diff --git a/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/EmptyTopicPath.java b/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/EmptyTopicPath.java deleted file mode 100644 index d363287301..0000000000 --- a/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/EmptyTopicPath.java +++ /dev/null @@ -1,151 +0,0 @@ -/* - * Copyright (c) 2021 Contributors to the Eclipse Foundation - * - * See the NOTICE file(s) distributed with this work for additional - * information regarding copyright ownership. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License 2.0 which is available at - * http://www.eclipse.org/legal/epl-2.0 - * - * SPDX-License-Identifier: EPL-2.0 - */ -package org.eclipse.ditto.protocoladapter; - -import java.util.Optional; - -import javax.annotation.Nullable; -import javax.annotation.concurrent.Immutable; - -/** - * Implementation of an empty {@link TopicPath}. - */ -@Immutable -final class EmptyTopicPath implements TopicPath { - - private EmptyTopicPath() { - super(); - } - - /** - * Returns an instance of {@code EmptyTopicPath}. - * - * @return the instance. - */ - static EmptyTopicPath getInstance() { - return new EmptyTopicPath(); - } - - /** - * @return always {@code null}. - */ - @Override - @Nullable - public String getNamespace() { - return null; - } - - /** - * @return always {@code null}. - */ - @Override - @Nullable - public String getEntityName() { - return null; - } - - /** - * @return always {@code null}. - */ - @Override - @Nullable - public Group getGroup() { - return null; - } - - /** - * @return always {@code null}. - */ - @Override - @Nullable - public Criterion getCriterion() { - return null; - } - - /** - * @return always {@code null}. - */ - @Override - @Nullable - public Channel getChannel() { - return null; - } - - /** - * @return always an empty Optional. - */ - @Override - public Optional getAction() { - return Optional.empty(); - } - - /** - * @return always an empty Optional. - */ - @Override - public Optional getSearchAction() { - return Optional.empty(); - } - - /** - * @return always an empty Optional. - */ - @Override - public Optional getSubject() { - return Optional.empty(); - } - - /** - * @return always an empty String. - */ - @Override - public String getPath() { - return ""; - } - - @Override - public boolean isGroup(@Nullable final Group expectedGroup) { - return false; - } - - @Override - public boolean isChannel(@Nullable final Channel expectedChannel) { - return false; - } - - @Override - public boolean isCriterion(@Nullable final Criterion expectedCriterion) { - return false; - } - - @Override - public boolean isAction(@Nullable final Action expectedAction) { - return false; - } - - @Override - public boolean equals(@Nullable final Object o) { - return this == o || !(o == null || getClass() != o.getClass()); - } - - @Override - public int hashCode() { - return EmptyTopicPath.class.hashCode(); - } - - @Override - public String toString() { - return getClass().getSimpleName() + "[]"; - } - -} diff --git a/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptable.java b/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptable.java index bd810926ee..39812ae6a6 100755 --- a/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptable.java +++ b/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptable.java @@ -19,9 +19,7 @@ import javax.annotation.Nonnull; import javax.annotation.concurrent.Immutable; -import org.eclipse.ditto.json.JsonFactory; import org.eclipse.ditto.json.JsonObject; -import org.eclipse.ditto.json.JsonObjectBuilder; import org.eclipse.ditto.model.base.exceptions.DittoRuntimeException; import org.eclipse.ditto.model.base.headers.DittoHeaders; @@ -62,18 +60,21 @@ public static ImmutableJsonifiableAdaptable fromJson(final JsonObject jsonObject .map(ProtocolFactory::newHeaders) .orElse(DittoHeaders.empty()); - final TopicPath topicPath; + return new ImmutableJsonifiableAdaptable(ImmutableAdaptable.of(tryToDeserializeTopicPath(jsonObject, headers), + ProtocolFactory.newPayload(jsonObject), + headers)); + } + private static TopicPath tryToDeserializeTopicPath(final JsonObject jsonObject, final DittoHeaders dittoHeaders) { try { - topicPath = jsonObject.getValue(JsonFields.TOPIC) - .map(ProtocolFactory::newTopicPath) - .orElseGet(ProtocolFactory::emptyTopicPath); + return deserializeTopicPath(jsonObject); } catch (final DittoRuntimeException e) { - throw e.setDittoHeaders(headers); + throw e.setDittoHeaders(dittoHeaders); } + } - return new ImmutableJsonifiableAdaptable(ImmutableAdaptable.of(topicPath, - ProtocolFactory.newPayload(jsonObject), headers)); + private static TopicPath deserializeTopicPath(final JsonObject jsonObject) { + return ProtocolFactory.newTopicPath(jsonObject.getValueOrThrow(JsonFields.TOPIC)); } @Override @@ -98,11 +99,8 @@ public JsonObject toJson() { @Override public JsonObject toJson(final DittoHeaders specificHeaders) { - final JsonObjectBuilder jsonObjectBuilder = JsonFactory.newObjectBuilder(); - if (!getTopicPath().equals(ProtocolFactory.emptyTopicPath())) { - jsonObjectBuilder.set(JsonFields.TOPIC, getTopicPath().getPath()); - } - return jsonObjectBuilder + return JsonObject.newBuilder() + .set(JsonFields.TOPIC, getTopicPath().getPath()) .set(JsonFields.HEADERS, specificHeaders.toJson()) .setAll(getPayload().toJson()) .build(); diff --git a/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ProtocolFactory.java b/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ProtocolFactory.java index 229bbb6d6c..8b5eb735a2 100644 --- a/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ProtocolFactory.java +++ b/protocol-adapter/src/main/java/org/eclipse/ditto/protocoladapter/ProtocolFactory.java @@ -76,15 +76,6 @@ public static Adaptable setExtra(final Adaptable existingAdaptable, final JsonOb .build(); } - /** - * Returns an empty {@code TopicPath}. - * - * @return the topic path. - */ - public static TopicPath emptyTopicPath() { - return EmptyTopicPath.getInstance(); - } - /** * Parses the string argument as a {@link TopicPath}. * diff --git a/protocol-adapter/src/test/java/org/eclipse/ditto/protocoladapter/EmptyTopicPathTest.java b/protocol-adapter/src/test/java/org/eclipse/ditto/protocoladapter/EmptyTopicPathTest.java deleted file mode 100644 index 823ad98ba5..0000000000 --- a/protocol-adapter/src/test/java/org/eclipse/ditto/protocoladapter/EmptyTopicPathTest.java +++ /dev/null @@ -1,135 +0,0 @@ -/* - * Copyright (c) 2021 Contributors to the Eclipse Foundation - * - * See the NOTICE file(s) distributed with this work for additional - * information regarding copyright ownership. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License 2.0 which is available at - * http://www.eclipse.org/legal/epl-2.0 - * - * SPDX-License-Identifier: EPL-2.0 - */ -package org.eclipse.ditto.protocoladapter; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mutabilitydetector.unittesting.MutabilityAssert.assertInstancesOf; -import static org.mutabilitydetector.unittesting.MutabilityMatchers.areImmutable; - -import org.assertj.core.api.JUnitSoftAssertions; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; - -import nl.jqno.equalsverifier.EqualsVerifier; - -/** - * Unit test for {@link EmptyTopicPathTest}. - */ -public final class EmptyTopicPathTest { - - @Rule - public final JUnitSoftAssertions softly = new JUnitSoftAssertions(); - - private EmptyTopicPath underTest; - - @Before - public void setUp() { - underTest = EmptyTopicPath.getInstance(); - } - - @Test - public void assertImmutability() { - assertInstancesOf(EmptyTopicPath.class, areImmutable()); - } - - @Test - public void testHashCodeAndEquals() { - EqualsVerifier.forClass(EmptyTopicPath.class) - .usingGetClass() - .verify(); - } - - @Test - public void getInstanceReturnsNotNull() { - assertThat(EmptyTopicPath.getInstance()).isNotNull(); - } - - @Test - public void getNamespaceReturnsNull() { - assertThat(underTest.getNamespace()).isNull(); - } - - @Test - public void getEntityNameReturnsNull() { - assertThat(underTest.getEntityName()).isNull(); - } - - @Test - public void getGroupReturnsNull() { - assertThat(underTest.getGroup()).isNull(); - } - - @Test - public void getCriterionReturnsNull() { - assertThat(underTest.getCriterion()).isNull(); - } - - @Test - public void getChannelReturnsNull() { - assertThat(underTest.getChannel()).isNull(); - } - - @Test - public void getActionReturnsEmptyOptional() { - assertThat(underTest.getAction()).isEmpty(); - } - - @Test - public void getSearchActionReturnsEmptyOptional() { - assertThat(underTest.getSearchAction()).isEmpty(); - } - - @Test - public void getSubjectReturnsEmptyOptional() { - assertThat(underTest.getSubject()).isEmpty(); - } - - @Test - public void getPathReturnsEmptyString() { - assertThat(underTest.getPath()).isEmpty(); - } - - @Test - public void isGroupReturnsExpected() { - softly.assertThat(underTest.isGroup(null)).as("null group").isFalse(); - for (final TopicPath.Group group : TopicPath.Group.values()) { - softly.assertThat(underTest.isGroup(group)).as(group.getName()).isFalse(); - } - } - - @Test - public void isChannelReturnsExpected() { - softly.assertThat(underTest.isChannel(null)).as("null channel").isFalse(); - for (final TopicPath.Channel channel : TopicPath.Channel.values()) { - softly.assertThat(underTest.isChannel(channel)).as(channel.getName()).isFalse(); - } - } - - @Test - public void isCriterionReturnsExpected() { - softly.assertThat(underTest.isCriterion(null)).as("null criterion").isFalse(); - for (final TopicPath.Criterion criterion : TopicPath.Criterion.values()) { - softly.assertThat(underTest.isCriterion(criterion)).as(criterion.getName()).isFalse(); - } - } - - @Test - public void isActionReturnsExpected() { - softly.assertThat(underTest.isAction(null)).as("null action").isFalse(); - for (final TopicPath.Action group : TopicPath.Action.values()) { - softly.assertThat(underTest.isAction(group)).as(group.getName()).isFalse(); - } - } - -} \ No newline at end of file diff --git a/protocol-adapter/src/test/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptableTest.java b/protocol-adapter/src/test/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptableTest.java index f5eac36e97..301b93a381 100755 --- a/protocol-adapter/src/test/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptableTest.java +++ b/protocol-adapter/src/test/java/org/eclipse/ditto/protocoladapter/ImmutableJsonifiableAdaptableTest.java @@ -13,19 +13,22 @@ package org.eclipse.ditto.protocoladapter; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; import static org.mutabilitydetector.unittesting.AllowedReason.provided; import static org.mutabilitydetector.unittesting.MutabilityAssert.assertInstancesOf; import static org.mutabilitydetector.unittesting.MutabilityMatchers.areImmutable; import java.time.Instant; +import java.util.NoSuchElementException; +import org.assertj.core.api.AutoCloseableSoftAssertions; import org.eclipse.ditto.json.JsonFieldSelector; +import org.eclipse.ditto.json.JsonMissingFieldException; import org.eclipse.ditto.json.JsonObject; import org.eclipse.ditto.json.JsonPointer; import org.eclipse.ditto.json.JsonValue; import org.eclipse.ditto.model.base.common.HttpStatus; import org.eclipse.ditto.model.base.entity.metadata.Metadata; -import org.eclipse.ditto.model.base.headers.DittoHeaderDefinition; import org.eclipse.ditto.model.base.headers.DittoHeaders; import org.junit.BeforeClass; import org.junit.Test; @@ -38,9 +41,9 @@ public final class ImmutableJsonifiableAdaptableTest { private static final String KNOWN_TOPIC = "org.eclipse.ditto/myThing/things/twin/commands/modify"; - private static final JsonObject KNOWN_HEADERS = JsonObject.newBuilder() - .set(DittoHeaderDefinition.CORRELATION_ID.getKey(), "cor-id") - .set(DittoHeaderDefinition.RESPONSE_REQUIRED.getKey(), true) + private static final DittoHeaders KNOWN_HEADERS = DittoHeaders.newBuilder() + .correlationId("cor-id") + .responseRequired(true) .build(); private static final JsonPointer KNOWN_PATH = JsonPointer.empty(); @@ -104,7 +107,7 @@ public void tryToCreateInstanceWithNullAdaptable() { public void jsonSerializationWorksAsExpected() { final JsonObject expected = JsonObject.newBuilder() .set(JsonifiableAdaptable.JsonFields.TOPIC, KNOWN_TOPIC) - .set(JsonifiableAdaptable.JsonFields.HEADERS, KNOWN_HEADERS) + .set(JsonifiableAdaptable.JsonFields.HEADERS, KNOWN_HEADERS.toJson()) .set(Payload.JsonFields.PATH, KNOWN_PATH.toString()) .set(Payload.JsonFields.VALUE, KNOWN_VALUE) .set(Payload.JsonFields.EXTRA, knownExtra) @@ -115,8 +118,8 @@ public void jsonSerializationWorksAsExpected() { .set(Payload.JsonFields.FIELDS, KNOWN_FIELDS.toString()) .build(); - final Adaptable adaptable = ImmutableAdaptable.of(ProtocolFactory.newTopicPath(KNOWN_TOPIC), knownPayload, - DittoHeaders.newBuilder(KNOWN_HEADERS).build()); + final Adaptable adaptable = + ImmutableAdaptable.of(ProtocolFactory.newTopicPath(KNOWN_TOPIC), knownPayload, KNOWN_HEADERS); final JsonifiableAdaptable jsonifiableAdaptable = ImmutableJsonifiableAdaptable.of(adaptable); final JsonObject actual = jsonifiableAdaptable.toJson().asObject(); @@ -126,13 +129,13 @@ public void jsonSerializationWorksAsExpected() { @Test public void jsonDeserializationWorksAsExpected() { - final Adaptable adaptable = ImmutableAdaptable.of(ProtocolFactory.newTopicPath(KNOWN_TOPIC), knownPayload, - DittoHeaders.newBuilder(KNOWN_HEADERS).build()); + final Adaptable adaptable = + ImmutableAdaptable.of(ProtocolFactory.newTopicPath(KNOWN_TOPIC), knownPayload, KNOWN_HEADERS); final JsonifiableAdaptable expected = ImmutableJsonifiableAdaptable.of(adaptable); final JsonObject payloadJsonObject = JsonObject.newBuilder() .set(JsonifiableAdaptable.JsonFields.TOPIC, KNOWN_TOPIC) - .set(JsonifiableAdaptable.JsonFields.HEADERS, KNOWN_HEADERS) + .set(JsonifiableAdaptable.JsonFields.HEADERS, KNOWN_HEADERS.toJson()) .set(Payload.JsonFields.PATH, KNOWN_PATH.toString()) .set(Payload.JsonFields.VALUE, KNOWN_VALUE) .set(Payload.JsonFields.EXTRA, knownExtra) @@ -148,4 +151,41 @@ public void jsonDeserializationWorksAsExpected() { assertThat(actual).isEqualTo(expected); } + @Test + public void deserializeJsonWithoutTopicPathFails() { + final JsonObject invalidJsonObject = JsonObject.newBuilder() + .set(JsonifiableAdaptable.JsonFields.HEADERS, KNOWN_HEADERS.toJson()) + .build(); + + assertThatExceptionOfType(JsonMissingFieldException.class) + .isThrownBy(() -> ImmutableJsonifiableAdaptable.fromJson(invalidJsonObject)) + .withMessageContaining(JsonifiableAdaptable.JsonFields.TOPIC.getPointer().toString()) + .withNoCause(); + } + + @Test + public void deserializeJsonWithInvalidTopicPathFails() { + final String invalidTopicPath = "abc"; + final JsonObject invalidJsonObject = JsonObject.newBuilder() + .set(JsonifiableAdaptable.JsonFields.HEADERS, KNOWN_HEADERS.toJson()) + .set(JsonifiableAdaptable.JsonFields.TOPIC, invalidTopicPath) + .build(); + + assertThatExceptionOfType(UnknownTopicPathException.class) + .isThrownBy(() -> ImmutableJsonifiableAdaptable.fromJson(invalidJsonObject)) + .satisfies(unknownTopicPathException -> { + try (final AutoCloseableSoftAssertions softly = new AutoCloseableSoftAssertions()) { + softly.assertThat(unknownTopicPathException.getDittoHeaders()) + .as("DittoHeaders") + .isEqualTo(KNOWN_HEADERS); + softly.assertThat(unknownTopicPathException.getDescription()) + .as("description") + .hasValue("The topic path has no entity name part."); + softly.assertThat(unknownTopicPathException.getCause()) + .as("cause") + .isInstanceOf(NoSuchElementException.class); + } + }); + } + } diff --git a/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/DittoMessageMapperTest.java b/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/DittoMessageMapperTest.java index bf86256f53..e8801361a1 100644 --- a/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/DittoMessageMapperTest.java +++ b/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/DittoMessageMapperTest.java @@ -12,18 +12,14 @@ */ package org.eclipse.ditto.services.connectivity.mapping; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; - import java.util.AbstractMap; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; -import java.util.stream.Collectors; -import java.util.stream.Stream; +import org.assertj.core.api.JUnitSoftAssertions; import org.eclipse.ditto.json.JsonFactory; import org.eclipse.ditto.json.JsonMissingFieldException; import org.eclipse.ditto.json.JsonObject; @@ -39,8 +35,8 @@ import org.eclipse.ditto.protocoladapter.ProtocolFactory; import org.eclipse.ditto.services.models.connectivity.ExternalMessage; import org.eclipse.ditto.services.models.connectivity.ExternalMessageFactory; -import org.junit.After; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; /** @@ -48,6 +44,9 @@ */ public final class DittoMessageMapperTest { + @Rule + public final JUnitSoftAssertions softly = new JUnitSoftAssertions(); + private DittoMessageMapper underTest; @Before @@ -55,37 +54,30 @@ public void setUp() { underTest = new DittoMessageMapper(); } - @After - public void tearDown() { - } - @Test public void mapMessage() { - createValidIncomingMappings().forEach((in, out) -> assertThat(underTest.map(in)).isEqualTo(out)); + final var validMapping = valid1(); + softly.assertThat(underTest.map(validMapping.getKey())).isEqualTo(validMapping.getValue()); } @Test public void mapMessageFails() { - createInvalidIncomingMappings().forEach((in, e) -> assertThatExceptionOfType(e.getClass()).isThrownBy( - () -> underTest.map(in))); + final var invalidIncomingMappings = createInvalidIncomingMappings(); + invalidIncomingMappings.forEach( + (in, e) -> softly.assertThatThrownBy(() -> underTest.map(in)).hasSameClassAs(e)); } @Test public void mapAdaptable() { - createValidOutgoingMappings().forEach((in, out) -> assertThat(underTest.map(in)).isEqualTo(out)); + final var validOutgoingMappings = createValidOutgoingMappings(); + validOutgoingMappings.forEach((in, out) -> softly.assertThat(underTest.map(in)).isEqualTo(out)); } @Test public void mapAdaptableFails() { - createInvalidOutgoingMappings().forEach((in, e) -> assertThatExceptionOfType(e.getClass()).isThrownBy( - () -> underTest.map(in))); - } - - private static Map> createValidIncomingMappings() { - return Stream.of( - valid1(), - valid2() - ).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + final var invalidOutgoingMappings = createInvalidOutgoingMappings(); + invalidOutgoingMappings.forEach( + (in, e) -> softly.assertThatThrownBy(() -> underTest.map(in)).hasSameClassAs(e)); } private static Map.Entry> valid1() { @@ -115,24 +107,6 @@ private static Map.Entry> valid1() { return new AbstractMap.SimpleEntry<>(message, expected); } - private static Map.Entry> valid2() { - final Map headers = new HashMap<>(); - headers.put("header-key", "header-value"); - headers.put(ExternalMessage.CONTENT_TYPE_HEADER, DittoConstants.DITTO_PROTOCOL_CONTENT_TYPE); - - final JsonObject json = JsonFactory.newObjectBuilder() - .set("path", "/some/path") - .build(); - - final List expected = Collections.singletonList( - ProtocolFactory.newAdaptableBuilder(ProtocolFactory.jsonifiableAdaptableFromJson(json)) - .build()); - final ExternalMessage message = ExternalMessageFactory.newExternalMessageBuilder(headers) - .withText(json.toString()) - .build(); - return new AbstractMap.SimpleEntry<>(message, expected); - } - private static Map createInvalidIncomingMappings() { final Map mappings = new HashMap<>(); @@ -151,8 +125,14 @@ private static Map createInvalidIncomingMappings() { message = ExternalMessageFactory.newExternalMessageBuilder(headers) .withText("no json") .build(); - mappings.put(message, new DittoJsonException( - new JsonParseException("Failed to create JSON object from string!"))); + mappings.put(message, + new DittoJsonException(new JsonParseException("Failed to create JSON object from string!"))); + + message = ExternalMessageFactory.newExternalMessageBuilder(headers) + .withText(String.valueOf(JsonObject.newBuilder().set("myKey", "myValue").build())) + .build(); + mappings.put(message, + new DittoJsonException(new JsonMissingFieldException(JsonifiableAdaptable.JsonFields.TOPIC))); return mappings; } diff --git a/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/WrappingMessageMapperTest.java b/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/WrappingMessageMapperTest.java index 03cc33b8d2..04dbeb3c22 100644 --- a/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/WrappingMessageMapperTest.java +++ b/services/connectivity/mapping/src/test/java/org/eclipse/ditto/services/connectivity/mapping/WrappingMessageMapperTest.java @@ -28,10 +28,10 @@ import org.eclipse.ditto.model.connectivity.MessageMappingFailedException; import org.eclipse.ditto.protocoladapter.Adaptable; import org.eclipse.ditto.protocoladapter.ProtocolFactory; +import org.eclipse.ditto.protocoladapter.TopicPath; import org.eclipse.ditto.services.connectivity.config.mapping.DefaultMappingConfig; import org.eclipse.ditto.services.connectivity.config.mapping.MappingConfig; import org.eclipse.ditto.services.models.connectivity.ExternalMessage; -import org.junit.After; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -45,6 +45,7 @@ public class WrappingMessageMapperTest { private static final JsonObject DEFAULT_OPTIONS = JsonObject.newBuilder().set("default", "option").build(); + private MessageMapper mockMapper; private MessageMapper underTest; private MessageMapperConfiguration mockConfiguration; @@ -67,7 +68,7 @@ public void setUp() { when(mockMapper.map(mockAdaptable)).thenReturn(singletonList(mockMessage)); when(mockMapper.getId()).thenReturn("mockMapper"); when(mockMapper.getDefaultOptions()).thenReturn(DEFAULT_OPTIONS); - when(mockAdaptable.getTopicPath()).thenReturn(ProtocolFactory.emptyTopicPath()); + when(mockAdaptable.getTopicPath()).thenReturn(mock(TopicPath.class)); when(mockAdaptable.getDittoHeaders()).thenReturn(DittoHeaders.empty()); when(mockAdaptable.getPayload()).thenReturn(ProtocolFactory.newPayload("{\"path\":\"/\"}")); when(mockMessage.getInternalHeaders()).thenReturn(DittoHeaders.empty()); @@ -76,10 +77,6 @@ public void setUp() { underTest = WrappingMessageMapper.wrap(mockMapper); } - @After - public void tearDown() { - } - @Test public void configure() { when(mockConfiguration.getContentTypeBlocklist()).thenReturn(Collections.singletonList("blockedContentType")); @@ -98,8 +95,7 @@ public void mapMessage() { @Test public void mapAdaptable() { - final DittoHeaders headers = - DittoHeaders.of(Collections.singletonMap(ExternalMessage.CONTENT_TYPE_HEADER, "contentType")); + final var headers = DittoHeaders.newBuilder().contentType("contentType").build(); when(mockAdaptable.getDittoHeaders()).thenReturn(headers); underTest.configure(mapperLimitsConfig, mockConfiguration); @@ -135,11 +131,12 @@ public void getDefaultOptions() { Assertions.assertThat(underTest.getDefaultOptions()).isEqualTo(DEFAULT_OPTIONS); } - private List listOfElements(final T elementInList, final int numberOfElements) { + private static List listOfElements(final T elementInList, final int numberOfElements) { final List list = new ArrayList<>(); for (int i = 0; i < numberOfElements + 1; i++) { list.add(elementInList); } return list; } + }