java类org.hamcrest.collection.IsIterableContainingInOrder的实例源码

@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 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 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());
}