MAILBOX-359 Factorize tests for Quota ser-deserialization
Project: http://git-wip-us.apache.org/repos/asf/james-project/repo Commit: http://git-wip-us.apache.org/repos/asf/james-project/commit/0a16e7ca Tree: http://git-wip-us.apache.org/repos/asf/james-project/tree/0a16e7ca Diff: http://git-wip-us.apache.org/repos/asf/james-project/diff/0a16e7ca Branch: refs/heads/master Commit: 0a16e7ca716984a3111cffd3c7a32a48b5c31268 Parents: 38ebe82 Author: Benoit Tellier <[email protected]> Authored: Mon Dec 24 16:31:11 2018 +0700 Committer: Benoit Tellier <[email protected]> Committed: Tue Jan 8 14:39:20 2019 +0700 ---------------------------------------------------------------------- .../json/MailboxDeletionSerializationTest.java | 144 +----- ...QuotaUsageUpdatedEventSerializationTest.java | 451 ++----------------- .../james/event/json/dtos/QuotaCountTest.java | 205 +++++++++ .../james/event/json/dtos/QuotaSizeTest.java | 199 ++++++++ 4 files changed, 438 insertions(+), 561 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/james-project/blob/0a16e7ca/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java ---------------------------------------------------------------------- diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java index 313dc33..b601f48 100644 --- a/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java +++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java @@ -88,86 +88,6 @@ class MailboxDeletionSerializationTest { } @Nested - class NullQuotaCountInDeletedMessageCount { - private final MailboxListener.MailboxDeletion unlimitedQuotaCountDeletedMessageEvent = new MailboxListener.MailboxDeletion( - SESSION_ID, - USER, - MAILBOX_PATH, - QUOTA_ROOT, - QuotaCount.unlimited(), - TOTAL_DELETED_SIZE, - MAILBOX_ID); - private final String nullQuotaCountInDeletedMessageCountEventJson = - "{" + - " \"MailboxDeletion\":{" + - " \"sessionId\":3652," + - " \"user\":\"user\"," + - " \"path\":{" + - " \"namespace\":\"#private\"," + - " \"user\":\"user\"," + - " \"name\":\"mailboxName\"" + - " }," + - " \"quotaRoot\":\"user@domain\"," + - " \"deletedMessageCount\":null," + - " \"totalDeletedSize\":100," + - " \"mailboxId\":\"789\"" + - " }" + - "}"; - - @Test - void mailboxAddedShouldBeWellSerializedWhenNullQuotaCount() { - assertThatJson(EVENT_SERIALIZER.toJson(unlimitedQuotaCountDeletedMessageEvent)) - .isEqualTo(nullQuotaCountInDeletedMessageCountEventJson); - } - - @Test - void mailboxAddedShouldBeWellDeSerializedWhenNullQuotaCount() { - assertThat(EVENT_SERIALIZER.fromJson(nullQuotaCountInDeletedMessageCountEventJson).get()) - .isEqualTo(unlimitedQuotaCountDeletedMessageEvent); - } - } - - @Nested - class NullQuotaSizeInTotalDeletedSize { - private final MailboxListener.MailboxDeletion unlimitedQuotaSizeDeletedSizeEvent = new MailboxListener.MailboxDeletion( - SESSION_ID, - USER, - MAILBOX_PATH, - QUOTA_ROOT, - DELETED_MESSAGE_COUNT, - QuotaSize.unlimited(), - MAILBOX_ID); - private final String nullQuotaSizeInTotalDeletedMessageEventJson = - "{" + - " \"MailboxDeletion\":{" + - " \"sessionId\":3652," + - " \"user\":\"user\"," + - " \"path\":{" + - " \"namespace\":\"#private\"," + - " \"user\":\"user\"," + - " \"name\":\"mailboxName\"" + - " }," + - " \"quotaRoot\":\"user@domain\"," + - " \"deletedMessageCount\":60," + - " \"totalDeletedSize\":null," + - " \"mailboxId\":\"789\"" + - " }" + - "}"; - - @Test - void mailboxAddedShouldBeWellSerializedWhenNullQuotaSize() { - assertThatJson(EVENT_SERIALIZER.toJson(unlimitedQuotaSizeDeletedSizeEvent)) - .isEqualTo(nullQuotaSizeInTotalDeletedMessageEventJson); - } - - @Test - void mailboxAddedShouldBeWellDeSerializedWhenNullQuotaSize() { - assertThat(EVENT_SERIALIZER.fromJson(nullQuotaSizeInTotalDeletedMessageEventJson).get()) - .isEqualTo(unlimitedQuotaSizeDeletedSizeEvent); - } - } - - @Nested class DeserializationErrors { @Test void mailboxAddedShouldThrowWhenMissingSessionId() { @@ -229,32 +149,10 @@ class MailboxDeletionSerializationTest { .isInstanceOf(NoSuchElementException.class); } - @Nested - class DeserializationErrorOnDeletedMessageCount { - @Test - void mailboxAddedShouldThrowWhenMissingQuotaCount() { - assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson( - "{" + - " \"MailboxDeletion\":{" + - " \"sessionId\":3652," + - " \"user\":\"user\"," + - " \"path\":{" + - " \"namespace\":\"#private\"," + - " \"user\":\"user\"," + - " \"name\":\"mailboxName\"" + - " }," + - " \"quotaRoot\":\"user@domain\"," + - " \"totalDeletedSize\":100," + - " \"mailboxId\":\"789\"" + - " }" + - "}").get()) - .isInstanceOf(NoSuchElementException.class); - } - - @Test - void mailboxAddedShouldThrowWhenQuotaCountIsNotANumber() { - assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson( - "{" + + @Test + void mailboxAddedShouldThrowWhenMissingQuotaCount() { + assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson( + "{" + " \"MailboxDeletion\":{" + " \"sessionId\":3652," + " \"user\":\"user\"," + @@ -264,41 +162,17 @@ class MailboxDeletionSerializationTest { " \"name\":\"mailboxName\"" + " }," + " \"quotaRoot\":\"user@domain\"," + - " \"deletedMessageCount\":\"60\"," + " \"totalDeletedSize\":100," + " \"mailboxId\":\"789\"" + " }" + "}").get()) .isInstanceOf(NoSuchElementException.class); - } } - @Nested - class DeserializationErrorOnTotalDeletedSize { - @Test - void mailboxAddedShouldThrowWhenMissingQuotaSize() { - assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson( - "{" + - " \"MailboxDeletion\":{" + - " \"sessionId\":3652," + - " \"user\":\"user\"," + - " \"path\":{" + - " \"namespace\":\"#private\"," + - " \"user\":\"user\"," + - " \"name\":\"mailboxName\"" + - " }," + - " \"quotaRoot\":\"user@domain\"," + - " \"deletedMessageCount\":60," + - " \"mailboxId\":\"789\"" + - " }" + - "}").get()) - .isInstanceOf(NoSuchElementException.class); - } - - @Test - void mailboxAddedShouldThrowWhenQuotaSizeIsNotANumber() { - assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson( - "{" + + @Test + void mailboxAddedShouldThrowWhenMissingQuotaSize() { + assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson( + "{" + " \"MailboxDeletion\":{" + " \"sessionId\":3652," + " \"user\":\"user\"," + @@ -309,12 +183,10 @@ class MailboxDeletionSerializationTest { " }," + " \"quotaRoot\":\"user@domain\"," + " \"deletedMessageCount\":60," + - " \"totalDeletedSize\":\"100\"," + " \"mailboxId\":\"789\"" + " }" + "}").get()) .isInstanceOf(NoSuchElementException.class); - } } @Test http://git-wip-us.apache.org/repos/asf/james-project/blob/0a16e7ca/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java ---------------------------------------------------------------------- diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java index 0e97545..608bee3 100644 --- a/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java +++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java @@ -34,12 +34,9 @@ import org.apache.james.core.quota.QuotaSize; import org.apache.james.mailbox.MailboxListener; import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; -import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; class QuotaUsageUpdatedEventSerializationTest { - - private static final User USER = User.fromUsername("user"); private static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("foo", Optional.empty()); private static final Quota<QuotaCount> QUOTA_COUNT = Quota.<QuotaCount>builder() .used(QuotaCount.count(12)) @@ -94,433 +91,37 @@ class QuotaUsageUpdatedEventSerializationTest { assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson(quotaUsageUpdatedEvent).get()) .isInstanceOf(NoSuchElementException.class); } - - @Nested - class WithQuotaCount { - - private MailboxListener.QuotaUsageUpdatedEvent quotaEventByQuotaCount(Quota<QuotaCount> countQuota) { - return new MailboxListener.QuotaUsageUpdatedEvent(USER, QUOTA_ROOT, countQuota, QUOTA_SIZE, INSTANT); - } - - @Nested - class LimitedQuotaCount { - - private Quota<QuotaCount> limitedQuotaCountByScopes(Quota.Scope scope) { - return Quota.<QuotaCount>builder() - .used(QuotaCount.count(12)) - .computedLimit(QuotaCount.count(100)) - .limitForScope(QuotaCount.count(100), scope) - .build(); - } - - @Nested - class LimitedQuotaGlobalScope { - - private final String limitedQuotaCountEventJsonGlobalScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{\"Global\":100}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(limitedQuotaCountByScopes(Quota.Scope.Global)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(limitedQuotaCountEventJsonGlobalScope); - } - - @Test - void fromJsonShouldDeserializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(limitedQuotaCountByScopes(Quota.Scope.Global)); - - assertThat(EVENT_SERIALIZER.fromJson(limitedQuotaCountEventJsonGlobalScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class LimitedQuotaDomainScope { - private final String limitedQuotaCountEventJsonDomainScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{\"Domain\":100}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(limitedQuotaCountByScopes(Quota.Scope.Domain)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(limitedQuotaCountEventJsonDomainScope); - } - - @Test - void fromJsonShouldDeserializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(limitedQuotaCountByScopes(Quota.Scope.Domain)); - - assertThat(EVENT_SERIALIZER.fromJson(limitedQuotaCountEventJsonDomainScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class LimitedQuotaUserScope { - private final String limitedQuotaCountEventJsonUserScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{\"User\":100}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(limitedQuotaCountByScopes(Quota.Scope.User)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(limitedQuotaCountEventJsonUserScope); - } - - @Test - void fromJsonShouldDeserializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(limitedQuotaCountByScopes(Quota.Scope.User)); - - assertThat(EVENT_SERIALIZER.fromJson(limitedQuotaCountEventJsonUserScope).get()) - .isEqualTo(quotaEvent); - } - } - } - - @Nested - class UnLimitedQuotaCount { - - private Quota<QuotaCount> unLimitedQuotaCountByScopes(Quota.Scope scope) { - return Quota.<QuotaCount>builder() - .used(QuotaCount.count(12)) - .computedLimit(QuotaCount.unlimited()) - .limitForScope(QuotaCount.unlimited(), scope) - .build(); - } - - @Nested - class UnLimitedQuotaGlobalScope { - private final String unLimitedQuotaCountEventJsonGlobalScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":null,\"limits\":{\"Global\":null}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(unLimitedQuotaCountByScopes(Quota.Scope.Global)); - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(unLimitedQuotaCountEventJsonGlobalScope); - } - - @Test - void fromJsonShouldDeserializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(unLimitedQuotaCountByScopes(Quota.Scope.Global)); - - assertThat(EVENT_SERIALIZER.fromJson(unLimitedQuotaCountEventJsonGlobalScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class UnLimitedQuotaDomainScope { - private final String unLimitedQuotaCountEventJsonDomainScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":null,\"limits\":{\"Domain\":null}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(unLimitedQuotaCountByScopes(Quota.Scope.Domain)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(unLimitedQuotaCountEventJsonDomainScope); - } - - @Test - void fromJsonShouldDeserializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(unLimitedQuotaCountByScopes(Quota.Scope.Domain)); - - assertThat(EVENT_SERIALIZER.fromJson(unLimitedQuotaCountEventJsonDomainScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class UnLimitedQuotaUserScope { - private final String unLimitedQuotaCountEventJsonUserScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":null,\"limits\":{\"User\":null}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(unLimitedQuotaCountByScopes(Quota.Scope.User)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(unLimitedQuotaCountEventJsonUserScope); - } - - @Test - void fromJsonShouldDeserializeQuotaCount() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaCount(unLimitedQuotaCountByScopes(Quota.Scope.User)); + @Test + void fromJsonShouldThrowWhenCountQuotaIsMissing() { + String quotaUsageUpdatedEvent = + "{" + + "\"QuotaUsageUpdatedEvent\":{" + + "\"quotaRoot\":\"foo\"," + + "\"time\":\"2018-11-13T12:00:55Z\"," + + "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{}}," + + "\"user\":\"onlyUsername\"" + + "}" + + "}"; - assertThat(EVENT_SERIALIZER.fromJson(unLimitedQuotaCountEventJsonUserScope).get()) - .isEqualTo(quotaEvent); - } - } - } + assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson(quotaUsageUpdatedEvent).get()) + .isInstanceOf(NoSuchElementException.class); } - - @Nested - class WithQuotaSize { - - private MailboxListener.QuotaUsageUpdatedEvent quotaEventByQuotaSize(Quota<QuotaSize> quotaSize) { - return new MailboxListener.QuotaUsageUpdatedEvent(USER, QUOTA_ROOT, QUOTA_COUNT, quotaSize, INSTANT); - } - - @Nested - class LimitedQuotaSize { - - private Quota<QuotaSize> limitedQuotaSizeByScopes(Quota.Scope scope) { - return Quota.<QuotaSize>builder() - .used(QuotaSize.size(1234)) - .computedLimit(QuotaSize.size(10000)) - .limitForScope(QuotaSize.size(10000), scope) - .build(); - } - - @Nested - class LimitedQuotaSizeGlobalScope { - - private final String limitedQuotaSizeEventJsonGlobalScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{\"Global\":10000}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(limitedQuotaSizeByScopes(Quota.Scope.Global)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(limitedQuotaSizeEventJsonGlobalScope); - } - - @Test - void fromJsonShouldDeserializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(limitedQuotaSizeByScopes(Quota.Scope.Global)); - - assertThat(EVENT_SERIALIZER.fromJson(limitedQuotaSizeEventJsonGlobalScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class LimitedQuotaSizeDomainScope { - private final String limitedQuotaSizeEventJsonDomainScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{\"Domain\":10000}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(limitedQuotaSizeByScopes(Quota.Scope.Domain)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(limitedQuotaSizeEventJsonDomainScope); - } - - @Test - void fromJsonShouldDeserializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(limitedQuotaSizeByScopes(Quota.Scope.Domain)); - - assertThat(EVENT_SERIALIZER.fromJson(limitedQuotaSizeEventJsonDomainScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class LimitedQuotaSizeUserScope { - private final String limitedQuotaSizeEventJsonUserScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":10000,\"limits\":{\"User\":10000}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(limitedQuotaSizeByScopes(Quota.Scope.User)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(limitedQuotaSizeEventJsonUserScope); - } - - @Test - void fromJsonShouldDeserializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(limitedQuotaSizeByScopes(Quota.Scope.User)); - - assertThat(EVENT_SERIALIZER.fromJson(limitedQuotaSizeEventJsonUserScope).get()) - .isEqualTo(quotaEvent); - } - } - } - - @Nested - class UnLimitedQuotaSize { - - private Quota<QuotaSize> unLimitedQuotaSizeByScopes(Quota.Scope scope) { - return Quota.<QuotaSize>builder() - .used(QuotaSize.size(1234)) - .computedLimit(QuotaSize.unlimited()) - .limitForScope(QuotaSize.unlimited(), scope) - .build(); - } - - @Nested - class UnLimitedQuotaSizeGlobalScope { - - private final String unLimitedQuotaSizeEventJsonGlobalScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":null,\"limits\":{\"Global\":null}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(unLimitedQuotaSizeByScopes(Quota.Scope.Global)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(unLimitedQuotaSizeEventJsonGlobalScope); - } - - @Test - void fromJsonShouldDeserializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(unLimitedQuotaSizeByScopes(Quota.Scope.Global)); - - assertThat(EVENT_SERIALIZER.fromJson(unLimitedQuotaSizeEventJsonGlobalScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class UnLimitedQuotaSizeDomainScope { - private final String unLimitedQuotaSizeEventJsonDomainScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":null,\"limits\":{\"Domain\":null}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(unLimitedQuotaSizeByScopes(Quota.Scope.Domain)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(unLimitedQuotaSizeEventJsonDomainScope); - } - - @Test - void fromJsonShouldDeserializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(unLimitedQuotaSizeByScopes(Quota.Scope.Domain)); - - assertThat(EVENT_SERIALIZER.fromJson(unLimitedQuotaSizeEventJsonDomainScope).get()) - .isEqualTo(quotaEvent); - } - } - - @Nested - class UnLimitedQuotaSizeUserScope { - private final String unLimitedQuotaSizeEventJsonUserScope = - "{" + - "\"QuotaUsageUpdatedEvent\":{" + - "\"quotaRoot\":\"foo\"," + - "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{}}," + - "\"time\":\"2018-11-13T12:00:55Z\"," + - "\"sizeQuota\":{\"used\":1234,\"limit\":null,\"limits\":{\"User\":null}}," + - "\"user\":\"user\"" + - "}" + - "}"; - - @Test - void toJsonShouldSerializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(unLimitedQuotaSizeByScopes(Quota.Scope.User)); - - assertThatJson(EVENT_SERIALIZER.toJson(quotaEvent)) - .isEqualTo(unLimitedQuotaSizeEventJsonUserScope); - } - - @Test - void fromJsonShouldDeserializeQuotaSize() { - MailboxListener.QuotaUsageUpdatedEvent quotaEvent = quotaEventByQuotaSize(unLimitedQuotaSizeByScopes(Quota.Scope.User)); + @Test + void fromJsonShouldThrowWhenSizeQuotaIsMissing() { + String quotaUsageUpdatedEvent = + "{" + + "\"QuotaUsageUpdatedEvent\":{" + + "\"quotaRoot\":\"foo\"," + + "\"time\":\"2018-11-13T12:00:55Z\"," + + "\"countQuota\":{\"used\":12,\"limit\":100,\"limits\":{}}," + + "\"user\":\"onlyUsername\"" + + "}" + + "}"; - assertThat(EVENT_SERIALIZER.fromJson(unLimitedQuotaSizeEventJsonUserScope).get()) - .isEqualTo(quotaEvent); - } - } - } + assertThatThrownBy(() -> EVENT_SERIALIZER.fromJson(quotaUsageUpdatedEvent).get()) + .isInstanceOf(NoSuchElementException.class); } @Test http://git-wip-us.apache.org/repos/asf/james-project/blob/0a16e7ca/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java ---------------------------------------------------------------------- diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java new file mode 100644 index 0000000..88adaa6 --- /dev/null +++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java @@ -0,0 +1,205 @@ +/**************************************************************** + * Licensed to the Apache Software Foundation (ASF) under one * + * or more contributor license agreements. See the NOTICE file * + * distributed with this work for additional information * + * regarding copyright ownership. The ASF licenses this file * + * to you under the Apache License, Version 2.0 (the * + * "License"); you may not use this file except in compliance * + * with the License. You may obtain a copy of the License at * + * * + * http://www.apache.org/licenses/LICENSE-2.0 * + * * + * Unless required by applicable law or agreed to in writing, * + * software distributed under the License is distributed on an * + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * + * KIND, either express or implied. See the License for the * + * specific language governing permissions and limitations * + * under the License. * + ****************************************************************/ + +package org.apache.james.event.json.dtos; + +import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson; +import static org.apache.james.event.json.SerializerFixture.DTO_JSON_SERIALIZE; +import static org.assertj.core.api.Assertions.assertThat; + +import org.apache.james.core.quota.QuotaCount; +import org.apache.james.event.json.DTOs; +import org.apache.james.mailbox.model.Quota; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import play.api.libs.json.JsError; +import play.api.libs.json.JsNull$; +import play.api.libs.json.JsNumber; +import play.api.libs.json.JsString; +import play.api.libs.json.Json; +import scala.math.BigDecimal; + +class QuotaCountTest { + @Test + void quotaCountShouldBeWellSerialized() { + assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaCount.count(18))) + .isEqualTo(new JsNumber(BigDecimal.valueOf(18))); + } + + @Test + void quotaCountShouldBeWellDeSerialized() { + assertThat(DTO_JSON_SERIALIZE.quotaCountReads().reads(new JsNumber(BigDecimal.valueOf(18))).get()) + .isEqualTo(QuotaCount.count(18)); + } + + @Test + void quotaCountShouldBeWellSerializedWhenUnlimited() { + assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaCount.unlimited())) + .isEqualTo(JsNull$.MODULE$); + } + + @Test + void quotaCountShouldBeWellDeSerializedWhenUnlimited() { + assertThat(DTO_JSON_SERIALIZE.quotaCountReads().reads(JsNull$.MODULE$).get()) + .isEqualTo(QuotaCount.unlimited()); + } + + @Test + void quotaCountShouldReturnErrorWhenString() { + assertThat(DTO_JSON_SERIALIZE.quotaCountReads().reads(new JsString("18"))) + .isInstanceOf(JsError.class); + } + + @Nested + class LimitedQuotaCount { + private Quota<QuotaCount> limitedQuotaCountByScopes(Quota.Scope scope) { + return Quota.<QuotaCount>builder() + .used(QuotaCount.count(12)) + .computedLimit(QuotaCount.count(100)) + .limitForScope(QuotaCount.count(100), scope) + .build(); + } + + @Nested + class LimitedQuotaGlobalScope { + private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Global\":100}}"; + private final Quota<QuotaCount> quota = limitedQuotaCountByScopes(Quota.Scope.Global); + + @Test + void toJsonShouldSerializeQuotaCount() { + assertThatJson(DTO_JSON_SERIALIZE.quotaCountWrites().writes(DTOs.Quota$.MODULE$.toScala( + quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaCount() { + assertThat(DTO_JSON_SERIALIZE.quotaCReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class LimitedQuotaDomainScope { + private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Domain\":100}}"; + private final Quota<QuotaCount> quota = limitedQuotaCountByScopes(Quota.Scope.Domain); + + @Test + void toJsonShouldSerializeQuotaCount() { + assertThatJson(DTO_JSON_SERIALIZE.quotaCountWrites().writes(DTOs.Quota$.MODULE$.toScala( + quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaCount() { + assertThat(DTO_JSON_SERIALIZE.quotaCReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class LimitedQuotaUserScope { + private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"User\":100}}"; + private final Quota<QuotaCount> quota = limitedQuotaCountByScopes(Quota.Scope.User); + + @Test + void toJsonShouldSerializeQuotaCount() { + assertThatJson(DTO_JSON_SERIALIZE.quotaCountWrites().writes(DTOs.Quota$.MODULE$.toScala( + quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaCount() { + assertThat(DTO_JSON_SERIALIZE.quotaCReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + } + + @Nested + class UnLimitedQuotaCount { + private Quota<QuotaCount> unLimitedQuotaCountByScopes(Quota.Scope scope) { + return Quota.<QuotaCount>builder() + .used(QuotaCount.count(12)) + .computedLimit(QuotaCount.unlimited()) + .limitForScope(QuotaCount.unlimited(), scope) + .build(); + } + + @Nested + class UnLimitedQuotaGlobalScope { + private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Global\":null}}"; + private final Quota<QuotaCount> quota = unLimitedQuotaCountByScopes(Quota.Scope.Global); + + @Test + void toJsonShouldSerializeQuotaCount() { + assertThatJson(DTO_JSON_SERIALIZE.quotaCountWrites().writes(DTOs.Quota$.MODULE$.toScala( + quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaCount() { + assertThat(DTO_JSON_SERIALIZE.quotaCReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class UnLimitedQuotaDomainScope { + private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Domain\":null}}"; + private final Quota<QuotaCount> quota = unLimitedQuotaCountByScopes(Quota.Scope.Domain); + + @Test + void toJsonShouldSerializeQuotaCount() { + assertThatJson(DTO_JSON_SERIALIZE.quotaCountWrites().writes(DTOs.Quota$.MODULE$.toScala( + quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaCount() { + assertThat(DTO_JSON_SERIALIZE.quotaCReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class UnLimitedQuotaUserScope { + private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"User\":null}}"; + private final Quota<QuotaCount> quota = unLimitedQuotaCountByScopes(Quota.Scope.User); + + @Test + void toJsonShouldSerializeQuotaCount() { + assertThatJson(DTO_JSON_SERIALIZE.quotaCountWrites().writes(DTOs.Quota$.MODULE$.toScala( + quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaCount() { + assertThat(DTO_JSON_SERIALIZE.quotaCReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + } +} http://git-wip-us.apache.org/repos/asf/james-project/blob/0a16e7ca/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java ---------------------------------------------------------------------- diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java new file mode 100644 index 0000000..5940f13 --- /dev/null +++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java @@ -0,0 +1,199 @@ +/**************************************************************** + * Licensed to the Apache Software Foundation (ASF) under one * + * or more contributor license agreements. See the NOTICE file * + * distributed with this work for additional information * + * regarding copyright ownership. The ASF licenses this file * + * to you under the Apache License, Version 2.0 (the * + * "License"); you may not use this file except in compliance * + * with the License. You may obtain a copy of the License at * + * * + * http://www.apache.org/licenses/LICENSE-2.0 * + * * + * Unless required by applicable law or agreed to in writing, * + * software distributed under the License is distributed on an * + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * + * KIND, either express or implied. See the License for the * + * specific language governing permissions and limitations * + * under the License. * + ****************************************************************/ + +package org.apache.james.event.json.dtos; + +import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson; +import static org.apache.james.event.json.SerializerFixture.DTO_JSON_SERIALIZE; +import static org.assertj.core.api.Assertions.assertThat; + +import org.apache.james.core.quota.QuotaSize; +import org.apache.james.event.json.DTOs; +import org.apache.james.mailbox.model.Quota; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import play.api.libs.json.JsError; +import play.api.libs.json.JsNull$; +import play.api.libs.json.JsNumber; +import play.api.libs.json.JsString; +import play.api.libs.json.Json; +import scala.math.BigDecimal; + +class QuotaSizeTest { + @Test + void quotaSizeShouldBeWellSerialized() { + assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaSize.size(18))) + .isEqualTo(new JsNumber(BigDecimal.valueOf(18))); + } + + @Test + void quotaSizeShouldBeWellDeSerialized() { + assertThat(DTO_JSON_SERIALIZE.quotaSizeReads().reads(new JsNumber(BigDecimal.valueOf(18))).get()) + .isEqualTo(QuotaSize.size(18)); + } + + @Test + void quotaSizeShouldBeWellSerializedWhenUnlimited() { + assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaSize.unlimited())) + .isEqualTo(JsNull$.MODULE$); + } + + @Test + void quotaSizeShouldBeWellDeSerializedWhenUnlimited() { + assertThat(DTO_JSON_SERIALIZE.quotaSizeReads().reads(JsNull$.MODULE$).get()) + .isEqualTo(QuotaSize.unlimited()); + } + + @Test + void quotaSizeShouldReturnErrorWhenString() { + assertThat(DTO_JSON_SERIALIZE.quotaSizeReads().reads(new JsString("18"))) + .isInstanceOf(JsError.class); + } + + @Nested + class LimitedQuotaSize { + private Quota<QuotaSize> limitedQuotaSizeByScopes(Quota.Scope scope) { + return Quota.<QuotaSize>builder() + .used(QuotaSize.size(12)) + .computedLimit(QuotaSize.size(100)) + .limitForScope(QuotaSize.size(100), scope) + .build(); + } + + @Nested + class LimitedQuotaGlobalScope { + private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Global\":100}}"; + private final Quota<QuotaSize> quota = limitedQuotaSizeByScopes(Quota.Scope.Global); + + @Test + void toJsonShouldSerializeQuotaSize() { + assertThatJson(DTO_JSON_SERIALIZE.quotaSizeWrites().writes(DTOs.Quota$.MODULE$.toScala(quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaSize() { + assertThat(DTO_JSON_SERIALIZE.quotaSReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class LimitedQuotaDomainScope { + private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Domain\":100}}"; + private final Quota<QuotaSize> quota = limitedQuotaSizeByScopes(Quota.Scope.Domain); + + @Test + void toJsonShouldSerializeQuotaSize() { + assertThatJson(DTO_JSON_SERIALIZE.quotaSizeWrites().writes(DTOs.Quota$.MODULE$.toScala(quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaSize() { + assertThat(DTO_JSON_SERIALIZE.quotaSReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class LimitedQuotaUserScope { + private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"User\":100}}"; + private final Quota<QuotaSize> quota = limitedQuotaSizeByScopes(Quota.Scope.User); + + @Test + void toJsonShouldSerializeQuotaSize() { + assertThatJson(DTO_JSON_SERIALIZE.quotaSizeWrites().writes(DTOs.Quota$.MODULE$.toScala(quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaSize() { + assertThat(DTO_JSON_SERIALIZE.quotaSReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + } + + @Nested + class UnLimitedQuotaSize { + private Quota<QuotaSize> unLimitedQuotaSizeByScopes(Quota.Scope scope) { + return Quota.<QuotaSize>builder() + .used(QuotaSize.size(12)) + .computedLimit(QuotaSize.unlimited()) + .limitForScope(QuotaSize.unlimited(), scope) + .build(); + } + + @Nested + class UnLimitedQuotaGlobalScope { + private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Global\":null}}"; + private final Quota<QuotaSize> quota = unLimitedQuotaSizeByScopes(Quota.Scope.Global); + + @Test + void toJsonShouldSerializeQuotaSize() { + assertThatJson(DTO_JSON_SERIALIZE.quotaSizeWrites().writes(DTOs.Quota$.MODULE$.toScala(quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaSize() { + assertThat(DTO_JSON_SERIALIZE.quotaSReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class UnLimitedQuotaDomainScope { + private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Domain\":null}}"; + private final Quota<QuotaSize> quota = unLimitedQuotaSizeByScopes(Quota.Scope.Domain); + + @Test + void toJsonShouldSerializeQuotaSize() { + assertThatJson(DTO_JSON_SERIALIZE.quotaSizeWrites().writes(DTOs.Quota$.MODULE$.toScala(quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaSize() { + assertThat(DTO_JSON_SERIALIZE.quotaSReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + + @Nested + class UnLimitedQuotaUserScope { + private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"User\":null}}"; + private final Quota<QuotaSize> quota = unLimitedQuotaSizeByScopes(Quota.Scope.User); + + @Test + void toJsonShouldSerializeQuotaSize() { + assertThatJson(DTO_JSON_SERIALIZE.quotaSizeWrites().writes(DTOs.Quota$.MODULE$.toScala(quota)).toString()) + .isEqualTo(json); + } + + @Test + void fromJsonShouldDeserializeQuotaSize() { + assertThat(DTO_JSON_SERIALIZE.quotaSReads().reads(Json.parse(json)).get().toJava()) + .isEqualTo(quota); + } + } + } +} --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
