@Test public void transactionsAreRunSuccessfully() { saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, SAGA_END_TRANSACTION, SagaEndedEvent.class) )); verify(transaction1).send(request1.serviceName(), SagaResponse.EMPTY_RESPONSE); verify(transaction2).send(request2.serviceName(), transactionResponse1); verify(compensation1, never()).send(request1.serviceName()); verify(compensation2, never()).send(request2.serviceName()); }
@Test public void skipIgnoredTransaction() throws Exception { when(sagaDefinition.requests()).thenReturn(new SagaRequest[]{request1, request2, request3}); saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); when(childrenExtractor.fromJson(transactionResponse1.body())).thenReturn(setOf(request3.id())); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, SAGA_END_TRANSACTION, SagaEndedEvent.class) )); verify(transaction1).send(request1.serviceName(), SagaResponse.EMPTY_RESPONSE); verify(transaction3).send(request3.serviceName(), transactionResponse1); verify(transaction2, never()).send(anyString(), any(SagaResponse.class)); verify(compensation1, never()).send(request1.serviceName()); verify(compensation2, never()).send(request2.serviceName()); verify(compensation3, never()).send(request3.serviceName()); }
@Test public void skipAllIgnoredTransactions() throws Exception { when(sagaDefinition.requests()).thenReturn(new SagaRequest[]{request1, request2, request3, request4}); saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); when(childrenExtractor.fromJson(transactionResponse1.body())).thenReturn(setOf("none")); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, SAGA_END_TRANSACTION, SagaEndedEvent.class) )); verify(transaction1).send(request1.serviceName(), SagaResponse.EMPTY_RESPONSE); verify(transaction2, never()).send(anyString(), any(SagaResponse.class)); verify(transaction3, never()).send(anyString(), any(SagaResponse.class)); verify(transaction4, never()).send(anyString(), any(SagaResponse.class)); verify(compensation1, never()).send(request1.serviceName()); verify(compensation2, never()).send(request2.serviceName()); verify(compensation3, never()).send(request3.serviceName()); verify(compensation4, never()).send(request4.serviceName()); }
@Test public void retriesFailedTransactionTillSuccess() { when(sagaDefinition.policy()).thenReturn(new ForwardRecovery()); saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); when(transaction2.send(request2.serviceName(), transactionResponse1)) .thenThrow(exception).thenThrow(exception).thenReturn(transactionResponse2); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, SAGA_END_TRANSACTION, SagaEndedEvent.class) )); verify(transaction1).send(request1.serviceName(), SagaResponse.EMPTY_RESPONSE); verify(transaction2, times(3)).send(request2.serviceName(), transactionResponse1); verify(compensation1, never()).send(anyString(), any(SagaResponse.class)); verify(compensation2, never()).send(anyString(), any(SagaResponse.class)); }
@Test public void buildsGraphOfParallelRequests() { SingleLeafDirectedAcyclicGraph<SagaRequest> tasks = graphBuilder.build(requests); Traveller<SagaRequest> traveller = new ByLevelTraveller<>(tasks, new FromRootTraversalDirection<>()); Collection<Node<SagaRequest>> nodes = traveller.nodes(); traveller.next(); assertThat(requestsOf(nodes), IsIterableContainingInOrder.contains(NoOpSagaRequest.SAGA_START_REQUEST)); nodes.clear(); traveller.next(); assertThat(requestsOf(nodes), contains(request1, request2)); nodes.clear(); traveller.next(); assertThat(requestsOf(nodes), contains(request3)); nodes.clear(); traveller.next(); assertThat(requestsOf(nodes), IsIterableContainingInOrder.contains(NoOpSagaRequest.SAGA_END_REQUEST)); }
@Test public void testMultipleTimeSeriesResponse() { setUp(); final String testMetricName1 = "testMetric1"; final List<String> testTags1 = Arrays.asList("host=h1", "dc=dc1"); final List<String> testTags2 = Arrays.asList("host=h2", "dc=dc1"); assertTrue(chunk.query(new Query("test", Collections.emptyList())).isEmpty()); parseAndAddOpenTSDBMetric( makeMetricString(testMetricName1, "host=h1 dc=dc1", testTs, testValue), chunk); parseAndAddOpenTSDBMetric( makeMetricString(testMetricName1, "host=h2 dc=dc1", testTs, testValue), chunk); Point p1 = new Point(testTs, testValue); Assert.assertThat(chunk.query(Query.parse(testMetricName1 + " dc=dc1")), IsIterableContainingInOrder.contains( new TimeSeries(testMetricName1 + " dc=dc1 host=h1", Collections.singletonList(p1)), new TimeSeries(testMetricName1 + " dc=dc1 host=h2", Collections.singletonList(p1)))); }
public void testMultipleTimeSeriesResponse() { final String testMetricName1 = "testMetric1"; final List<String> testTags1 = Arrays.asList("host=h1", "dc=dc1"); final List<String> testTags2 = Arrays.asList("host=h2", "dc=dc1"); assertTrue(ms.getSeries(new Query("test", Collections.emptyList())).isEmpty()); final Metric testMetric1 = new Metric(testMetricName1, testTags1); final Metric testMetric2 = new Metric(testMetricName1, testTags2); ms.addPoint(testMetric1, ts, value); ms.addPoint(testMetric2, ts, value); Point p1 = new Point(ts, value); assertThat(ms.getSeries(Query.parse(testMetricName1 + " dc=dc1")), IsIterableContainingInOrder.contains( new TimeSeries(testMetricName1 + " dc=dc1 host=h1", Collections.singletonList(p1)), new TimeSeries(testMetricName1 + " dc=dc1 host=h2", Collections.singletonList(p1)))); }
@Test public void testEnums() { Codec<Pojo> pojoCodec = codecRegistry.get(Pojo.class); LovelyDisplayable lovelyDisplayable = LovelyDisplayable.builder().identityProperty("foo").build(); Pojo pojo = Pojo.builder() .simpleEnumProperty(EnumA.TYPE1) .displayable(Arrays.asList(EnumB.TYPE1, EnumA.TYPE1, EnumA.TYPE3, lovelyDisplayable)) .build(); StringWriter stringWriter = new StringWriter(); JsonWriter writer = new JsonWriter(stringWriter, new JsonWriterSettings(true)); pojoCodec.encode(writer, pojo, EncoderContext.builder().build()); System.out.println(stringWriter.toString()); Pojo decodedPojo = pojoCodec.decode(new JsonReader(stringWriter.toString()), DecoderContext.builder().build()); MatcherAssert.assertThat(decodedPojo.getDisplayable(), IsIterableContainingInOrder.contains(EnumB.TYPE1, EnumA.TYPE1, EnumA.TYPE3, lovelyDisplayable)); }
@Test public void testWrite() { String xml = "<FaceInterpolator parts=\"morph1 morph2 morph3\">" + "0.1 0.5 0.4 0.4\n" + "0.9 0.7 0.6 0.2" + "</FaceInterpolator>"; FaceInterpolator ipIn = new FaceInterpolator(); ipIn.readXML(xml); StringBuilder buf = new StringBuilder(); ipIn.appendXML(buf); FaceInterpolator ipOut = new FaceInterpolator(); ipOut.readXML(buf.toString()); assertThat(ipOut.getParts(), IsIterableContainingInOrder.contains("morph1", "morph2", "morph3")); assertEquals(0.1, ipOut.getStartTime(), PRECISION); assertEquals(0.9, ipOut.getEndTime(), PRECISION); }
@Test public void getFields_shouldGetFields() { final Field height = new Field("height", "", null, null, ""); final Field width = new Field("width", "", null, null, ""); final Field title = new Field("title", "", null, null, ""); final List<Field> fields = Arrays.asList(height, width, title); final RegisterReadOnly register = mock(RegisterReadOnly.class); when(register.getRegisterName()).thenReturn(new RegisterName("widget")); final HomePageView homePageView = new HomePageView(null, null, mockRequestContext, 1, 2, null, Optional.empty(), homepageContent, registerResolver, fields, registerLinkService, register); final List<Field> actualFields = Lists.newArrayList(homePageView.getFields()); assertThat(actualFields, IsIterableContainingInOrder.contains(height, width, title)); }
@Test public void shouldUseServiceToGetEntryProof() { int entryNumber = 2; int totalEntries = 5; HashValue expectedHash1 = new HashValue(HashingAlgorithm.SHA256, sampleHash1); HashValue expectedHash2 = new HashValue(HashingAlgorithm.SHA256, sampleHash2); List<HashValue> expectedAuditPath = Arrays.asList(expectedHash1, expectedHash2); EntryProof expectedProof = new EntryProof("3", expectedAuditPath); RegisterReadOnly registerMock = mock(RegisterReadOnly.class); when(registerMock.getTotalEntries()).thenReturn(8); when(registerMock.getEntryProof(entryNumber, totalEntries)).thenReturn(expectedProof); VerifiableLogResource vlResource = new VerifiableLogResource(registerMock); EntryProof actualProof = vlResource.entryProof(entryNumber, totalEntries); verify(registerMock, times(1)).getEntryProof(entryNumber, totalEntries); assertThat(actualProof.getProofIdentifier(), equalTo(expectedProof.getProofIdentifier())); assertThat(actualProof.getEntryNumber(), equalTo(expectedProof.getEntryNumber())); assertThat(actualProof.getAuditPath(), IsIterableContainingInOrder.contains(expectedHash1, expectedHash2)); }
@Test public void shouldUseServiceToGetConsistencyProof() { int totalEntries1 = 3; int totalEntries2 = 6; HashValue expectedHash1 = new HashValue(HashingAlgorithm.SHA256, sampleHash1); HashValue expectedHash2 = new HashValue(HashingAlgorithm.SHA256, sampleHash2); List<HashValue> expectedConsistencyNodes = Arrays.asList(expectedHash1, expectedHash2); ConsistencyProof expectedProof = new ConsistencyProof(expectedConsistencyNodes); RegisterReadOnly registerMock = mock(RegisterReadOnly.class); when(registerMock.getTotalEntries()).thenReturn(8); when(registerMock.getConsistencyProof(totalEntries1, totalEntries2)).thenReturn(expectedProof); VerifiableLogResource vlResource = new VerifiableLogResource(registerMock); ConsistencyProof actualProof = vlResource.consistencyProof(totalEntries1, totalEntries2); verify(registerMock, times(1)).getConsistencyProof(totalEntries1, totalEntries2); assertThat(actualProof.getProofIdentifier(), equalTo(expectedProof.getProofIdentifier())); assertThat(actualProof.getConsistencyNodes(), IsIterableContainingInOrder.contains(expectedHash1, expectedHash2)); }
@Test public void read() throws Exception { final List<TimeSeriesCollection> tsdata = create_tsdata_(3).collect(Collectors.toList()); file_support.create_file(tmpfile, tsdata); final TSData fd = TSData.readonly(tmpfile); assertEquals(tsdata, fd.stream().collect(Collectors.toList())); assertEquals(Files.size(tmpfile), fd.getFileSize()); assertEquals(tsdata.get(0).getTimestamp(), fd.getBegin()); assertEquals(tsdata.get(tsdata.size() - 1).getTimestamp(), fd.getEnd()); assertNotNull(fd.getFileChannel()); assertEquals(tsdata.size(), fd.size()); assertEquals(file_support.getMajor(), fd.getMajor()); assertEquals(file_support.getMinor(), fd.getMinor()); assertThat(fd, IsIterableContainingInOrder.contains(tsdata.stream().map(Matchers::equalTo).collect(Collectors.toList()))); }
@Test public void read() throws Exception { file_support.create_file(tmpfile, tsdata); final UnmappedReadonlyTSDataFile fd = UnmappedReadonlyTSDataFile.open(tmpfile); assertEquals(Files.size(tmpfile), fd.getFileSize()); assertEquals(tsdata.get(0).getTimestamp(), fd.getBegin()); assertEquals(tsdata.get(tsdata.size() - 1).getTimestamp(), fd.getEnd()); assertTrue(fd.getFileChannel().isPresent()); assertEquals(tsdata.size(), fd.size()); assertEquals(file_support.getMajor(), fd.getMajor()); assertEquals(file_support.getMinor(), fd.getMinor()); assertThat(fd, IsIterableContainingInOrder.contains(tsdata.stream().map(Matchers::equalTo).collect(Collectors.toList()))); assertThat(fd.streamReversed().collect(Collectors.toList()), IsIterableContainingInOrder.contains(expect_reversed.stream().map(Matchers::equalTo).collect(Collectors.toList()))); }
private void verifyValues(List<byte[]> expectedValues, InputStream is) throws Exception { List<byte[]> values = new ArrayList<>(); long count; do { count = VarInt.decodeLong(is); for (int i = 0; i < count; ++i) { values.add(ByteArrayCoder.of().decode(is)); } } while(count > 0); if (expectedValues.isEmpty()) { assertTrue(values.isEmpty()); } else { assertThat(values, IsIterableContainingInOrder.contains(expectedValues.toArray())); } }
public static void checkLastLines(File jsonFile, String[] expectedLinesAtEnd) { CircularQueue<String> queue = new CircularQueue<String>(expectedLinesAtEnd.length); Scanner sc = null; try { sc = new Scanner(jsonFile, "UTF-8"); while (sc.hasNextLine()) { queue.add(sc.nextLine()); } } catch (FileNotFoundException e) { e.printStackTrace(); } finally { if (null != sc) { sc.close(); } } MatcherAssert.assertThat(queue, IsIterableContainingInOrder.contains(expectedLinesAtEnd)); }
@Test public void whenNameContainsReDosAttack_shouldBeInvalid() { // language=JSON String json = "{" + "\"type\":\"value\"," + "\"name\":\"/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/" + "com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/" + "com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/com/foo/" + "com/foo/com/foo/com/\"," + "\"value\":\"some-value\"," + "\"overwrite\":true" + "}"; Set<ConstraintViolation<BaseCredentialSetRequest>> violations = JsonTestHelper .deserializeAndValidate(json, BaseCredentialSetRequest.class); MatcherAssert.assertThat(violations, IsIterableContainingInOrder.contains(JsonTestHelper.hasViolationWithMessage("error.credential.invalid_slash_in_name"))); }
@Test public void whenNameContainsInvalidCharacter_shouldBeInvalid() { for (char invalidCharacter: new char[]{'.', ' ', '\\', '?', '!', '$'}) { // language=JSON String json = "{" + "\"type\":\"value\"," + "\"name\":\"test" + invalidCharacter + "name\"," + "\"value\":\"some-value\"," + "\"overwrite\":true" + "}"; Set<ConstraintViolation<BaseCredentialSetRequest>> violations = JsonTestHelper .deserializeAndValidate(json, BaseCredentialSetRequest.class); MatcherAssert.assertThat(violations, IsIterableContainingInOrder.contains(JsonTestHelper.hasViolationWithMessage("error.credential.invalid_character_in_name"))); } }
@Test public void readLocations() { List<Map<String, Object>> locationsTest1Token1 = restClient.getForEntity( "http://localhost:" + serverPort + "/ws/test1/TEST1-TOKEN1/locations", List.class).getBody(); List<Map<String, Object>> locationsTest1Token2 = restClient.getForEntity( "http://localhost:" + serverPort + "/ws/test1/TEST1-TOKEN2/locations", List.class).getBody(); assertNotNull(locationsTest1Token1); assertNotNull(locationsTest1Token2); assertEquals(4, locationsTest1Token1.size()); assertThat(locationsTest1Token1, IsIterableContainingInOrder.contains(locationsTest1Token2.toArray())); List<Map<String, Object>> locationsTest2Token1 = restClient.getForEntity( "http://localhost:" + serverPort + "/ws/test2/TEST2-TOKEN1/locations", List.class).getBody(); assertNotNull(locationsTest2Token1); assertEquals(4, locationsTest2Token1.size()); assertEquals(52.377, locationsTest2Token1.get(0).get("latitude")); assertEquals(9.739, locationsTest2Token1.get(0).get("longitude")); assertTrue(DateTimeUtil.fromString((String) locationsTest2Token1.get(0).get("instant")) .isBefore(LocalDateTime.now().minus(10, ChronoUnit.DAYS))); }
@Test public void testCleanDisconnects() { MutableTreeNode test = new MutableTreeNode(null); MutableTreeNode child = new MutableTreeNode(null); MutableTreeNode parent = new MutableTreeNode(null); test.addChild(child); parent.addChild(test); parent.addChild(child); test.clean(); assertThat(test.getChildren(), IsEmptyCollection.empty()); assertThat(test.getAncestors(), IsEmptyCollection.empty()); assertThat(parent.getChildren(), hasSize(1)); assertThat(parent.getChildren(), IsIterableContainingInOrder.contains(child)); assertThat(child.getAncestors(), hasSize(1)); assertThat(child.getAncestors(), IsIterableContainingInOrder.contains(parent)); }
@Test public void testListContainsMatching() { Matcher<Person> matcher = is(aPersonThat() .hasPhoneList(IsIterableContainingInOrder.contains( new PhoneMatcher[]{ aPhoneThat().hasCode("123").hasNumber("123123"), aPhoneThat().hasCode("123").hasNumber("456654") } ))); String descriptionOfMismatch = "phoneList item 1: number was '456456' (expected '456654') " + "(expected iterable containing [" + "a Phone that (has code ('123') and has number ('123123')), " + "a Phone that (has code ('123') and has number ('456654'))" + "])"; assertMismatch(bob, matcher, descriptionOfMismatch); }
@Test public void transform_string_to_enum () { List<String> days = Lists.newArrayList( "WEDNESDAY", "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY"); Function<String, Day> valueOfFunction = Enums.valueOfFunction(Day.class); Iterable<Day> daysAsEnums = Iterables.transform(days, valueOfFunction); assertThat(daysAsEnums, IsIterableWithSize.<Day>iterableWithSize(5)); assertThat(daysAsEnums, IsIterableContainingInOrder. <Day>contains( Day.WEDNESDAY, Day.SUNDAY, Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY)); }
@Test public void transform_string_to_enum_string_converter () { List<String> days = Lists.newArrayList( "WEDNESDAY", "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY"); Function<String, Day> valueOfFunction = Enums.stringConverter(Day.class); Iterable<Day> daysAsEnums = Iterables.transform(days, valueOfFunction); assertThat(daysAsEnums, IsIterableWithSize.<Day>iterableWithSize(5)); assertThat(daysAsEnums, IsIterableContainingInOrder. <Day>contains( Day.WEDNESDAY, Day.SUNDAY, Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY)); }
@Test public void testList() throws Exception { Configuration config = new ZookeeperConfiguration(zkConnection, 5000, "/test"); final String key = UUID.randomUUID().toString(); final String val = "An extended List, with several, commas, that should stay within, the, same value,"; final List<?> list = Lists.transform(Arrays.asList(val.split(",")), new Function<String, String>() { @Override public String apply(String input) { return input.trim(); } }); assertThat(config.getProperty(key), nullValue()); config.setProperty(key, list); assertThat(config.getList(key), IsIterableContainingInOrder.contains(list.toArray())); assertThat(config.getString(key), is(val.split(",")[0].trim())); config.setProperty(key, val.split(",")); assertThat(config.getString(key), is(val.split(",")[0])); assertThat(config.getList(key), CoreMatchers.<Object>hasItems(val.split(","))); assertThat(config.getStringArray(key), arrayContaining(val.split(","))); assertThat(config.getStringArray(key), arrayWithSize(val.split(",").length)); }
private void testCmdSplittedOnSpaces(final String composeDefinition, final String[] expectedInOrderCmds) { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("serverVersion", "1.13"); parameters.put("serverUri", "http://localhost:25123"); parameters.put("dockerContainers", composeDefinition); parameters.put("definitionFormat", DefinitionFormat.COMPOSE.name()); CubeDockerConfiguration cubeConfiguration = CubeDockerConfiguration.fromMap(parameters, null); final DockerCompositions dockerContainersContent = cubeConfiguration.getDockerContainersContent(); final CubeContainer wildfly = dockerContainersContent.get("wildfly"); final Collection<String> commands = wildfly.getCmd(); assertThat(commands, IsIterableContainingInOrder.contains(expectedInOrderCmds)); }
@Test public void doNotCompensateIgnoredTransactions() throws Exception { when(sagaDefinition.requests()).thenReturn(new SagaRequest[]{request1, request2, request3, request4}); saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); when(childrenExtractor.fromJson(transactionResponse1.body())).thenReturn(setOf(request3.id())); when(transaction4.send(request4.serviceName(), transactionResponse3)).thenThrow(exception); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction4, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction4, TransactionAbortedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionCompensatedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionCompensatedEvent.class), SagaEventMatcher.eventWith(sagaId, Compensation.SAGA_START_COMPENSATION, SagaEndedEvent.class) )); verify(transaction1).send(request1.serviceName(), SagaResponse.EMPTY_RESPONSE); verify(transaction3).send(request3.serviceName(), transactionResponse1); verify(transaction4).send(request4.serviceName(), transactionResponse3); verify(transaction2, never()).send(anyString(), any(SagaResponse.class)); verify(compensation1).send(request1.serviceName()); verify(compensation3).send(request3.serviceName()); verify(compensation2, never()).send(request2.serviceName()); verify(compensation4, never()).send(request4.serviceName()); }
@Test public void restoresSagaToTransactionStateByPlayingAllEvents() { when(sagaDefinition.requests()).thenReturn(new SagaRequest[]{request1, request2, request3}); saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); Iterable<EventEnvelope> events = asList( envelope(new SagaStartedEvent(sagaId, requestJson, NoOpSagaRequest.SAGA_START_REQUEST)), envelope(new TransactionStartedEvent(sagaId, request1)), envelope(new TransactionEndedEvent(sagaId, request1, transactionResponse1)), envelope(new TransactionStartedEvent(sagaId, request2)), envelope(new TransactionEndedEvent(sagaId, request2, transactionResponse2)) ); eventStore.populate(events); saga.play(); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, SAGA_END_TRANSACTION, SagaEndedEvent.class) )); verify(transaction1, never()).send(anyString(), any(SagaResponse.class)); verify(transaction2, never()).send(anyString(), any(SagaResponse.class)); verify(transaction3).send(request3.serviceName(), transactionResponse1); verify(compensation1, never()).send(request1.serviceName()); verify(compensation2, never()).send(request2.serviceName()); verify(compensation3, never()).send(request3.serviceName()); }
@Test public void restoresPartialTransactionByPlayingAllEvents() { when(sagaDefinition.requests()).thenReturn(new SagaRequest[]{request1, request2, request3}); saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); Iterable<EventEnvelope> events = asList( envelope(new SagaStartedEvent(sagaId, requestJson, NoOpSagaRequest.SAGA_START_REQUEST)), envelope(new TransactionStartedEvent(sagaId, request1)), envelope(new TransactionEndedEvent(sagaId, request1, transactionResponse1)), envelope(new TransactionStartedEvent(sagaId, request2)), envelope(new TransactionEndedEvent(sagaId, request2, transactionResponse2)), envelope(new TransactionStartedEvent(sagaId, request3)) ); eventStore.populate(events); saga.play(); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, SAGA_END_TRANSACTION, SagaEndedEvent.class) )); verify(transaction1, never()).send(anyString(), any(SagaResponse.class)); verify(transaction2, never()).send(anyString(), any(SagaResponse.class)); verify(transaction3).send(request3.serviceName(), transactionResponse1); verify(compensation1, never()).send(request1.serviceName()); verify(compensation2, never()).send(request2.serviceName()); verify(compensation3, never()).send(request3.serviceName()); }
@Test public void restoresToCompensationFromAbortedTransactionByPlayingAllEvents() { when(sagaDefinition.requests()).thenReturn(new SagaRequest[]{request1, request2, request3}); saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); Iterable<EventEnvelope> events = asList( envelope(new SagaStartedEvent(sagaId, requestJson, NoOpSagaRequest.SAGA_START_REQUEST)), envelope(new TransactionStartedEvent(sagaId, request1)), envelope(new TransactionEndedEvent(sagaId, request1)), envelope(new TransactionStartedEvent(sagaId, request2)), envelope(new TransactionEndedEvent(sagaId, request2)), envelope(new TransactionStartedEvent(sagaId, request3)), envelope(new TransactionAbortedEvent(sagaId, request3, exception)) ); eventStore.populate(events); saga.play(); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction3, TransactionAbortedEvent.class), SagaEventMatcher.eventWith(sagaId, compensation2, TransactionCompensatedEvent.class), SagaEventMatcher.eventWith(sagaId, compensation1, TransactionCompensatedEvent.class), SagaEventMatcher.eventWith(sagaId, Compensation.SAGA_START_COMPENSATION, SagaEndedEvent.class) )); verify(transaction1, never()).send(anyString(), any(SagaResponse.class)); verify(transaction2, never()).send(anyString(), any(SagaResponse.class)); verify(transaction3, never()).send(anyString(), any(SagaResponse.class)); verify(compensation1).send(request1.serviceName()); verify(compensation2).send(request2.serviceName()); verify(compensation3, never()).send(request3.serviceName()); }
@Test public void restoresSagaToEndStateByPlayingAllEvents() { saga = sagaFactory.createSaga(requestJson, sagaId, eventStore, sagaDefinition); Iterable<EventEnvelope> events = asList( envelope(new SagaStartedEvent(sagaId, requestJson, NoOpSagaRequest.SAGA_START_REQUEST)), envelope(new TransactionStartedEvent(sagaId, request1)), envelope(new TransactionEndedEvent(sagaId, request1)), envelope(new TransactionStartedEvent(sagaId, request2)), envelope(new TransactionEndedEvent(sagaId, request2)) ); eventStore.populate(events); saga.play(); saga.run(); assertThat(eventStore, IsIterableContainingInOrder.contains( SagaEventMatcher.eventWith(sagaId, SAGA_START_TRANSACTION, SagaStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction1, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionStartedEvent.class), SagaEventMatcher.eventWith(sagaId, transaction2, TransactionEndedEvent.class), SagaEventMatcher.eventWith(sagaId, SAGA_END_TRANSACTION, SagaEndedEvent.class) )); verify(transaction1, never()).send(anyString(), any(SagaResponse.class)); verify(transaction2, never()).send(anyString(), any(SagaResponse.class)); verify(compensation1, never()).send(request1.serviceName()); verify(compensation2, never()).send(request2.serviceName()); }
public void testDedup() { Point point1 = new Point(1, 1); Point point2 = new Point(2, 2); Point point3 = new Point(3, 3); List<Point> points = Collections.unmodifiableList(Arrays.asList(point1, point2, point3)); List<Point> reversedPoints = Collections.unmodifiableList(Arrays.asList(point3, point2, point1)); assertTrue(Points.dedup(Collections.emptyList()).isEmpty()); Assert.assertThat(points, IsIterableContainingInOrder.contains(Points.dedup(points).toArray())); Assert.assertThat(points, IsIterableContainingInOrder.contains(Points.dedup(reversedPoints).toArray())); List<Point> duplicatePoints = Arrays.asList(point1, new Point(1, 2)); List<Point> result1 = Points.dedup(duplicatePoints); assertEquals(1, result1.size()); assertEquals(1, result1.get(0).getTs()); assertEquals(2.0, result1.get(0).getVal()); assertEquals(new Point(1, 2), result1.get(0)); List<Point> duplicatePoints2 = Arrays.asList(point1, new Point(2, 3), point2, point3); Assert.assertThat(points, IsIterableContainingInOrder.contains(Points.dedup(duplicatePoints2).toArray())); List<Point> duplicatePoints3 = Arrays.asList(point1, point2, new Point(2, 3), point2, point3); Assert.assertThat(points, IsIterableContainingInOrder.contains(Points.dedup(duplicatePoints3).toArray())); List<Point> duplicatePoints4 = Arrays.asList(point1, new Point(1, 2), new Point(1, -1)); List<Point> result2 = Points.dedup(duplicatePoints4); assertEquals(1, result2.size()); assertEquals(new Point(1, -1), result2.get(0)); }
@Test public void getNames() throws Exception { Object[] expResult = names.toArray(); ObservableList<SimpleStringProperty> result = packet.getNames(); assertThat(result.stream().map(SimpleStringProperty::get).collect(Collectors.toList()), IsIterableContainingInOrder.contains(expResult)); }
@Test public void getFastestLapTimes() throws Exception { Object[] expResult = fastestLaps.toArray(); ObservableList<SimpleFloatProperty> result = packet.getFastestLapTimes(); assertThat(result.stream().map(SimpleFloatProperty::get).collect(Collectors.toList()), IsIterableContainingInOrder.contains(expResult)); }
public static <T> Matcher<Iterable<? extends T>> inOrder(Iterable<T> items) { final List<Matcher<? super T>> matchers = new ArrayList<>(); for (final Object item : items) { matchers.add(IsEqual.equalTo(item)); } return IsIterableContainingInOrder.contains(matchers); }
@Test public void testGetParts() { String xml = "<FaceInterpolator parts=\"morph1 morph2 morph3\">" + "0.1 0.5 0.4 0.4\n" + "0.9 0.7 0.6 0.2" + "</FaceInterpolator>"; FaceInterpolator ip = new FaceInterpolator(); ip.readXML(xml); assertThat(ip.getParts(), IsIterableContainingInOrder.contains("morph1", "morph2", "morph3")); }
@Test public void getSimilarRegisters_shouldGetSimilarRegistersIfAvailable() { final RegisterReadOnly register = mock(RegisterReadOnly.class); HomepageContent homepageContent = new HomepageContent(Optional.empty(), emptyList(), emptyList()); HomePageView homePageView = new HomePageView(null, null, mockRequestContext, 1, 2, Optional.empty(), Optional.empty(), homepageContent, registerResolver, Arrays.asList(field), registerLinkService, register); assertThat(homePageView.getHomepageContent().getSimilarRegisters(), is(empty())); final List<String> similarRegisters = Arrays.asList("address", "territory"); homepageContent = new HomepageContent(Optional.empty(), similarRegisters, emptyList()); homePageView = new HomePageView(null, null, mockRequestContext, 1, 2, Optional.empty(), Optional.empty(), homepageContent, registerResolver, Arrays.asList(field), registerLinkService, register); assertThat(homePageView.getHomepageContent().getSimilarRegisters(), IsIterableContainingInOrder.contains("address", "territory")); }
@Test public void getIndexes_shouldGetIndexesIfAvailable() { final RegisterReadOnly register = mock(RegisterReadOnly.class); HomepageContent homepageContent = new HomepageContent(Optional.empty(), emptyList(), emptyList()); HomePageView homePageView = new HomePageView(null, null, mockRequestContext, 1, 2, Optional.empty(), Optional.empty(), homepageContent, registerResolver, Arrays.asList(field), registerLinkService, register); assertThat(homePageView.getHomepageContent().getIndexes(), is(emptyList())); final List<String> indexes = Arrays.asList("current-countries", "local-authority-by-type"); homepageContent = new HomepageContent(Optional.empty(), emptyList(), indexes); homePageView = new HomePageView(null, null, mockRequestContext, 1, 2, Optional.empty(), Optional.empty(), homepageContent, registerResolver, Arrays.asList(field), registerLinkService, register); assertThat(homePageView.getHomepageContent().getIndexes(), IsIterableContainingInOrder.contains("current-countries", "local-authority-by-type")); }