Skip to content
This repository was archived by the owner on Aug 13, 2020. It is now read-only.

Commit b2a5728

Browse files
purple52purple52
authored
Merge pull request #373 from CJSCommonPlatform/fix-enveloper-not-to-include-stream-data-1.5
Remove stream metadata when creating new envelope
2 parents 846b735 + baea420 commit b2a5728

File tree

2 files changed

+77
-77
lines changed

2 files changed

+77
-77
lines changed

‎core/src/main/java/uk/gov/justice/services/core/enveloper/Enveloper.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
import static uk.gov.justice.services.messaging.JsonObjectMetadata.CREATED_AT;
77
import static uk.gov.justice.services.messaging.JsonObjectMetadata.ID;
88
import static uk.gov.justice.services.messaging.JsonObjectMetadata.NAME;
9+
import static uk.gov.justice.services.messaging.JsonObjectMetadata.STREAM;
910
import static uk.gov.justice.services.messaging.JsonObjectMetadata.metadataFrom;
1011

1112
import uk.gov.justice.domain.annotation.Event;
@@ -101,7 +102,7 @@ private Metadata buildMetaData(final Object eventObject, final Metadata metadata
101102
private Metadata buildMetaData(final Metadata metadata, final String name) {
102103

103104
JsonObjectBuilder metadataBuilder = JsonObjects.createObjectBuilderWithFilter(metadata.asJsonObject(),
104-
x -> !Arrays.asList(ID, NAME, CAUSATION).contains(x));
105+
x -> !Arrays.asList(ID, NAME, CAUSATION, STREAM).contains(x));
105106

106107
final JsonObject jsonObject = metadataBuilder
107108
.add(ID, UUID.randomUUID().toString())

‎core/src/test/java/uk/gov/justice/services/core/enveloper/EnveloperTest.java‎

Lines changed: 75 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,26 @@
11
package uk.gov.justice.services.core.enveloper;
22

3+
import static java.util.Optional.empty;
4+
import static java.util.UUID.randomUUID;
35
import static org.hamcrest.MatcherAssert.assertThat;
46
import static org.hamcrest.Matchers.equalTo;
7+
import static org.hamcrest.Matchers.is;
58
import static org.hamcrest.Matchers.notNullValue;
6-
import static org.mockito.Mockito.doReturn;
7-
import static org.mockito.Mockito.times;
8-
import static org.mockito.Mockito.verify;
9-
import static org.mockito.Mockito.when;
9+
import static org.hamcrest.core.IsNot.not;
10+
import static uk.gov.justice.services.messaging.DefaultJsonEnvelope.envelope;
1011
import static uk.gov.justice.services.messaging.JsonObjectMetadata.metadataOf;
12+
import static uk.gov.justice.services.messaging.JsonObjectMetadata.metadataWithDefaults;
1113

1214
import uk.gov.justice.domain.annotation.Event;
1315
import uk.gov.justice.services.common.converter.ObjectToJsonValueConverter;
14-
import uk.gov.justice.services.common.util.Clock;
16+
import uk.gov.justice.services.common.converter.jackson.ObjectMapperProducer;
17+
import uk.gov.justice.services.common.util.UtcClock;
1518
import uk.gov.justice.services.core.enveloper.exception.InvalidEventException;
1619
import uk.gov.justice.services.core.extension.EventFoundEvent;
1720
import uk.gov.justice.services.messaging.JsonEnvelope;
1821

19-
import java.time.ZonedDateTime;
2022
import java.util.UUID;
2123

22-
import javax.json.JsonObject;
2324
import javax.json.JsonValue;
2425

2526
import com.fasterxml.jackson.core.JsonProcessingException;
@@ -28,151 +29,149 @@
2829
import org.junit.Test;
2930
import org.junit.rules.ExpectedException;
3031
import org.junit.runner.RunWith;
31-
import org.mockito.InjectMocks;
32-
import org.mockito.Mock;
3332
import org.mockito.runners.MockitoJUnitRunner;
3433

3534
@RunWith(MockitoJUnitRunner.class)
3635
public class EnveloperTest {
3736

38-
private static final UUID CLIENT_ID_VALUE = UUID.randomUUID();
39-
private static final UUID USER_ID_VALUE = UUID.randomUUID();
40-
private static final UUID SESSION_ID_VALUE = UUID.randomUUID();
41-
private static final UUID STREAM_ID_VALUE = UUID.randomUUID();
42-
private static final int VERSION = 5;
43-
private static final String TEST_COMMAND_NAME = "test.command.do-something";
4437
private static final String TEST_EVENT_NAME = "test.event.something-happened";
45-
private static final UUID COMMAND_UUID = UUID.randomUUID();
46-
private static final UUID OLD_CAUSATION_ID = UUID.randomUUID();
38+
private static final UUID COMMAND_UUID = randomUUID();
39+
private static final UUID OLD_CAUSATION_ID = randomUUID();
4740
private static final String TEST_NAME = "test.query.query-response";
4841

4942
@Rule
5043
public ExpectedException exception = ExpectedException.none();
5144

52-
@InjectMocks
53-
private Enveloper enveloper;
54-
55-
private Object object;
56-
57-
@Mock
58-
private ObjectToJsonValueConverter objectToJsonValueConverter;
59-
60-
@Mock
61-
private JsonEnvelope envelope;
62-
63-
@Mock
64-
private EventFoundEvent event;
65-
66-
@Mock
67-
private JsonObject payload;
68-
69-
@Mock
70-
private Clock clock;
45+
private Enveloper enveloper = new Enveloper();
7146

7247
@Before
7348
public void setup() throws JsonProcessingException {
7449

75-
object = new TestEvent();
7650

77-
doReturn(TestEvent.class).when(event).getClazz();
78-
when(event.getEventName()).thenReturn(TEST_EVENT_NAME);
51+
enveloper.clock = new UtcClock();
52+
enveloper.objectToJsonValueConverter
53+
= new ObjectToJsonValueConverter(new ObjectMapperProducer().objectMapper());
7954

8055

8156
}
8257

8358
@Test
8459
public void shouldEnvelopeEventObject() throws JsonProcessingException {
85-
enveloper.register(event);
86-
when(envelope.metadata()).thenReturn(
87-
metadataOf(COMMAND_UUID, TEST_EVENT_NAME)
88-
.withCausation(OLD_CAUSATION_ID)
89-
.build());
90-
when(objectToJsonValueConverter.convert(object)).thenReturn(payload);
91-
when(clock.now()).thenReturn(ZonedDateTime.now());
60+
enveloper.register(new EventFoundEvent(TestEvent.class, TEST_EVENT_NAME));
9261

93-
JsonEnvelope event = enveloper.withMetadataFrom(envelope).apply(object);
62+
JsonEnvelope event = enveloper.withMetadataFrom(
63+
envelope()
64+
.with(metadataOf(COMMAND_UUID, TEST_EVENT_NAME)
65+
.withCausation(OLD_CAUSATION_ID))
66+
.build())
67+
.apply(new TestEvent("somePayloadValue"));
9468

95-
assertThat(event.payloadAsJsonObject(), equalTo(payload));
9669
assertThat(event.metadata().id(), notNullValue());
70+
assertThat(event.metadata().id(), not(equalTo(COMMAND_UUID)));
9771
assertThat(event.metadata().name(), equalTo(TEST_EVENT_NAME));
9872
assertThat(event.metadata().causation().size(), equalTo(2));
9973
assertThat(event.metadata().causation().get(0), equalTo(OLD_CAUSATION_ID));
10074
assertThat(event.metadata().causation().get(1), equalTo(COMMAND_UUID));
101-
verify(objectToJsonValueConverter, times(1)).convert(object);
75+
assertThat(event.payloadAsJsonObject().getString("somePayloadKey"), equalTo("somePayloadValue"));
10276
}
10377

10478
@Test(expected = IllegalArgumentException.class)
10579
public void shouldThrowExceptionOnNullEvent() throws JsonProcessingException {
106-
enveloper.withMetadataFrom(envelope).apply(null);
80+
enveloper.withMetadataFrom(envelope().build()).apply(null);
10781
}
10882

10983
@Test
11084
public void shouldEnvelopeObjectWithName() throws JsonProcessingException {
111-
when(envelope.metadata()).thenReturn(
112-
metadataOf(COMMAND_UUID, TEST_NAME)
113-
.withCausation(OLD_CAUSATION_ID)
114-
.build());
115-
when(objectToJsonValueConverter.convert(object)).thenReturn(payload);
116-
when(clock.now()).thenReturn(ZonedDateTime.now());
11785

118-
JsonEnvelope event = enveloper.withMetadataFrom(envelope, TEST_NAME).apply(object);
86+
JsonEnvelope event = enveloper.withMetadataFrom(
87+
envelope()
88+
.with(metadataOf(COMMAND_UUID, TEST_EVENT_NAME)
89+
.withCausation(OLD_CAUSATION_ID))
90+
.build(), TEST_NAME)
91+
.apply(new TestEvent());
92+
11993

120-
assertThat(event.payload(), equalTo(payload));
12194
assertThat(event.metadata().id(), notNullValue());
12295
assertThat(event.metadata().name(), equalTo(TEST_NAME));
12396
assertThat(event.metadata().causation().size(), equalTo(2));
12497
assertThat(event.metadata().causation().get(0), equalTo(OLD_CAUSATION_ID));
12598
assertThat(event.metadata().causation().get(1), equalTo(COMMAND_UUID));
126-
verify(objectToJsonValueConverter, times(1)).convert(object);
12799
}
128100

129101
@Test
130102
public void shouldEnvelopeMapNullObjectWithName() throws JsonProcessingException {
131-
when(envelope.metadata()).thenReturn(
132-
metadataOf(COMMAND_UUID, TEST_NAME)
133-
.withCausation(OLD_CAUSATION_ID)
134-
.build());
135-
when(clock.now()).thenReturn(ZonedDateTime.now());
136103

137-
JsonEnvelope event = enveloper.withMetadataFrom(envelope, TEST_NAME).apply(null);
104+
JsonEnvelope event = enveloper.withMetadataFrom(
105+
envelope()
106+
.with(metadataOf(COMMAND_UUID, TEST_EVENT_NAME)
107+
.withCausation(OLD_CAUSATION_ID))
108+
.build(), TEST_NAME)
109+
.apply(null);
138110

139111
assertThat(event.payload(), equalTo(JsonValue.NULL));
140112
assertThat(event.metadata().id(), notNullValue());
141113
assertThat(event.metadata().name(), equalTo(TEST_NAME));
142114
assertThat(event.metadata().causation().size(), equalTo(2));
143115
assertThat(event.metadata().causation().get(0), equalTo(OLD_CAUSATION_ID));
144116
assertThat(event.metadata().causation().get(1), equalTo(COMMAND_UUID));
145-
verify(objectToJsonValueConverter, times(0)).convert(object);
146117
}
147118

148119
@Test
149120
public void shouldEnvelopeObjectWithoutCausation() throws JsonProcessingException {
150-
enveloper.register(event);
151-
when(envelope.metadata()).thenReturn(
152-
metadataOf(COMMAND_UUID, TEST_EVENT_NAME)
153-
.build());
154-
when(objectToJsonValueConverter.convert(object)).thenReturn(payload);
155-
when(clock.now()).thenReturn(ZonedDateTime.now());
121+
enveloper.register(new EventFoundEvent(TestEvent.class, TEST_EVENT_NAME));
122+
123+
JsonEnvelope event = enveloper.withMetadataFrom(
124+
envelope()
125+
.with(metadataOf(COMMAND_UUID, TEST_EVENT_NAME))
126+
.build())
127+
.apply(new TestEvent());
156128

157-
JsonEnvelope event = enveloper.withMetadataFrom(envelope).apply(object);
158129

159-
assertThat(event.payloadAsJsonObject(), equalTo(payload));
160130
assertThat(event.metadata().id(), notNullValue());
161131
assertThat(event.metadata().name(), equalTo(TEST_EVENT_NAME));
162132
assertThat(event.metadata().causation().size(), equalTo(1));
163133
assertThat(event.metadata().causation().get(0), equalTo(COMMAND_UUID));
164-
verify(objectToJsonValueConverter, times(1)).convert(object);
134+
165135
}
166136

167137
@Test
168138
public void shouldThrowExceptionIfProvidedInvalidEventObject() {
169139
exception.expect(InvalidEventException.class);
170140
exception.expectMessage("Failed to map event. No event registered for class java.lang.String");
171141

172-
enveloper.withMetadataFrom(envelope).apply("InvalidEventObject");
142+
enveloper.withMetadataFrom(envelope().build()).apply("InvalidEventObject");
143+
}
144+
145+
@Test
146+
public void shouldRemoveStreamMetadata() throws JsonProcessingException {
147+
enveloper.register(new EventFoundEvent(TestEvent.class, TEST_EVENT_NAME));
148+
149+
JsonEnvelope event = enveloper.withMetadataFrom(
150+
envelope()
151+
.with(metadataWithDefaults()
152+
.withStreamId(randomUUID())
153+
.withVersion(123l)
154+
)
155+
.build())
156+
.apply(new TestEvent());
157+
158+
assertThat(event.metadata().streamId(), is(empty()));
159+
assertThat(event.metadata().version(), is(empty()));
173160
}
174161

175162
@Event("Test-Event")
176163
public static class TestEvent {
164+
private String somePayloadKey;
165+
166+
public TestEvent(final String somePayloadKey) {
167+
this.somePayloadKey = somePayloadKey;
168+
}
169+
170+
public TestEvent() {
171+
}
172+
173+
public String getSomePayloadKey() {
174+
return somePayloadKey;
175+
}
177176
}
178177
}

0 commit comments

Comments
 (0)