target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void currentStatusIsOneOfTheGivenStatusesWhenDocumentPassedIn() { Document document = new Document(); DocumentMatcher expectedDocument = hasField(STATUS_HISTORY + ".0." + STATUS, hasField(IN, contains(FAILED.name(), CLASSIFIED.name()))); Document actualDocument = underTest.currentStatusIn(document, immutableEnumSet(FAILED, CLASSIFIED)); assertThat(actualDocument, expectedDocument); assertThat(actualDocument, is(document)); }
|
public Document currentStatusIn(Set<Status> statuses) { return currentStatusIn(new Document(), statuses); }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusIn(Set<Status> statuses) { return currentStatusIn(new Document(), statuses); } }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusIn(Set<Status> statuses) { return currentStatusIn(new Document(), statuses); } }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusIn(Set<Status> statuses) { return currentStatusIn(new Document(), statuses); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusIn(Set<Status> statuses) { return currentStatusIn(new Document(), statuses); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }
|
@Test public void successfullyMatchSingleField() { assertThat(underTest.test(failedMessage), is(true)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void attemptToMatchSingleValueInArrayForFieldThatDoesExist() { underTest = new ContentMatchesJsonPath("$.store.book[0].isbn", "0-553-21311-3"); assertThat(underTest.test(failedMessage), is(false)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void attemptToMatchSingleValueInArrayWhereValuesAreNull() { underTest = new ContentMatchesJsonPath("$.store.book[0].publicationDate", "2018-01-01"); assertThat(underTest.test(failedMessage), is(false)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void successfullyMatchSingleValueInArray() { underTest = new ContentMatchesJsonPath("$.store.book[1].category", "fiction"); assertThat(underTest.test(failedMessage), is(true)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void attemptToMatchAnyValueInArrayForFieldThatDoesNotExist() { underTest = new ContentMatchesJsonPath("$.store.book[*].something", ""); assertThat("", underTest.test(failedMessage), is(false)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void attemptToMatchAnyValueInArray() { underTest = new ContentMatchesJsonPath("$.store.book[*].category", "romance"); assertThat("No books should exist with category 'romance'", underTest.test(failedMessage), is(false)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void successfullyMatchAntValueInArray() { underTest = new ContentMatchesJsonPath("$.store.book[*].category", "fiction"); assertThat(underTest.test(failedMessage), is(true)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void messageContentIsNull() { when(failedMessage.getContent()).thenReturn(null); assertThat(underTest.test(failedMessage), is(false)); }
|
@Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
ContentMatchesJsonPath implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { final Object object = Optional.ofNullable(failedMessage.getContent()) .filter(StringUtils::isNotEmpty) .map(parseContext::parse) .map(content -> content.read(jsonPath)) .orElse(null); if (object instanceof JSONArray) { for (Object item: ((JSONArray)object)) { if (pattern.matcher(String.valueOf(item)).matches()) { return true; } } } else { return pattern .matcher(String.valueOf(object)) .matches(); } return false; } ContentMatchesJsonPath(@JsonProperty("jsonPath") String jsonPath,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void nameOfBrokerMatchers() { when(destination.getBrokerName()).thenReturn("some-broker"); assertThat(underTest.test(failedMessage), is(true)); }
|
@Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } BrokerEqualsPredicate(@JsonProperty("broker") String broker); }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } BrokerEqualsPredicate(@JsonProperty("broker") String broker); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } BrokerEqualsPredicate(@JsonProperty("broker") String broker); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void nameOfBrokerDoesNotMatch() { when(destination.getBrokerName()).thenReturn("another-broker"); assertThat(underTest.test(failedMessage), is(false)); }
|
@Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } BrokerEqualsPredicate(@JsonProperty("broker") String broker); }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } BrokerEqualsPredicate(@JsonProperty("broker") String broker); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
BrokerEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return broker.equals(failedMessage.getDestination().getBrokerName()); } BrokerEqualsPredicate(@JsonProperty("broker") String broker); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }
|
@Test public void currentStatusNotEqualTo() { assertThat(underTest.currentStatusNotEqualTo(DELETED), hasField(STATUS_HISTORY + ".0." + STATUS, hasField(NE, equalTo(DELETED.name())))); }
|
public Document currentStatusNotEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, new Document(NE, status.name())); }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusNotEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, new Document(NE, status.name())); } }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusNotEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, new Document(NE, status.name())); } }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusNotEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, new Document(NE, status.name())); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }
|
MongoStatusHistoryQueryBuilder { public Document currentStatusNotEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, new Document(NE, status.name())); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }
|
@Test public void shortCutEvaluationWhenFirstPredicateIsTrue() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(true)); verify(failedMessagePredicate1).test(failedMessage); verifyZeroInteractions(failedMessagePredicate2); }
|
@Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
@Test public void bothPredicatesAreEvaluatedWhenFirstPredicateReturnsFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(false); when(failedMessagePredicate2.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(true)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); }
|
@Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
@Test public void allPredicatesReturnFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(false); when(failedMessagePredicate2.test(failedMessage)).thenReturn(false); assertThat(underTest.test(failedMessage), is(false)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); }
|
@Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
OrPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .anyMatch(p -> p.test(failedMessage)); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
@Test public void canSerialiseAndDeserialisePredicate() throws IOException { ObjectMapper objectMapper = JacksonConfiguration.defaultObjectMapper(); objectMapper.registerSubtypes(BooleanPredicate.class); final OrPredicate underTest = objectMapper.readValue( objectMapper.writeValueAsString(new OrPredicate(singletonList(alwaysTruePredicate))), OrPredicate.class ); assertThat(underTest.getPredicates(), contains(alwaysTruePredicate)); }
|
public List<FailedMessagePredicate> getPredicates() { return predicates; }
|
OrPredicate implements FailedMessagePredicate { public List<FailedMessagePredicate> getPredicates() { return predicates; } }
|
OrPredicate implements FailedMessagePredicate { public List<FailedMessagePredicate> getPredicates() { return predicates; } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); }
|
OrPredicate implements FailedMessagePredicate { public List<FailedMessagePredicate> getPredicates() { return predicates; } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
OrPredicate implements FailedMessagePredicate { public List<FailedMessagePredicate> getPredicates() { return predicates; } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
@Test public void testDescribe() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.describe(new StringDescription()).getOutput(), is("( predicate1 OR predicate2 )")); }
|
@Override public <T> Description<T> describe(Description<T> description) { Description<T> finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" OR "); } } return finalDescription.append(" )"); }
|
OrPredicate implements FailedMessagePredicate { @Override public <T> Description<T> describe(Description<T> description) { Description<T> finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" OR "); } } return finalDescription.append(" )"); } }
|
OrPredicate implements FailedMessagePredicate { @Override public <T> Description<T> describe(Description<T> description) { Description<T> finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" OR "); } } return finalDescription.append(" )"); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); }
|
OrPredicate implements FailedMessagePredicate { @Override public <T> Description<T> describe(Description<T> description) { Description<T> finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" OR "); } } return finalDescription.append(" )"); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
OrPredicate implements FailedMessagePredicate { @Override public <T> Description<T> describe(Description<T> description) { Description<T> finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" OR "); } } return finalDescription.append(" )"); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
@Test public void toStringTest() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.toString(), is("( predicate1 OR predicate2 )")); }
|
@Override public String toString() { return describe(new StringDescription()).toString(); }
|
OrPredicate implements FailedMessagePredicate { @Override public String toString() { return describe(new StringDescription()).toString(); } }
|
OrPredicate implements FailedMessagePredicate { @Override public String toString() { return describe(new StringDescription()).toString(); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); }
|
OrPredicate implements FailedMessagePredicate { @Override public String toString() { return describe(new StringDescription()).toString(); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
OrPredicate implements FailedMessagePredicate { @Override public String toString() { return describe(new StringDescription()).toString(); } OrPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description<T> describe(Description<T> description); @Override String toString(); }
|
@Test public void canSerialiseAndDeserialiseAction() throws Exception { DeleteMessageAction underTest = objectMapper.readValue( objectMapper.writeValueAsString(new DeleteMessageAction(failedMessageService)), DeleteMessageAction.class ); when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); underTest.accept(failedMessage); verify(failedMessageService).delete(FAILED_MESSAGE_ID); }
|
@Override public void accept(FailedMessage failedMessage) { failedMessageService.delete(failedMessage.getFailedMessageId()); }
|
DeleteMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.delete(failedMessage.getFailedMessageId()); } }
|
DeleteMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.delete(failedMessage.getFailedMessageId()); } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); }
|
DeleteMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.delete(failedMessage.getFailedMessageId()); } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
DeleteMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.delete(failedMessage.getFailedMessageId()); } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void testToString() { assertThat(new DeleteMessageAction(failedMessageService).toString(), is("delete failedMessage")); }
|
@Override public String toString() { return "delete failedMessage"; }
|
DeleteMessageAction implements FailedMessageAction { @Override public String toString() { return "delete failedMessage"; } }
|
DeleteMessageAction implements FailedMessageAction { @Override public String toString() { return "delete failedMessage"; } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); }
|
DeleteMessageAction implements FailedMessageAction { @Override public String toString() { return "delete failedMessage"; } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
DeleteMessageAction implements FailedMessageAction { @Override public String toString() { return "delete failedMessage"; } DeleteMessageAction(@JacksonInject FailedMessageService failedMessageService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void canSerialiseAndDeserialiseAction() throws Exception { LabelMessageAction underTest = objectMapper.readValue( objectMapper.writeValueAsString(new LabelMessageAction("foo", failedMessageLabelService)), LabelMessageAction.class ); when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); underTest.accept(failedMessage); verify(failedMessageLabelService).addLabel(FAILED_MESSAGE_ID, "foo"); }
|
@Override public void accept(FailedMessage failedMessage) { failedMessageLabelService.addLabel(failedMessage.getFailedMessageId(), label); }
|
LabelMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageLabelService.addLabel(failedMessage.getFailedMessageId(), label); } }
|
LabelMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageLabelService.addLabel(failedMessage.getFailedMessageId(), label); } LabelMessageAction(@JsonProperty("label") String label,
@JacksonInject FailedMessageLabelService failedMessageLabelService); }
|
LabelMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageLabelService.addLabel(failedMessage.getFailedMessageId(), label); } LabelMessageAction(@JsonProperty("label") String label,
@JacksonInject FailedMessageLabelService failedMessageLabelService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
LabelMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageLabelService.addLabel(failedMessage.getFailedMessageId(), label); } LabelMessageAction(@JsonProperty("label") String label,
@JacksonInject FailedMessageLabelService failedMessageLabelService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void testToString() { LabelMessageAction underTest = new LabelMessageAction("foo", failedMessageLabelService); assertThat(underTest.toString(), Matchers.is("set label 'foo'")); }
|
@Override public String toString() { return "set label '" + label + "'"; }
|
LabelMessageAction implements FailedMessageAction { @Override public String toString() { return "set label '" + label + "'"; } }
|
LabelMessageAction implements FailedMessageAction { @Override public String toString() { return "set label '" + label + "'"; } LabelMessageAction(@JsonProperty("label") String label,
@JacksonInject FailedMessageLabelService failedMessageLabelService); }
|
LabelMessageAction implements FailedMessageAction { @Override public String toString() { return "set label '" + label + "'"; } LabelMessageAction(@JsonProperty("label") String label,
@JacksonInject FailedMessageLabelService failedMessageLabelService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
LabelMessageAction implements FailedMessageAction { @Override public String toString() { return "set label '" + label + "'"; } LabelMessageAction(@JsonProperty("label") String label,
@JacksonInject FailedMessageLabelService failedMessageLabelService); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void findFailedMessageThatDoesNotExistReturnsNull() { assertThat(underTest.findById(newFailedMessageId()), is(Optional.empty())); }
|
@Override public Optional<FailedMessage> findById(FailedMessageId failedMessageId) { return Optional.ofNullable(collection .find(failedMessageConverter.createId(failedMessageId)) .map(failedMessageConverter::convertToObject) .first()); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public Optional<FailedMessage> findById(FailedMessageId failedMessageId) { return Optional.ofNullable(collection .find(failedMessageConverter.createId(failedMessageId)) .map(failedMessageConverter::convertToObject) .first()); } }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public Optional<FailedMessage> findById(FailedMessageId failedMessageId) { return Optional.ofNullable(collection .find(failedMessageConverter.createId(failedMessageId)) .map(failedMessageConverter::convertToObject) .first()); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public Optional<FailedMessage> findById(FailedMessageId failedMessageId) { return Optional.ofNullable(collection .find(failedMessageConverter.createId(failedMessageId)) .map(failedMessageConverter::convertToObject) .first()); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public Optional<FailedMessage> findById(FailedMessageId failedMessageId) { return Optional.ofNullable(collection .find(failedMessageConverter.createId(failedMessageId)) .map(failedMessageConverter::convertToObject) .first()); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
@Test public void resendFailedMessageActionWithNullDelay() { ResendFailedMessageAction underTest = resendFailedMessageActionWithFixedClock(null); underTest.accept(failedMessage); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), aStatusUpdateRequest(RESEND).withUpdatedDateTime(FIXED_CLOCK.instant())); }
|
@Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void resendFailedMessageActionWithGivenDelay() { ResendFailedMessageAction underTest = resendFailedMessageActionWithFixedClock(Duration.ofSeconds(10)); underTest.accept(failedMessage); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), aStatusUpdateRequest(RESEND).withUpdatedDateTime(FIXED_CLOCK.instant().plusSeconds(10))); }
|
@Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { failedMessageService.update( failedMessage.getFailedMessageId(), new StatusUpdateRequest(RESEND, clock.instant().plus(getResendDelay()))); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void testToString() { ResendFailedMessageAction underTest = resendFailedMessageActionWithFixedClock(Duration.ofDays(2).plusMinutes(15).plusSeconds(10).plusMillis(5)); assertThat(underTest.toString(), Matchers.is("resend in 48:15:10.005")); }
|
@Override public String toString() { return "resend in " + formatDurationHMS(getResendDelay().toMillis()); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public String toString() { return "resend in " + formatDurationHMS(getResendDelay().toMillis()); } }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public String toString() { return "resend in " + formatDurationHMS(getResendDelay().toMillis()); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public String toString() { return "resend in " + formatDurationHMS(getResendDelay().toMillis()); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
ResendFailedMessageAction implements FailedMessageAction { @Override public String toString() { return "resend in " + formatDurationHMS(getResendDelay().toMillis()); } ResendFailedMessageAction(@JsonProperty("resendDelay") Duration resendDelay,
@JacksonInject FailedMessageService failedMessageService); ResendFailedMessageAction(Duration resendDelay,
FailedMessageService failedMessageService,
Clock clock); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void allActionsInTheListAreExecuted() { ChainedFailedMessageAction underTest = new ChainedFailedMessageAction(Arrays.asList( failedMessageAction1, failedMessageAction2 )); underTest.accept(failedMessage); verify(failedMessageAction1).accept(failedMessage); verify(failedMessageAction2).accept(failedMessage); }
|
@Override public void accept(FailedMessage failedMessage) { actions.forEach(action -> action.accept(failedMessage)); }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { actions.forEach(action -> action.accept(failedMessage)); } }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { actions.forEach(action -> action.accept(failedMessage)); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { actions.forEach(action -> action.accept(failedMessage)); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public void accept(FailedMessage failedMessage) { actions.forEach(action -> action.accept(failedMessage)); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void testToString() { when(failedMessageAction1.toString()).thenReturn("action1"); when(failedMessageAction2.toString()).thenReturn("action2"); ChainedFailedMessageAction underTest = new ChainedFailedMessageAction(Arrays.asList( failedMessageAction1, failedMessageAction2 )); assertThat(underTest.toString(), Matchers.is("action1 AND action2")); }
|
@Override public String toString() { return actions.stream().map(Object::toString).collect(Collectors.joining(" AND ")); }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public String toString() { return actions.stream().map(Object::toString).collect(Collectors.joining(" AND ")); } }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public String toString() { return actions.stream().map(Object::toString).collect(Collectors.joining(" AND ")); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public String toString() { return actions.stream().map(Object::toString).collect(Collectors.joining(" AND ")); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
ChainedFailedMessageAction implements FailedMessageAction { @Override public String toString() { return actions.stream().map(Object::toString).collect(Collectors.joining(" AND ")); } ChainedFailedMessageAction(@JsonProperty("actions") List<FailedMessageAction> actions); @Override void accept(FailedMessage failedMessage); @Override String toString(); }
|
@Test public void convertOutcomeToOutcomeResponse() throws JsonProcessingException { when(outcome.isMatched()).thenReturn(true); when(outcome.getFailedMessage()).thenReturn(failedMessage); when(outcome.getDescription()).thenReturn("Description"); when(outcome.getFailedMessageAction()).thenReturn(failedMessageAction); when(objectMapper.writeValueAsString(failedMessageAction)).thenReturn("Action"); when(failedMessageResponseFactory.create(failedMessage)).thenReturn(failedMessageResponse); final MessageClassificationOutcomeResponse response = underTest.toOutcomeResponse(outcome); assertThat(response.isMatched(), is(true)); assertThat(response.getFailedMessageResponse(), is(failedMessageResponse)); assertThat(response.getAction(), is("Action")); assertThat(response.getDescription(), is("Description")); }
|
public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } MessageClassificationOutcomeAdapter(ObjectMapper objectMapper,
FailedMessageResponseFactory failedMessageResponseFactory); }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } MessageClassificationOutcomeAdapter(ObjectMapper objectMapper,
FailedMessageResponseFactory failedMessageResponseFactory); MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome); }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } MessageClassificationOutcomeAdapter(ObjectMapper objectMapper,
FailedMessageResponseFactory failedMessageResponseFactory); MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome); }
|
@Test public void actionIsClassNameWhenJsonProcessingExceptionIsThrown() throws JsonProcessingException { failedMessageAction = new StubFailedMessageAction(); when(outcome.isMatched()).thenReturn(true); when(outcome.getFailedMessage()).thenReturn(failedMessage); when(outcome.getDescription()).thenReturn("Description"); when(outcome.getFailedMessageAction()).thenReturn(failedMessageAction); when(objectMapper.writeValueAsString(failedMessageAction)).thenThrow(JsonProcessingException.class); when(failedMessageResponseFactory.create(failedMessage)).thenReturn(failedMessageResponse); final MessageClassificationOutcomeResponse response = underTest.toOutcomeResponse(outcome); assertThat(response.isMatched(), is(true)); assertThat(response.getFailedMessageResponse(), is(failedMessageResponse)); assertThat(response.getAction(), is("StubFailedMessageAction")); assertThat(response.getDescription(), is("Description")); }
|
public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } MessageClassificationOutcomeAdapter(ObjectMapper objectMapper,
FailedMessageResponseFactory failedMessageResponseFactory); }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } MessageClassificationOutcomeAdapter(ObjectMapper objectMapper,
FailedMessageResponseFactory failedMessageResponseFactory); MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome); }
|
MessageClassificationOutcomeAdapter { public MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome) { String failedMessageAction; try { failedMessageAction = objectMapper.writeValueAsString(outcome.getFailedMessageAction()); } catch (JsonProcessingException e) { failedMessageAction = outcome.getFailedMessageAction().getClass().getSimpleName(); LOGGER.error("Could not serialise {}", failedMessageAction, e); } return new MessageClassificationOutcomeResponse( outcome.isMatched(), outcome.getDescription(), failedMessageResponseFactory.create(outcome.getFailedMessage()), failedMessageAction ); } MessageClassificationOutcomeAdapter(ObjectMapper objectMapper,
FailedMessageResponseFactory failedMessageResponseFactory); MessageClassificationOutcomeResponse toOutcomeResponse(MessageClassificationOutcome outcome); }
|
@Test public void noClassifiersMatch() { when(messageClassifier1.classify(context)).thenReturn(classifier1Outcome); when(messageClassifier2.classify(context)).thenReturn(classifier2Outcome); when(classifier1Outcome.isMatched()).thenReturn(false); when(finalOutcome.isMatched()).thenReturn(false); when(classifier1Outcome.or(classifier2Outcome)).thenReturn(finalOutcome); assertThat(underTest.classify(context), is(finalOutcome)); verify(messageClassifier1).classify(context); verify(messageClassifier2).classify(context); verify(classifier1Outcome).or(classifier2Outcome); }
|
@Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
@Test public void firstClassifierMatches() { when(messageClassifier1.classify(context)).thenReturn(classifier1Outcome); when(classifier1Outcome.isMatched()).thenReturn(true); assertThat(underTest.classify(context), is(this.classifier1Outcome)); verify(messageClassifier1).classify(context); verifyZeroInteractions(messageClassifier2); }
|
@Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
MessageClassifierGroup implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { MessageClassificationOutcome outcome = null; for (MessageClassifier messageClassifier : messageClassifiers) { final MessageClassificationOutcome latestOutcome = messageClassifier.classify(context); outcome = Optional.ofNullable(outcome).map(currentOutcome -> currentOutcome.or(latestOutcome)).orElse(latestOutcome); if (outcome.isMatched()) { return outcome; } } return Optional.ofNullable(outcome).orElse(context.notMatched(new BooleanPredicate(false))); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
@Test public void canSerialiseAndDeserialiseMessageClassifier() throws IOException { final ObjectMapper objectMapper = JacksonConfiguration.defaultObjectMapper(); objectMapper.registerSubtypes(DoNothingMessageClassifier.class); underTest = newClassifierCollection() .withClassifier(new DoNothingMessageClassifier()) .withClassifier(new DoNothingMessageClassifier()) .build(); final String json = objectMapper.writeValueAsString(underTest); assertThat(json, allOf( hasJsonPath("$._classifier", equalTo("collection")), hasJsonPath("$.classifiers[0]._classifier", equalTo("doNothing")), hasJsonPath("$.classifiers[1]._classifier", equalTo("doNothing")) )); assertThat(objectMapper.readValue(json, MessageClassifier.class), reflectionEquals(underTest)); }
|
public static Builder newClassifierCollection() { return new Builder(); }
|
MessageClassifierGroup implements MessageClassifier { public static Builder newClassifierCollection() { return new Builder(); } }
|
MessageClassifierGroup implements MessageClassifier { public static Builder newClassifierCollection() { return new Builder(); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); }
|
MessageClassifierGroup implements MessageClassifier { public static Builder newClassifierCollection() { return new Builder(); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
MessageClassifierGroup implements MessageClassifier { public static Builder newClassifierCollection() { return new Builder(); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
@Test public void findNumberOfMessagesForBroker() { underTest.insert(failedMessageBuilder .withNewFailedMessageId() .withDestination(new Destination("brokerA", of("queue-name"))) .build()); underTest.insert(failedMessageBuilder .withNewFailedMessageId() .withDestination(new Destination("brokerB", of("queue-name"))) .build()); assertThat(underTest.findNumberOfMessagesForBroker("brokerA"), is(1L)); }
|
@Override public long findNumberOfMessagesForBroker(String broker) { return collection.count(new Document(DESTINATION + "." + BROKER_NAME, broker)); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long findNumberOfMessagesForBroker(String broker) { return collection.count(new Document(DESTINATION + "." + BROKER_NAME, broker)); } }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long findNumberOfMessagesForBroker(String broker) { return collection.count(new Document(DESTINATION + "." + BROKER_NAME, broker)); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long findNumberOfMessagesForBroker(String broker) { return collection.count(new Document(DESTINATION + "." + BROKER_NAME, broker)); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long findNumberOfMessagesForBroker(String broker) { return collection.count(new Document(DESTINATION + "." + BROKER_NAME, broker)); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
@Test public void testToString() { when(messageClassifier1.toString()).thenReturn("classifier1"); when(messageClassifier2.toString()).thenReturn("classifier2"); final MessageClassifierGroup underTest = newClassifierCollection().withClassifier(messageClassifier1).withClassifier(messageClassifier2).build(); assertThat(underTest.toString(), is("classifier1 OR classifier2")); }
|
@Override public String toString() { return messageClassifiers.stream().map(MessageClassifier::toString).collect(Collectors.joining(" OR ")); }
|
MessageClassifierGroup implements MessageClassifier { @Override public String toString() { return messageClassifiers.stream().map(MessageClassifier::toString).collect(Collectors.joining(" OR ")); } }
|
MessageClassifierGroup implements MessageClassifier { @Override public String toString() { return messageClassifiers.stream().map(MessageClassifier::toString).collect(Collectors.joining(" OR ")); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); }
|
MessageClassifierGroup implements MessageClassifier { @Override public String toString() { return messageClassifiers.stream().map(MessageClassifier::toString).collect(Collectors.joining(" OR ")); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
MessageClassifierGroup implements MessageClassifier { @Override public String toString() { return messageClassifiers.stream().map(MessageClassifier::toString).collect(Collectors.joining(" OR ")); } private MessageClassifierGroup(@JsonProperty("classifiers") List<MessageClassifier> messageClassifiers); static Builder newClassifierCollection(); static Builder copyClassifierCollection(MessageClassifierGroup messageClassifierGroup); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); List<MessageClassifier> getClassifiers(); }
|
@Test public void actionIsExecutedIfThePredicateIsTrue() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(true); when(context.matched(predicate, action)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).matched(predicate, action); }
|
@Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
@Test public void actionIsNotExecutedIfThePredicateIsFalse() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(false); when(context.notMatched(predicate)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).notMatched(predicate); }
|
@Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate, action); } else { return context.notMatched(predicate); } } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
@Test public void testToString() { when(predicate.toString()).thenReturn("predicate"); when(action.toString()).thenReturn("action"); assertThat(underTest.toString(), is("if predicate then action")); }
|
@Override public String toString() { return "if " + predicate + " then " + action; }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + action; } }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + action; } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + action; } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
ExecutingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + action; } ExecutingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("action") FailedMessageAction action); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
@Test public void getDefaultDescription() { when(matchedPredicate.describe(any(StringDescription.class))).thenAnswer((Answer<Description<String>>) invocation -> ((StringDescription)invocation.getArgument(0)).append("predicate1")); assertThat(matched().getDescription(), is(equalTo("matched = true, predicate1"))); }
|
public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } MessageClassificationOutcome(boolean matched,
FailedMessagePredicate predicate,
FailedMessage failedMessage,
FailedMessageAction action); }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } MessageClassificationOutcome(boolean matched,
FailedMessagePredicate predicate,
FailedMessage failedMessage,
FailedMessageAction action); boolean isMatched(); String getDescription(); Description<T> getDescription(Description<T> description); FailedMessage getFailedMessage(); void execute(); @Override String toString(); MessageClassificationOutcome and(MessageClassificationOutcome outcome); MessageClassificationOutcome or(MessageClassificationOutcome outcome); }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } MessageClassificationOutcome(boolean matched,
FailedMessagePredicate predicate,
FailedMessage failedMessage,
FailedMessageAction action); boolean isMatched(); String getDescription(); Description<T> getDescription(Description<T> description); FailedMessage getFailedMessage(); void execute(); @Override String toString(); MessageClassificationOutcome and(MessageClassificationOutcome outcome); MessageClassificationOutcome or(MessageClassificationOutcome outcome); }
|
@Test public void getDescription() { assertThat(matched().getDescription(description), is(notNullValue(Description.class))); }
|
public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } MessageClassificationOutcome(boolean matched,
FailedMessagePredicate predicate,
FailedMessage failedMessage,
FailedMessageAction action); }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } MessageClassificationOutcome(boolean matched,
FailedMessagePredicate predicate,
FailedMessage failedMessage,
FailedMessageAction action); boolean isMatched(); String getDescription(); Description<T> getDescription(Description<T> description); FailedMessage getFailedMessage(); void execute(); @Override String toString(); MessageClassificationOutcome and(MessageClassificationOutcome outcome); MessageClassificationOutcome or(MessageClassificationOutcome outcome); }
|
MessageClassificationOutcome { public String getDescription() { return predicate.describe(new StringDescription().append("matched = ").append(matched).append(", ")).getOutput(); } MessageClassificationOutcome(boolean matched,
FailedMessagePredicate predicate,
FailedMessage failedMessage,
FailedMessageAction action); boolean isMatched(); String getDescription(); Description<T> getDescription(Description<T> description); FailedMessage getFailedMessage(); void execute(); @Override String toString(); MessageClassificationOutcome and(MessageClassificationOutcome outcome); MessageClassificationOutcome or(MessageClassificationOutcome outcome); }
|
@Test public void predicateIsNotMatched() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(false); when(context.notMatched(predicate)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).notMatched(predicate); verifyZeroInteractions(messageClassifierGroup); }
|
@Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
@Test public void predicateIsMatched() { when(context.getFailedMessage()).thenReturn(failedMessage); when(predicate.test(failedMessage)).thenReturn(true); MessageClassificationOutcome initialClassificationOutcome = mock(MessageClassificationOutcome.class); when(context.matched(predicate)).thenReturn(initialClassificationOutcome); MessageClassificationOutcome subsequentClassificationOutcome = mock(MessageClassificationOutcome.class); when(messageClassifierGroup.classify(context)).thenReturn(subsequentClassificationOutcome); when(initialClassificationOutcome.and(subsequentClassificationOutcome)).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); verify(predicate).test(failedMessage); verify(context).matched(predicate); verify(initialClassificationOutcome).and(subsequentClassificationOutcome); }
|
@Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { final boolean matched = predicate.test(context.getFailedMessage()); if (matched) { return context.matched(predicate).and(messageClassifier.classify(context)); } else { return context.notMatched(predicate); } } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
@Test public void testToString() { when(predicate.toString()).thenReturn("predicate"); when(messageClassifierGroup.toString()).thenReturn("more classifiers"); assertThat(underTest.toString(), is("if predicate then more classifiers")); }
|
@Override public String toString() { return "if " + predicate + " then " + messageClassifier; }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + messageClassifier; } }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + messageClassifier; } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + messageClassifier; } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
DelegatingMessageClassifier implements MessageClassifier { @Override public String toString() { return "if " + predicate + " then " + messageClassifier; } DelegatingMessageClassifier(@JsonProperty("predicate") FailedMessagePredicate predicate,
@JsonProperty("messageClassifier") MessageClassifier messageClassifier); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); }
|
@Test public void testEquals() { assertThat(underTest.equals(null), is(false)); assertThat(underTest.equals(new BooleanPredicate(true)), is(false)); assertThat(underTest.equals(new FailedMessagePredicateWithResult(false, failedMessagePredicate)), is(false)); assertThat(underTest.equals(new FailedMessagePredicateWithResult(true, mock(FailedMessagePredicate.class))), is(false)); assertThat(underTest.equals(new FailedMessagePredicateWithResult(true, failedMessagePredicate)), is(true)); }
|
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FailedMessagePredicateWithResult that = (FailedMessagePredicateWithResult) o; return result == that.result && Objects.equals(predicate, that.predicate); }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FailedMessagePredicateWithResult that = (FailedMessagePredicateWithResult) o; return result == that.result && Objects.equals(predicate, that.predicate); } }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FailedMessagePredicateWithResult that = (FailedMessagePredicateWithResult) o; return result == that.result && Objects.equals(predicate, that.predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result,
@JsonProperty("predicate") FailedMessagePredicate predicate); }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FailedMessagePredicateWithResult that = (FailedMessagePredicateWithResult) o; return result == that.result && Objects.equals(predicate, that.predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result,
@JsonProperty("predicate") FailedMessagePredicate predicate); @Override boolean test(FailedMessage failedMessage); @Override Description<T> describe(Description<T> description); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FailedMessagePredicateWithResult that = (FailedMessagePredicateWithResult) o; return result == that.result && Objects.equals(predicate, that.predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result,
@JsonProperty("predicate") FailedMessagePredicate predicate); @Override boolean test(FailedMessage failedMessage); @Override Description<T> describe(Description<T> description); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void removeOnAnEmptyCollection() { assertThat(underTest.removeFailedMessages(), is(0L)); }
|
@Override public long removeFailedMessages() { return collection.deleteMany(removeRecordsQueryFactory.create()).getDeletedCount(); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long removeFailedMessages() { return collection.deleteMany(removeRecordsQueryFactory.create()).getDeletedCount(); } }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long removeFailedMessages() { return collection.deleteMany(removeRecordsQueryFactory.create()).getDeletedCount(); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long removeFailedMessages() { return collection.deleteMany(removeRecordsQueryFactory.create()).getDeletedCount(); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public long removeFailedMessages() { return collection.deleteMany(removeRecordsQueryFactory.create()).getDeletedCount(); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
@Test public void testHashCode() { assertThat(underTest.hashCode(), is(Arrays.hashCode(new Object[] {true, failedMessagePredicate}))); }
|
@Override public int hashCode() { return Objects.hash(result, predicate); }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public int hashCode() { return Objects.hash(result, predicate); } }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public int hashCode() { return Objects.hash(result, predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result,
@JsonProperty("predicate") FailedMessagePredicate predicate); }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public int hashCode() { return Objects.hash(result, predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result,
@JsonProperty("predicate") FailedMessagePredicate predicate); @Override boolean test(FailedMessage failedMessage); @Override Description<T> describe(Description<T> description); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }
|
FailedMessagePredicateWithResult implements FailedMessagePredicate { @Override public int hashCode() { return Objects.hash(result, predicate); } FailedMessagePredicateWithResult(@JsonProperty("result") boolean result,
@JsonProperty("predicate") FailedMessagePredicate predicate); @Override boolean test(FailedMessage failedMessage); @Override Description<T> describe(Description<T> description); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void notMatched() { final MessageClassificationOutcome outcome = underTest.notMatched(failedMessagePredicate); assertThat(outcome.isMatched(), is(false)); assertThat(outcome.getFailedMessage(), is(failedMessage)); assertThat(outcome.getFailedMessageAction(), is(nullValue())); assertThat(outcome.getFailedMessagePredicate(), is(new FailedMessagePredicateWithResult(false, failedMessagePredicate))); }
|
public MessageClassificationOutcome notMatched(FailedMessagePredicate predicate) { return new MessageClassificationOutcome(false, new FailedMessagePredicateWithResult(false, predicate), failedMessage,null); }
|
MessageClassificationContext { public MessageClassificationOutcome notMatched(FailedMessagePredicate predicate) { return new MessageClassificationOutcome(false, new FailedMessagePredicateWithResult(false, predicate), failedMessage,null); } }
|
MessageClassificationContext { public MessageClassificationOutcome notMatched(FailedMessagePredicate predicate) { return new MessageClassificationOutcome(false, new FailedMessagePredicateWithResult(false, predicate), failedMessage,null); } MessageClassificationContext(FailedMessage failedMessage); }
|
MessageClassificationContext { public MessageClassificationOutcome notMatched(FailedMessagePredicate predicate) { return new MessageClassificationOutcome(false, new FailedMessagePredicateWithResult(false, predicate), failedMessage,null); } MessageClassificationContext(FailedMessage failedMessage); FailedMessage getFailedMessage(); MessageClassificationOutcome matched(FailedMessagePredicate predicate); MessageClassificationOutcome matched(FailedMessagePredicate predicate, FailedMessageAction action); MessageClassificationOutcome notMatched(FailedMessagePredicate predicate); @Override boolean equals(Object o); @Override int hashCode(); }
|
MessageClassificationContext { public MessageClassificationOutcome notMatched(FailedMessagePredicate predicate) { return new MessageClassificationOutcome(false, new FailedMessagePredicateWithResult(false, predicate), failedMessage,null); } MessageClassificationContext(FailedMessage failedMessage); FailedMessage getFailedMessage(); MessageClassificationOutcome matched(FailedMessagePredicate predicate); MessageClassificationOutcome matched(FailedMessagePredicate predicate, FailedMessageAction action); MessageClassificationOutcome notMatched(FailedMessagePredicate predicate); @Override boolean equals(Object o); @Override int hashCode(); final FailedMessage failedMessage; }
|
@Test public void testClassify() { when(context.getFailedMessage()).thenReturn(failedMessage); when(context.notMatched(new BooleanPredicate(false))).thenReturn(outcome); assertThat(underTest.classify(context), is(outcome)); }
|
@Override public MessageClassificationOutcome classify(MessageClassificationContext context) { return context.notMatched(new BooleanPredicate(false)); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { return context.notMatched(new BooleanPredicate(false)); } }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { return context.notMatched(new BooleanPredicate(false)); } private UnmatchedMessageClassifier(); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { return context.notMatched(new BooleanPredicate(false)); } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public MessageClassificationOutcome classify(MessageClassificationContext context) { return context.notMatched(new BooleanPredicate(false)); } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final UnmatchedMessageClassifier ALWAYS_UNMATCHED; }
|
@Test public void testToString() { assertThat(underTest.toString(), is("unmatched")); }
|
@Override public String toString() { return "unmatched"; }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public String toString() { return "unmatched"; } }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public String toString() { return "unmatched"; } private UnmatchedMessageClassifier(); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public String toString() { return "unmatched"; } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public String toString() { return "unmatched"; } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final UnmatchedMessageClassifier ALWAYS_UNMATCHED; }
|
@Test public void testEquals() { assertThat(underTest.equals(UnmatchedMessageClassifier.ALWAYS_UNMATCHED), is(true)); assertThat(underTest.equals(newClassifierCollection().build()), is(false)); assertThat(underTest.equals(null), is(false)); }
|
@Override public boolean equals(Object obj) { return this == obj; }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public boolean equals(Object obj) { return this == obj; } }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public boolean equals(Object obj) { return this == obj; } private UnmatchedMessageClassifier(); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public boolean equals(Object obj) { return this == obj; } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public boolean equals(Object obj) { return this == obj; } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final UnmatchedMessageClassifier ALWAYS_UNMATCHED; }
|
@Test public void testHashCode() { assertThat(underTest.hashCode(), is(544)); }
|
@Override public int hashCode() { return 17 * 32; }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public int hashCode() { return 17 * 32; } }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public int hashCode() { return 17 * 32; } private UnmatchedMessageClassifier(); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public int hashCode() { return 17 * 32; } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
UnmatchedMessageClassifier implements MessageClassifier { @Override public int hashCode() { return 17 * 32; } private UnmatchedMessageClassifier(); @Override MessageClassificationOutcome classify(MessageClassificationContext context); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final UnmatchedMessageClassifier ALWAYS_UNMATCHED; }
|
@Test public void jobExecutesSuccessfully() throws Exception { underTest.start(); verifyMessageClassificationServiceExecutions(75); }
|
@ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") void start(); @ApiOperation( value = "Synchronously execute the resend job for the given broker", code = 204 ) @POST @Path("/execute") void execute(); @ApiOperation( value = "Pause/Stop the Message Classification executor", code = 204 ) @PUT @Path("/pause") void pause(); void stop(); }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") void start(); @ApiOperation( value = "Synchronously execute the resend job for the given broker", code = 204 ) @POST @Path("/execute") void execute(); @ApiOperation( value = "Pause/Stop the Message Classification executor", code = 204 ) @PUT @Path("/pause") void pause(); void stop(); }
|
@Test public void jobContinuesToExecuteIfExceptionIsThrown() throws InterruptedException { doAnswer(decrementCountdownLatchAndThrowException()) .when(messageClassificationService) .classifyFailedMessages(); underTest.start(); verifyMessageClassificationServiceExecutions(75); verifyMessageClassificationServiceExecutions(120); }
|
@ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") void start(); @ApiOperation( value = "Synchronously execute the resend job for the given broker", code = 204 ) @POST @Path("/execute") void execute(); @ApiOperation( value = "Pause/Stop the Message Classification executor", code = 204 ) @PUT @Path("/pause") void pause(); void stop(); }
|
MessageClassificationExecutorService { @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") public void start() { LOGGER.info("MessageClassificationService scheduled to start in {} {} and then execute every {} {}", initialDelay, timeUnit, executionFrequency, timeUnit ); scheduleAtAFixedRate(initialDelay); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") void start(); @ApiOperation( value = "Synchronously execute the resend job for the given broker", code = 204 ) @POST @Path("/execute") void execute(); @ApiOperation( value = "Pause/Stop the Message Classification executor", code = 204 ) @PUT @Path("/pause") void pause(); void stop(); }
|
@Test public void executorCanBeStopped() { underTest.stop(); assertThat(scheduledExecutorService.isShutdown(), is(true)); }
|
public void stop() { LOGGER.info("Stopping execution of the MessageClassificationService"); scheduledExecutorService.shutdown(); LOGGER.info("Execution of the MessageClassificationService stopped"); }
|
MessageClassificationExecutorService { public void stop() { LOGGER.info("Stopping execution of the MessageClassificationService"); scheduledExecutorService.shutdown(); LOGGER.info("Execution of the MessageClassificationService stopped"); } }
|
MessageClassificationExecutorService { public void stop() { LOGGER.info("Stopping execution of the MessageClassificationService"); scheduledExecutorService.shutdown(); LOGGER.info("Execution of the MessageClassificationService stopped"); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); }
|
MessageClassificationExecutorService { public void stop() { LOGGER.info("Stopping execution of the MessageClassificationService"); scheduledExecutorService.shutdown(); LOGGER.info("Execution of the MessageClassificationService stopped"); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") void start(); @ApiOperation( value = "Synchronously execute the resend job for the given broker", code = 204 ) @POST @Path("/execute") void execute(); @ApiOperation( value = "Pause/Stop the Message Classification executor", code = 204 ) @PUT @Path("/pause") void pause(); void stop(); }
|
MessageClassificationExecutorService { public void stop() { LOGGER.info("Stopping execution of the MessageClassificationService"); scheduledExecutorService.shutdown(); LOGGER.info("Execution of the MessageClassificationService stopped"); } MessageClassificationExecutorService(ScheduledExecutorService scheduledExecutorService,
MessageClassificationService messageClassificationService,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); @ApiOperation( value = "Start the Message Classification executor with the configuration in application.yml", code = 204 ) @POST @Path("/start") void start(); @ApiOperation( value = "Synchronously execute the resend job for the given broker", code = 204 ) @POST @Path("/execute") void execute(); @ApiOperation( value = "Pause/Stop the Message Classification executor", code = 204 ) @PUT @Path("/pause") void pause(); void stop(); }
|
@Test public void addMessageClassifierDelegatesToRepository() { ArgumentCaptor<MessageClassifierGroup> captor = ArgumentCaptor.forClass(MessageClassifierGroup.class); Mockito.doNothing().when(repository).save(captor.capture()); underTest.addMessageClassifier(messageClassifier); assertThat(captor.getValue().getClassifiers(), contains(messageClassifier)); verify(repository).save(captor.getValue()); }
|
@Override public void addMessageClassifier(MessageClassifier messageClassifier) { messageClassificationRepository.save(MessageClassifierGroup.newClassifierCollection().withClassifier(messageClassifier).build()); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void addMessageClassifier(MessageClassifier messageClassifier) { messageClassificationRepository.save(MessageClassifierGroup.newClassifierCollection().withClassifier(messageClassifier).build()); } }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void addMessageClassifier(MessageClassifier messageClassifier) { messageClassificationRepository.save(MessageClassifierGroup.newClassifierCollection().withClassifier(messageClassifier).build()); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void addMessageClassifier(MessageClassifier messageClassifier) { messageClassificationRepository.save(MessageClassifierGroup.newClassifierCollection().withClassifier(messageClassifier).build()); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void addMessageClassifier(MessageClassifier messageClassifier) { messageClassificationRepository.save(MessageClassifierGroup.newClassifierCollection().withClassifier(messageClassifier).build()); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
@Test public void addLabelToAFailedMessageThatDoesNotExist() { underTest.addLabel(failedMessageId, "foo"); assertThat(collection.count(), is(0L)); }
|
@Override public void addLabel(FailedMessageId failedMessageId, String label) { UpdateResult updateResult = collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$addToSet", new Document(LABELS, label)) ); LOGGER.debug("{} rows updated", updateResult.getModifiedCount()); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void addLabel(FailedMessageId failedMessageId, String label) { UpdateResult updateResult = collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$addToSet", new Document(LABELS, label)) ); LOGGER.debug("{} rows updated", updateResult.getModifiedCount()); } }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void addLabel(FailedMessageId failedMessageId, String label) { UpdateResult updateResult = collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$addToSet", new Document(LABELS, label)) ); LOGGER.debug("{} rows updated", updateResult.getModifiedCount()); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void addLabel(FailedMessageId failedMessageId, String label) { UpdateResult updateResult = collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$addToSet", new Document(LABELS, label)) ); LOGGER.debug("{} rows updated", updateResult.getModifiedCount()); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void addLabel(FailedMessageId failedMessageId, String label) { UpdateResult updateResult = collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$addToSet", new Document(LABELS, label)) ); LOGGER.debug("{} rows updated", updateResult.getModifiedCount()); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
@Test public void listMessageClassifiers() { when(repository.findLatest()).thenReturn(messageClassifier); assertThat(underTest.listAllMessageClassifiers(), is(messageClassifier)); }
|
@Override public MessageClassifier listAllMessageClassifiers() { return messageClassificationRepository.findLatest(); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassifier listAllMessageClassifiers() { return messageClassificationRepository.findLatest(); } }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassifier listAllMessageClassifiers() { return messageClassificationRepository.findLatest(); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassifier listAllMessageClassifiers() { return messageClassificationRepository.findLatest(); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassifier listAllMessageClassifiers() { return messageClassificationRepository.findLatest(); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
@Test public void removeAllDelegatesFromRepository() { underTest.removeAllMessageClassifiers(); verify(repository).deleteAll(); }
|
@Override public void removeAllMessageClassifiers() { messageClassificationRepository.deleteAll(); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void removeAllMessageClassifiers() { messageClassificationRepository.deleteAll(); } }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void removeAllMessageClassifiers() { messageClassificationRepository.deleteAll(); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void removeAllMessageClassifiers() { messageClassificationRepository.deleteAll(); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public void removeAllMessageClassifiers() { messageClassificationRepository.deleteAll(); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
@Test(expected = FailedMessageNotFoundException.class) public void classifyByIfWhenFailedMessageDoesNotExist() { when(failedMessageSearchService.findById(failedMessageId)).thenReturn(Optional.empty()); underTest.classifyFailedMessage(failedMessageId); verifyZeroInteractions(messageClassifier); verifyZeroInteractions(outcomeAdapter); }
|
@Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
@Test public void classifyByFailedMessageId() { when(failedMessageSearchService.findById(failedMessageId)).thenReturn(Optional.of(failedMessage)); when(repository.findLatest()).thenReturn(messageClassifier); when(messageClassifier.classify(new MessageClassificationContext(failedMessage))).thenReturn(messageClassificationOutcome); when(outcomeAdapter.toOutcomeResponse(messageClassificationOutcome)).thenReturn(messageClassificationOutcomeResponse); final MessageClassificationOutcomeResponse outcomeResponse = underTest.classifyFailedMessage(failedMessageId); assertThat(outcomeResponse, is(messageClassificationOutcomeResponse)); verify(failedMessageSearchService).findById(failedMessageId); verify(messageClassifier).classify(new MessageClassificationContext(failedMessage)); verify(outcomeAdapter).toOutcomeResponse(messageClassificationOutcome); verifyZeroInteractions(messageClassificationOutcome); }
|
@Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
@Test public void classifyFailedMessage() { when(repository.findLatest()).thenReturn(messageClassifier); when(messageClassifier.classify(new MessageClassificationContext(failedMessage))).thenReturn(messageClassificationOutcome); when(outcomeAdapter.toOutcomeResponse(messageClassificationOutcome)).thenReturn(messageClassificationOutcomeResponse); final MessageClassificationOutcomeResponse outcome = underTest.classifyFailedMessage(failedMessage); assertThat(outcome, is(messageClassificationOutcomeResponse)); verify(messageClassifier).classify(new MessageClassificationContext(failedMessage)); verify(outcomeAdapter).toOutcomeResponse(messageClassificationOutcome); verifyZeroInteractions(messageClassificationOutcome); }
|
@Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
MessageClassificationResource implements MessageClassificationClient { @Override public MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId) { return failedMessageSearchService.findById(failedMessageId) .map(this::classifyFailedMessage) .orElseThrow(failedMessageNotFound(failedMessageId)); } MessageClassificationResource(MessageClassificationRepository messageClassificationRepository,
FailedMessageSearchService failedMessageSearchService,
MessageClassificationOutcomeAdapter outcomeAdapter); @Override void addMessageClassifier(MessageClassifier messageClassifier); @Override MessageClassifier listAllMessageClassifiers(); @Override void removeAllMessageClassifiers(); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessageId failedMessageId); @Override MessageClassificationOutcomeResponse classifyFailedMessage(FailedMessage failedMessage); }
|
@Test public void deleteAllMessageClassifiers() { messageClassifiers.add(messageClassifier); underTest.deleteAll(); assertThat(messageClassifiers, contains(messageClassifier, ALWAYS_UNMATCHED)); }
|
@Override public void deleteAll() { messageClassifiers.add(UnmatchedMessageClassifier.ALWAYS_UNMATCHED); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public void deleteAll() { messageClassifiers.add(UnmatchedMessageClassifier.ALWAYS_UNMATCHED); } }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public void deleteAll() { messageClassifiers.add(UnmatchedMessageClassifier.ALWAYS_UNMATCHED); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public void deleteAll() { messageClassifiers.add(UnmatchedMessageClassifier.ALWAYS_UNMATCHED); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); @Override void save(MessageClassifier messageClassifier); @Override MessageClassifier findLatest(); @Override void deleteAll(); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public void deleteAll() { messageClassifiers.add(UnmatchedMessageClassifier.ALWAYS_UNMATCHED); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); @Override void save(MessageClassifier messageClassifier); @Override MessageClassifier findLatest(); @Override void deleteAll(); }
|
@Test public void findLatestMessageClassifiers() { messageClassifiers.add(mock(MessageClassifier.class)); messageClassifiers.add(messageClassifier); final MessageClassifier messageClassifiers = underTest.findLatest(); assertThat(messageClassifiers, is(messageClassifier)); }
|
@Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); @Override void save(MessageClassifier messageClassifier); @Override MessageClassifier findLatest(); @Override void deleteAll(); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); @Override void save(MessageClassifier messageClassifier); @Override MessageClassifier findLatest(); @Override void deleteAll(); }
|
@Test public void findLatestMessageClassifierWhenEmpty() { assertThat(new InMemoryMessageClassificationRepository().findLatest(), nullValue()); }
|
@Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); @Override void save(MessageClassifier messageClassifier); @Override MessageClassifier findLatest(); @Override void deleteAll(); }
|
InMemoryMessageClassificationRepository implements MessageClassificationRepository { @Override public MessageClassifier findLatest() { return messageClassifiers.isEmpty() ? null : messageClassifiers.lastElement(); } InMemoryMessageClassificationRepository(); InMemoryMessageClassificationRepository(Vector<MessageClassifier> messageClassifiers); @Override void save(MessageClassifier messageClassifier); @Override MessageClassifier findLatest(); @Override void deleteAll(); }
|
@Test public void classifyFailedMessagesWhenNoneExist() { when(failedMessageSearchService.findByStatus(FAILED)).thenReturn(Collections.emptyList()); underTest.classifyFailedMessages(); verifyZeroInteractions(messageClassificationRepository); }
|
public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); void classifyFailedMessages(); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); void classifyFailedMessages(); }
|
@Test public void classifyFailedMessagesNotMatched() { when(failedMessageSearchService.findByStatus(FAILED)).thenReturn(singletonList(failedMessage)); when(messageClassificationRepository.findLatest()).thenReturn(messageClassifier); when(messageClassifier.classify(new MessageClassificationContext(failedMessage))).thenReturn(messageClassificationOutcome); when(messageClassificationOutcome.isMatched()).thenReturn(false); underTest.classifyFailedMessages(); verify(messageClassifier).classify(new MessageClassificationContext(failedMessage)); verify(messageClassificationOutcome).getDescription(); verify(messageClassificationOutcome).execute(); }
|
public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); void classifyFailedMessages(); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); void classifyFailedMessages(); }
|
@Test public void removeLabelForAFailedMessageThatDoesNotExist() { underTest.removeLabel(failedMessageId, "bar"); assertThat(collection.count(), is(0L)); }
|
@Override public void removeLabel(FailedMessageId failedMessageId, String label) { collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$pull", new Document(LABELS, label)) ); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void removeLabel(FailedMessageId failedMessageId, String label) { collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$pull", new Document(LABELS, label)) ); } }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void removeLabel(FailedMessageId failedMessageId, String label) { collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$pull", new Document(LABELS, label)) ); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void removeLabel(FailedMessageId failedMessageId, String label) { collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$pull", new Document(LABELS, label)) ); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
FailedMessageMongoDao implements FailedMessageDao { @Override public void removeLabel(FailedMessageId failedMessageId, String label) { collection.updateOne( failedMessageConverter.createId(failedMessageId), new Document("$pull", new Document(LABELS, label)) ); } FailedMessageMongoDao(MongoCollection<Document> collection,
FailedMessageConverter failedMessageConverter,
DocumentConverter<StatusHistoryEvent> failedMessageStatusConverter,
RemoveRecordsQueryFactory removeRecordsQueryFactory); @Override void insert(FailedMessage failedMessage); @Override void update(FailedMessage failedMessage); @Override List<StatusHistoryEvent> getStatusHistory(FailedMessageId failedMessageId); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); @Override long findNumberOfMessagesForBroker(String broker); @Override long removeFailedMessages(); @Override void addLabel(FailedMessageId failedMessageId, String label); @Override void setLabels(FailedMessageId failedMessageId, Set<String> labels); @Override void removeLabel(FailedMessageId failedMessageId, String label); }
|
@Test public void successfullyWriteAResponse() throws Exception { when(httpServletResponse.getWriter()).thenReturn(printWriter); underTest.doGet(httpServletRequest, httpServletResponse); verify(responseWriter).write(printWriter); verifyZeroInteractions(httpServletRequest); }
|
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { try { responseWriter.write(resp.getWriter()); } catch (IOException e) { handleError(resp, e); } }
|
PingServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { try { responseWriter.write(resp.getWriter()); } catch (IOException e) { handleError(resp, e); } } }
|
PingServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { try { responseWriter.write(resp.getWriter()); } catch (IOException e) { handleError(resp, e); } } PingServlet(PingResponseWriter responseWriter); }
|
PingServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { try { responseWriter.write(resp.getWriter()); } catch (IOException e) { handleError(resp, e); } } PingServlet(PingResponseWriter responseWriter); }
|
PingServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { try { responseWriter.write(resp.getWriter()); } catch (IOException e) { handleError(resp, e); } } PingServlet(PingResponseWriter responseWriter); }
|
@Test public void classifyFailedMessagesMatched() { when(failedMessageSearchService.findByStatus(FAILED)).thenReturn(singletonList(failedMessage)); when(messageClassificationRepository.findLatest()).thenReturn(messageClassifier); when(messageClassifier.classify(new MessageClassificationContext(failedMessage))).thenReturn(messageClassificationOutcome); underTest.classifyFailedMessages(); verify(messageClassifier).classify(new MessageClassificationContext(failedMessage)); verify(messageClassificationOutcome).getDescription(); verify(messageClassificationOutcome).execute(); }
|
public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); void classifyFailedMessages(); }
|
MessageClassificationService { public void classifyFailedMessages() { Collection<FailedMessage> failedMessages = failedMessageSearchService.findByStatus(FAILED); if (failedMessages.isEmpty()) { LOGGER.info("No messages require classification"); return; } LOGGER.info("Attempting to classify {} messages", failedMessages.size()); MessageClassifier messageClassifiers = messageClassificationRepository.findLatest(); failedMessages .stream() .map(failedMessage -> messageClassifiers.classify(new MessageClassificationContext(failedMessage))) .peek(outcome -> LOGGER.debug("{}", outcome.getDescription())) .forEach(MessageClassificationOutcome::execute); } MessageClassificationService(FailedMessageSearchService failedMessageSearchService,
MessageClassificationRepository messageClassificationRepository); void classifyFailedMessages(); }
|
@Test public void verifySupplier() { final FailedMessageNotFoundException underTest = FailedMessageNotFoundException.failedMessageNotFound(FAILED_MESSAGE_ID).get(); assertEquals("Failed Message: " + FAILED_MESSAGE_ID + " not found", underTest.getMessage()); assertEquals("Failed Message: " + FAILED_MESSAGE_ID + " not found", underTest.getLocalizedMessage()); assertNull(underTest.getCause()); }
|
public static Supplier<FailedMessageNotFoundException> failedMessageNotFound(FailedMessageId failedMessageId) { return () -> new FailedMessageNotFoundException(failedMessageId); }
|
FailedMessageNotFoundException extends RuntimeException { public static Supplier<FailedMessageNotFoundException> failedMessageNotFound(FailedMessageId failedMessageId) { return () -> new FailedMessageNotFoundException(failedMessageId); } }
|
FailedMessageNotFoundException extends RuntimeException { public static Supplier<FailedMessageNotFoundException> failedMessageNotFound(FailedMessageId failedMessageId) { return () -> new FailedMessageNotFoundException(failedMessageId); } FailedMessageNotFoundException(FailedMessageId failedMessageId); }
|
FailedMessageNotFoundException extends RuntimeException { public static Supplier<FailedMessageNotFoundException> failedMessageNotFound(FailedMessageId failedMessageId) { return () -> new FailedMessageNotFoundException(failedMessageId); } FailedMessageNotFoundException(FailedMessageId failedMessageId); static Supplier<FailedMessageNotFoundException> failedMessageNotFound(FailedMessageId failedMessageId); }
|
FailedMessageNotFoundException extends RuntimeException { public static Supplier<FailedMessageNotFoundException> failedMessageNotFound(FailedMessageId failedMessageId) { return () -> new FailedMessageNotFoundException(failedMessageId); } FailedMessageNotFoundException(FailedMessageId failedMessageId); static Supplier<FailedMessageNotFoundException> failedMessageNotFound(FailedMessageId failedMessageId); }
|
@Test public void createFailedMessageResponseFromAFailedMessage() { FailedMessageResponse failedMessageResponse = underTest.create(newFailedMessage() .withContent("Hello World") .withDestination(new Destination("broker", of("queue"))) .withFailedDateTime(NOW) .withFailedMessageId(FAILED_MESSAGE_ID) .withProperties(Collections.singletonMap("foo", "bar")) .withSentDateTime(NOW) .build() ); assertThat(failedMessageResponse, CoreMatchers.is(aFailedMessage() .withFailedMessageId(equalTo(FAILED_MESSAGE_ID)) .withContent(equalTo("Hello World")) .withBroker(equalTo("broker")) .withDestination(equalTo(of("queue"))) .withFailedAt(equalTo(NOW)) .withProperties(Matchers.hasEntry("foo", "bar")) .withSentAt(equalTo(NOW)))); }
|
public FailedMessageResponse create(FailedMessage failedMessage) { return new FailedMessageResponse( failedMessage.getFailedMessageId(), failedMessage.getDestination().getBrokerName(), failedMessage.getDestination().getName(), failedMessage.getSentAt(), failedMessage.getFailedAt(), failedMessage.getContent(), FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus()), failedMessage.getProperties(), failedMessage.getLabels()); }
|
FailedMessageResponseFactory { public FailedMessageResponse create(FailedMessage failedMessage) { return new FailedMessageResponse( failedMessage.getFailedMessageId(), failedMessage.getDestination().getBrokerName(), failedMessage.getDestination().getName(), failedMessage.getSentAt(), failedMessage.getFailedAt(), failedMessage.getContent(), FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus()), failedMessage.getProperties(), failedMessage.getLabels()); } }
|
FailedMessageResponseFactory { public FailedMessageResponse create(FailedMessage failedMessage) { return new FailedMessageResponse( failedMessage.getFailedMessageId(), failedMessage.getDestination().getBrokerName(), failedMessage.getDestination().getName(), failedMessage.getSentAt(), failedMessage.getFailedAt(), failedMessage.getContent(), FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus()), failedMessage.getProperties(), failedMessage.getLabels()); } }
|
FailedMessageResponseFactory { public FailedMessageResponse create(FailedMessage failedMessage) { return new FailedMessageResponse( failedMessage.getFailedMessageId(), failedMessage.getDestination().getBrokerName(), failedMessage.getDestination().getName(), failedMessage.getSentAt(), failedMessage.getFailedAt(), failedMessage.getContent(), FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus()), failedMessage.getProperties(), failedMessage.getLabels()); } FailedMessageResponse create(FailedMessage failedMessage); }
|
FailedMessageResponseFactory { public FailedMessageResponse create(FailedMessage failedMessage) { return new FailedMessageResponse( failedMessage.getFailedMessageId(), failedMessage.getDestination().getBrokerName(), failedMessage.getDestination().getName(), failedMessage.getSentAt(), failedMessage.getFailedAt(), failedMessage.getContent(), FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus()), failedMessage.getProperties(), failedMessage.getLabels()); } FailedMessageResponse create(FailedMessage failedMessage); }
|
@Test public void statusHistoryEventIsSet() { underTest.adapt(new StatusUpdateRequest(FAILED, NOW), failedMessageBuilder); verify(failedMessageBuilder).withStatusHistoryEvent( argThat(new HamcrestArgumentMatcher<>(StatusHistoryEventMatcher.equalTo(FAILED).withUpdatedDateTime(NOW))) ); }
|
@Override public void adapt(StatusUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withStatusHistoryEvent(new StatusHistoryEvent(updateRequest.getStatus(), updateRequest.getEffectiveDateTime())); }
|
StatusUpdateRequestAdapter implements UpdateRequestAdapter<StatusUpdateRequest> { @Override public void adapt(StatusUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withStatusHistoryEvent(new StatusHistoryEvent(updateRequest.getStatus(), updateRequest.getEffectiveDateTime())); } }
|
StatusUpdateRequestAdapter implements UpdateRequestAdapter<StatusUpdateRequest> { @Override public void adapt(StatusUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withStatusHistoryEvent(new StatusHistoryEvent(updateRequest.getStatus(), updateRequest.getEffectiveDateTime())); } }
|
StatusUpdateRequestAdapter implements UpdateRequestAdapter<StatusUpdateRequest> { @Override public void adapt(StatusUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withStatusHistoryEvent(new StatusHistoryEvent(updateRequest.getStatus(), updateRequest.getEffectiveDateTime())); } @Override void adapt(StatusUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
StatusUpdateRequestAdapter implements UpdateRequestAdapter<StatusUpdateRequest> { @Override public void adapt(StatusUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withStatusHistoryEvent(new StatusHistoryEvent(updateRequest.getStatus(), updateRequest.getEffectiveDateTime())); } @Override void adapt(StatusUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
@Test public void classNameIsLoggedByTheAdapter() { underTest.adapt(new ExampleUpdateRequest(), failedMessageBuilder); verify(logger).warn("UpdateRequestAdapter not found for: {}", ExampleUpdateRequest.class.getName()); }
|
@Override public void adapt(UpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { getLogger().warn("UpdateRequestAdapter not found for: {}", updateRequest.getClass().getName()); }
|
LoggingUpdateRequestAdapter implements UpdateRequestAdapter<UpdateRequest> { @Override public void adapt(UpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { getLogger().warn("UpdateRequestAdapter not found for: {}", updateRequest.getClass().getName()); } }
|
LoggingUpdateRequestAdapter implements UpdateRequestAdapter<UpdateRequest> { @Override public void adapt(UpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { getLogger().warn("UpdateRequestAdapter not found for: {}", updateRequest.getClass().getName()); } }
|
LoggingUpdateRequestAdapter implements UpdateRequestAdapter<UpdateRequest> { @Override public void adapt(UpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { getLogger().warn("UpdateRequestAdapter not found for: {}", updateRequest.getClass().getName()); } @Override void adapt(UpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
LoggingUpdateRequestAdapter implements UpdateRequestAdapter<UpdateRequest> { @Override public void adapt(UpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { getLogger().warn("UpdateRequestAdapter not found for: {}", updateRequest.getClass().getName()); } @Override void adapt(UpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
@Test public void verifyDestinationAdaptedCorrectly() { underTest.adapt(new DestinationUpdateRequest(BROKER_NAME, DESTINATION_NAME), failedMessageBuilder); verify(failedMessageBuilder).withDestination(new Destination(BROKER_NAME, Optional.of(DESTINATION_NAME))); }
|
@Override public void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withDestination(new Destination(updateRequest.getBroker(), Optional.ofNullable(updateRequest.getDestination()))); }
|
DestinationUpdateRequestAdapter implements UpdateRequestAdapter<DestinationUpdateRequest> { @Override public void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withDestination(new Destination(updateRequest.getBroker(), Optional.ofNullable(updateRequest.getDestination()))); } }
|
DestinationUpdateRequestAdapter implements UpdateRequestAdapter<DestinationUpdateRequest> { @Override public void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withDestination(new Destination(updateRequest.getBroker(), Optional.ofNullable(updateRequest.getDestination()))); } }
|
DestinationUpdateRequestAdapter implements UpdateRequestAdapter<DestinationUpdateRequest> { @Override public void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withDestination(new Destination(updateRequest.getBroker(), Optional.ofNullable(updateRequest.getDestination()))); } @Override void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
DestinationUpdateRequestAdapter implements UpdateRequestAdapter<DestinationUpdateRequest> { @Override public void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withDestination(new Destination(updateRequest.getBroker(), Optional.ofNullable(updateRequest.getDestination()))); } @Override void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
@Test public void propertiesAreDeleted() { underTest.adapt(new PropertiesUpdateRequest(Collections.singleton(SOME_KEY), Collections.emptyMap()), failedMessageBuilder); verify(failedMessageBuilder).removeProperty(SOME_KEY); verifyNoMoreInteractions(failedMessageBuilder); }
|
@Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } @Override void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } @Override void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
@Test public void propertiesAreUpdated() { underTest.adapt(new PropertiesUpdateRequest(Collections.emptySet(), Collections.singletonMap(SOME_KEY, SOME_VALUE)), failedMessageBuilder); verify(failedMessageBuilder).withProperty(SOME_KEY, SOME_VALUE); verifyNoMoreInteractions(failedMessageBuilder); }
|
@Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } @Override void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } @Override void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
@Test public void verifyMessageContentAdaptedCorrectly() { underTest.adapt(new ContentUpdateRequest("some-content"), failedMessageBuilder); verify(failedMessageBuilder).withContent("some-content"); }
|
@Override public void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withContent(updateRequest.getContent()); }
|
ContentUpdateRequestAdapter implements UpdateRequestAdapter<ContentUpdateRequest> { @Override public void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withContent(updateRequest.getContent()); } }
|
ContentUpdateRequestAdapter implements UpdateRequestAdapter<ContentUpdateRequest> { @Override public void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withContent(updateRequest.getContent()); } }
|
ContentUpdateRequestAdapter implements UpdateRequestAdapter<ContentUpdateRequest> { @Override public void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withContent(updateRequest.getContent()); } @Override void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
ContentUpdateRequestAdapter implements UpdateRequestAdapter<ContentUpdateRequest> { @Override public void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withContent(updateRequest.getContent()); } @Override void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }
|
@Test public void defaultAdapterIsReturnedWhenAdapterNotFoundForClass() { assertThat(underTest.getAdapter(updateRequest), is(defaultUpdateRequestAdapter)); }
|
@SuppressWarnings("unchecked") public <T extends UpdateRequest> UpdateRequestAdapter<T> getAdapter(T updateRequest) { return updateRequestAdapters.getOrDefault(updateRequest.getClass(), defaultUpdateRequestAdapter); }
|
UpdateRequestAdapterRegistry { @SuppressWarnings("unchecked") public <T extends UpdateRequest> UpdateRequestAdapter<T> getAdapter(T updateRequest) { return updateRequestAdapters.getOrDefault(updateRequest.getClass(), defaultUpdateRequestAdapter); } }
|
UpdateRequestAdapterRegistry { @SuppressWarnings("unchecked") public <T extends UpdateRequest> UpdateRequestAdapter<T> getAdapter(T updateRequest) { return updateRequestAdapters.getOrDefault(updateRequest.getClass(), defaultUpdateRequestAdapter); } UpdateRequestAdapterRegistry(UpdateRequestAdapter<UpdateRequest> defaultUpdateRequestAdapter); }
|
UpdateRequestAdapterRegistry { @SuppressWarnings("unchecked") public <T extends UpdateRequest> UpdateRequestAdapter<T> getAdapter(T updateRequest) { return updateRequestAdapters.getOrDefault(updateRequest.getClass(), defaultUpdateRequestAdapter); } UpdateRequestAdapterRegistry(UpdateRequestAdapter<UpdateRequest> defaultUpdateRequestAdapter); UpdateRequestAdapterRegistry addAdapter(Class<T> clazz, UpdateRequestAdapter<T> adapter); @SuppressWarnings("unchecked") UpdateRequestAdapter<T> getAdapter(T updateRequest); }
|
UpdateRequestAdapterRegistry { @SuppressWarnings("unchecked") public <T extends UpdateRequest> UpdateRequestAdapter<T> getAdapter(T updateRequest) { return updateRequestAdapters.getOrDefault(updateRequest.getClass(), defaultUpdateRequestAdapter); } UpdateRequestAdapterRegistry(UpdateRequestAdapter<UpdateRequest> defaultUpdateRequestAdapter); UpdateRequestAdapterRegistry addAdapter(Class<T> clazz, UpdateRequestAdapter<T> adapter); @SuppressWarnings("unchecked") UpdateRequestAdapter<T> getAdapter(T updateRequest); }
|
@Test public void successfullySendMessage() { when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); underTest.send(failedMessage); verify(messageSender).send(failedMessage); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), is(aStatusUpdateRequest(SENT))); }
|
public void send(FailedMessage failedMessage) { try { messageSender.send(failedMessage); failedMessageService.update(failedMessage.getFailedMessageId(), statusUpdateRequest(SENT)); } catch (Exception e) { LOGGER.error("Could not send FailedMessage: " + failedMessage.getFailedMessageId(), e); } }
|
FailedMessageSender implements MessageSender { public void send(FailedMessage failedMessage) { try { messageSender.send(failedMessage); failedMessageService.update(failedMessage.getFailedMessageId(), statusUpdateRequest(SENT)); } catch (Exception e) { LOGGER.error("Could not send FailedMessage: " + failedMessage.getFailedMessageId(), e); } } }
|
FailedMessageSender implements MessageSender { public void send(FailedMessage failedMessage) { try { messageSender.send(failedMessage); failedMessageService.update(failedMessage.getFailedMessageId(), statusUpdateRequest(SENT)); } catch (Exception e) { LOGGER.error("Could not send FailedMessage: " + failedMessage.getFailedMessageId(), e); } } FailedMessageSender(MessageSender messageSender,
FailedMessageService failedMessageService); }
|
FailedMessageSender implements MessageSender { public void send(FailedMessage failedMessage) { try { messageSender.send(failedMessage); failedMessageService.update(failedMessage.getFailedMessageId(), statusUpdateRequest(SENT)); } catch (Exception e) { LOGGER.error("Could not send FailedMessage: " + failedMessage.getFailedMessageId(), e); } } FailedMessageSender(MessageSender messageSender,
FailedMessageService failedMessageService); void send(FailedMessage failedMessage); }
|
FailedMessageSender implements MessageSender { public void send(FailedMessage failedMessage) { try { messageSender.send(failedMessage); failedMessageService.update(failedMessage.getFailedMessageId(), statusUpdateRequest(SENT)); } catch (Exception e) { LOGGER.error("Could not send FailedMessage: " + failedMessage.getFailedMessageId(), e); } } FailedMessageSender(MessageSender messageSender,
FailedMessageService failedMessageService); void send(FailedMessage failedMessage); }
|
@Test public void searchRequestMatchingAllCriteriaWithAllParametersSpecified() { final Document document = underTest.toQuery(searchMatchingAllCriteria() .withBroker("broker-name") .withDestination("mars") .withStatus(FailedMessageStatus.FAILED) .withStatus(FailedMessageStatus.RESENDING) .withStatus(FailedMessageStatus.SENT) .withContent("id") .withJmsMessageId("ID:localhost.localdomain-46765-1518703251379-5:1:1:1:1") .build() ); assertThat(document, allOf( hasField("statusHistory.0.status", hasField(IN, hasItems("FAILED", "CLASSIFIED", "RESEND", "SENT"))), hasField("$and", containsInAnyOrder( hasField("destination.brokerName", equalTo("broker-name")), hasField("destination.name", equalTo("mars")), hasField("content", allOf(willMatch("user_id"), willMatch("id"), willMatch("hidden"), not(willMatch("find")))), hasField("jmsMessageId", equalTo("ID:localhost.localdomain-46765-1518703251379-5:1:1:1:1")) )))); }
|
public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); Document toQuery(SearchFailedMessageRequest request); }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); Document toQuery(SearchFailedMessageRequest request); }
|
@Test public void searchRequestMatchingAnyCriteriaWithAllParametersSpecified() { final Document document = underTest.toQuery(searchMatchingAnyCriteria() .withBroker("broker-name") .withDestination("mars") .withStatus(FailedMessageStatus.FAILED) .withStatus(FailedMessageStatus.RESENDING) .withStatus(FailedMessageStatus.SENT) .withContent("id") .withJmsMessageId("ID:localhost.localdomain-46765-1518703251379-5:1:1:1:1") .build() ); assertThat(document, allOf( hasField("statusHistory.0.status", hasField(IN, hasItems("FAILED", "CLASSIFIED", "RESEND", "SENT"))), hasField("$or", containsInAnyOrder( hasField("destination.brokerName", equalTo("broker-name")), hasField("destination.name", equalTo("mars")), hasField("content", allOf(willMatch("user_id"), willMatch("id"), willMatch("hidden"), not(willMatch("find")))), hasField("jmsMessageId", equalTo("ID:localhost.localdomain-46765-1518703251379-5:1:1:1:1")) )))); }
|
public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); Document toQuery(SearchFailedMessageRequest request); }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); Document toQuery(SearchFailedMessageRequest request); }
|
@Test public void searchRequestWithoutDestinationAndBrokerAndDefaultStatus() { final Document document = underTest.toQuery(searchMatchingAllCriteria().build()); assertThat(document, Matchers.allOf( hasField("statusHistory.0.status", hasField("$ne", equalTo("DELETED"))) )); }
|
public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); Document toQuery(SearchFailedMessageRequest request); }
|
MongoSearchRequestAdapter { public Document toQuery(SearchFailedMessageRequest request) { Document query; if (!request.getStatuses().isEmpty()) { query = mongoStatusHistoryQueryBuilder.currentStatusIn(fromFailedMessageStatus(request.getStatuses())); } else { query = mongoStatusHistoryQueryBuilder.currentStatusNotEqualTo(DELETED); } List<Document> predicates = new ArrayList<>(); request.getBroker().ifPresent(broker -> predicates.add(new Document(DESTINATION + "." + BROKER_NAME, broker))); request.getDestination().ifPresent(destination -> predicates.add(new Document(DESTINATION + "." + NAME, destination))); request.getContent().ifPresent(content -> predicates.add(new Document(CONTENT, Pattern.compile(content)))); request.getJmsMessageId().ifPresent(jmsMessageId -> predicates.add(new Document(JMS_MESSAGE_ID, jmsMessageId))); if (!predicates.isEmpty()) { query.append(request.getOperator() == AND ? QueryOperators.AND : QueryOperators.OR, predicates); } return query; } MongoSearchRequestAdapter(); Document toQuery(SearchFailedMessageRequest request); }
|
@Test public void search() { failedMessageMongoDao.insert(failedMessageBuilder.build()); when(mongoSearchRequestAdapter.toQuery(request)).thenReturn(new Document()); assertThat(underTest.search(request), contains(aFailedMessage().withFailedMessageId(equalTo(failedMessageId)))); }
|
@Override public Collection<FailedMessage> search(SearchFailedMessageRequest request) { final List<FailedMessage> failedMessages = getFailedMessages(mongoSearchRequestAdapter.toQuery(request)); LOGGER.debug("Found {} failedMessages", failedMessages.size()); return failedMessages; }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> search(SearchFailedMessageRequest request) { final List<FailedMessage> failedMessages = getFailedMessages(mongoSearchRequestAdapter.toQuery(request)); LOGGER.debug("Found {} failedMessages", failedMessages.size()); return failedMessages; } }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> search(SearchFailedMessageRequest request) { final List<FailedMessage> failedMessages = getFailedMessages(mongoSearchRequestAdapter.toQuery(request)); LOGGER.debug("Found {} failedMessages", failedMessages.size()); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> search(SearchFailedMessageRequest request) { final List<FailedMessage> failedMessages = getFailedMessages(mongoSearchRequestAdapter.toQuery(request)); LOGGER.debug("Found {} failedMessages", failedMessages.size()); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); @Override Collection<FailedMessage> search(SearchFailedMessageRequest request); @Override Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> search(SearchFailedMessageRequest request) { final List<FailedMessage> failedMessages = getFailedMessages(mongoSearchRequestAdapter.toQuery(request)); LOGGER.debug("Found {} failedMessages", failedMessages.size()); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); @Override Collection<FailedMessage> search(SearchFailedMessageRequest request); @Override Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); }
|
@Test public void findByStatus() { failedMessageMongoDao.insert(failedMessageBuilder.build()); when(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(FAILED)).thenReturn(new Document()); assertThat(underTest.findByStatus(FAILED), contains(aFailedMessage().withFailedMessageId(equalTo(failedMessageId)))); }
|
@Override public Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status) { final List<FailedMessage> failedMessages = getFailedMessages(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(status)); LOGGER.debug("Found {} failedMessages with status {}", failedMessages.size(), status); return failedMessages; }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status) { final List<FailedMessage> failedMessages = getFailedMessages(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(status)); LOGGER.debug("Found {} failedMessages with status {}", failedMessages.size(), status); return failedMessages; } }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status) { final List<FailedMessage> failedMessages = getFailedMessages(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(status)); LOGGER.debug("Found {} failedMessages with status {}", failedMessages.size(), status); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status) { final List<FailedMessage> failedMessages = getFailedMessages(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(status)); LOGGER.debug("Found {} failedMessages with status {}", failedMessages.size(), status); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); @Override Collection<FailedMessage> search(SearchFailedMessageRequest request); @Override Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); }
|
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status) { final List<FailedMessage> failedMessages = getFailedMessages(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(status)); LOGGER.debug("Found {} failedMessages with status {}", failedMessages.size(), status); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); @Override Collection<FailedMessage> search(SearchFailedMessageRequest request); @Override Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); }
|
@Test public void convertBasicDBbjectToSearchResponse() { when(failedMessageConverter.getDestination(document)).thenReturn(new Destination("broker-name", Optional.of("queue-name"))); when(failedMessageConverter.getStatusHistoryEvent(document)).thenReturn(new StatusHistoryEvent(StatusHistoryEvent.Status.FAILED, NOW)); when(failedMessageConverter.getFailedMessageId(document)).thenReturn(FAILED_MESSAGE_ID); when(failedMessageConverter.getContent(document)).thenReturn("some-content"); SearchFailedMessageResponse response = underTest.toResponse(document); assertThat(response, new TypeSafeMatcher<SearchFailedMessageResponse>() { @Override public void describeTo(Description description) { } @Override protected boolean matchesSafely(SearchFailedMessageResponse response) { return FAILED_MESSAGE_ID.equals(response.getFailedMessageId()) && "some-content".equals(response.getContent()) && NOW.equals(response.getStatusDateTime()) && FailedMessageStatus.FAILED.equals(response.getStatus()) && "broker-name".equals(response.getBroker()) && Optional.of("queue-name").equals(response.getDestination()); } }); }
|
public SearchFailedMessageResponse toResponse(Document document) { final Destination destination = failedMessageConverter.getDestination(document); final StatusHistoryEvent statusHistoryEvent = failedMessageConverter.getStatusHistoryEvent(document); return newSearchFailedMessageResponse() .withFailedMessageId(failedMessageConverter.getFailedMessageId(document)) .withBroker(destination.getBrokerName()) .withDestination(destination.getName().orElse(null)) .withContent(failedMessageConverter.getContent(document)) .withStatus(toFailedMessageStatus(statusHistoryEvent.getStatus())) .withStatusDateTime(statusHistoryEvent.getEffectiveDateTime()) .build(); }
|
MongoSearchResponseAdapter { public SearchFailedMessageResponse toResponse(Document document) { final Destination destination = failedMessageConverter.getDestination(document); final StatusHistoryEvent statusHistoryEvent = failedMessageConverter.getStatusHistoryEvent(document); return newSearchFailedMessageResponse() .withFailedMessageId(failedMessageConverter.getFailedMessageId(document)) .withBroker(destination.getBrokerName()) .withDestination(destination.getName().orElse(null)) .withContent(failedMessageConverter.getContent(document)) .withStatus(toFailedMessageStatus(statusHistoryEvent.getStatus())) .withStatusDateTime(statusHistoryEvent.getEffectiveDateTime()) .build(); } }
|
MongoSearchResponseAdapter { public SearchFailedMessageResponse toResponse(Document document) { final Destination destination = failedMessageConverter.getDestination(document); final StatusHistoryEvent statusHistoryEvent = failedMessageConverter.getStatusHistoryEvent(document); return newSearchFailedMessageResponse() .withFailedMessageId(failedMessageConverter.getFailedMessageId(document)) .withBroker(destination.getBrokerName()) .withDestination(destination.getName().orElse(null)) .withContent(failedMessageConverter.getContent(document)) .withStatus(toFailedMessageStatus(statusHistoryEvent.getStatus())) .withStatusDateTime(statusHistoryEvent.getEffectiveDateTime()) .build(); } MongoSearchResponseAdapter(FailedMessageConverter failedMessageConverter); }
|
MongoSearchResponseAdapter { public SearchFailedMessageResponse toResponse(Document document) { final Destination destination = failedMessageConverter.getDestination(document); final StatusHistoryEvent statusHistoryEvent = failedMessageConverter.getStatusHistoryEvent(document); return newSearchFailedMessageResponse() .withFailedMessageId(failedMessageConverter.getFailedMessageId(document)) .withBroker(destination.getBrokerName()) .withDestination(destination.getName().orElse(null)) .withContent(failedMessageConverter.getContent(document)) .withStatus(toFailedMessageStatus(statusHistoryEvent.getStatus())) .withStatusDateTime(statusHistoryEvent.getEffectiveDateTime()) .build(); } MongoSearchResponseAdapter(FailedMessageConverter failedMessageConverter); SearchFailedMessageResponse toResponse(Document document); }
|
MongoSearchResponseAdapter { public SearchFailedMessageResponse toResponse(Document document) { final Destination destination = failedMessageConverter.getDestination(document); final StatusHistoryEvent statusHistoryEvent = failedMessageConverter.getStatusHistoryEvent(document); return newSearchFailedMessageResponse() .withFailedMessageId(failedMessageConverter.getFailedMessageId(document)) .withBroker(destination.getBrokerName()) .withDestination(destination.getName().orElse(null)) .withContent(failedMessageConverter.getContent(document)) .withStatus(toFailedMessageStatus(statusHistoryEvent.getStatus())) .withStatusDateTime(statusHistoryEvent.getEffectiveDateTime()) .build(); } MongoSearchResponseAdapter(FailedMessageConverter failedMessageConverter); SearchFailedMessageResponse toResponse(Document document); }
|
@Test public void destinationNameIsEmpty() { assertThat(underTest.toResponse(failedMessageBuilder.withDestination(new Destination(BROKER_NAME, Optional.empty())).build()), is(aFailedMessage() .withBroker(equalTo(BROKER_NAME)) .withContent(equalTo(SOME_CONTENT)) .withDestination(equalTo(Optional.empty())) .withStatus(FailedMessageStatus.FAILED) .withStatusDateTime(NOW) .withFailedMessageId(equalTo(FAILED_MESSAGE_ID)) .withJmsMessageId(equalTo(JMS_MESSAGE_ID)) .withLabels(contains("foo")) )); }
|
public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } SearchFailedMessageResponse toResponse(FailedMessage failedMessage); }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } SearchFailedMessageResponse toResponse(FailedMessage failedMessage); }
|
@Test public void destinationNameIsPopulated() { assertThat(underTest.toResponse(failedMessageBuilder.withDestination(new Destination(BROKER_NAME, Optional.of(DESTINATION_NAME))).build()), is(aFailedMessage() .withBroker(equalTo(BROKER_NAME)) .withContent(equalTo(SOME_CONTENT)) .withDestination(equalTo(Optional.of(DESTINATION_NAME))) .withStatus(FailedMessageStatus.FAILED) .withStatusDateTime(NOW) .withFailedMessageId(equalTo(FAILED_MESSAGE_ID)) .withJmsMessageId(equalTo(JMS_MESSAGE_ID)) .withLabels(contains("foo")) )); }
|
public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } SearchFailedMessageResponse toResponse(FailedMessage failedMessage); }
|
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } SearchFailedMessageResponse toResponse(FailedMessage failedMessage); }
|
@Test public void createWhenOriginalDestinationPresent() { ActiveMQMessage message = mock(ActiveMQMessage.class); when(message.getOriginalDestination()).thenReturn(new ActiveMQQueue("queue.name")); Destination destination = underTest.extractDestination(message); assertThat(destination, equalTo(new Destination("internal", Optional.of("queue.name")))); }
|
@Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } ActiveMQDestinationExtractor(String brokerName); }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } ActiveMQDestinationExtractor(String brokerName); @Override Destination extractDestination(ActiveMQMessage message); }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } ActiveMQDestinationExtractor(String brokerName); @Override Destination extractDestination(ActiveMQMessage message); }
|
@Test public void createWhenOriginalDestinationNotPresent() { ActiveMQMessage message = mock(ActiveMQMessage.class); when(message.getOriginalDestination()).thenReturn(null); Destination destination = underTest.extractDestination(message); assertThat(destination, is(aDestination().withBrokerName("internal").withNoName())); }
|
@Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } ActiveMQDestinationExtractor(String brokerName); }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } ActiveMQDestinationExtractor(String brokerName); @Override Destination extractDestination(ActiveMQMessage message); }
|
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } ActiveMQDestinationExtractor(String brokerName); @Override Destination extractDestination(ActiveMQMessage message); }
|
@Test(expected = BadRequestException.class) public void startThrowsABadRequestExceptionIfBrokerIsUnknown() { underTest.start("unknown-broker"); }
|
@ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") public void start( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).start(); }
|
ResendScheduledExecutorsResource { @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") public void start( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).start(); } }
|
ResendScheduledExecutorsResource { @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") public void start( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).start(); } ResendScheduledExecutorsResource(Map<String, ResendScheduledExecutorService> resendScheduledExecutors); }
|
ResendScheduledExecutorsResource { @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") public void start( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).start(); } ResendScheduledExecutorsResource(Map<String, ResendScheduledExecutorService> resendScheduledExecutors); @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") void start(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Synchronously execute the resend job for the given broker") @POST @Path("/execute") void execute(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Pause the resend executor for the given broker") @PUT @Path("/pause") void pause(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); }
|
ResendScheduledExecutorsResource { @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") public void start( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).start(); } ResendScheduledExecutorsResource(Map<String, ResendScheduledExecutorService> resendScheduledExecutors); @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") void start(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Synchronously execute the resend job for the given broker") @POST @Path("/execute") void execute(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Pause the resend executor for the given broker") @PUT @Path("/pause") void pause(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); }
|
@Test public void exceptionIsThrownIfMessageIsNull() throws JMSException { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Message cannot be null"); underTest.createFailedMessage(null); }
|
@Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
@Test public void exceptionIsThrownIfMessageIsNotActiveMQMessage() throws JMSException { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Expected ActiveMQMessage received: " + SomeMessage.class.getName()); underTest.createFailedMessage(new SomeMessage()); }
|
@Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
@Test public void createAFailedMessage() throws JMSException { when(messageTextExtractor.extractText(message)).thenReturn(MESSAGE_CONTENT); when(destinationExtractor.extractDestination(message)).thenReturn(new Destination("broker.name", of("queue.name"))); when(messagePropertyExtractor.extractProperties(message)).thenReturn(emptyMap()); when(message.getJMSMessageID()).thenReturn(JMS_MESSAGE_ID); when(message.getTimestamp()).thenReturn(NOW.minusSeconds(5).toEpochMilli()); when(message.getBrokerInTime()).thenReturn(NOW.toEpochMilli()); FailedMessage failedMessage = underTest.createFailedMessage(message); assertThat(failedMessage, is(aFailedMessage() .withJmsMessageId(equalTo(JMS_MESSAGE_ID)) .withContent(equalTo(MESSAGE_CONTENT)) .withDestination(aDestination().withBrokerName("broker.name").withName("queue.name")) .withSentAt(equalTo(NOW.minusSeconds(5))) .withFailedAt(equalTo(NOW)) .withProperties(equalTo(emptyMap())))); }
|
@Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
@Test public void createAFailedMessageWithFailedMessageIdFromProperty() throws JMSException { final Map<String, Object> messageProperties = singletonMap(FAILED_MESSAGE_ID, FAILED_MESSAGE_ID_VALUE.toString()); when(messageTextExtractor.extractText(message)).thenReturn(MESSAGE_CONTENT); when(destinationExtractor.extractDestination(message)).thenReturn(new Destination("broker.name", of("queue.name"))); when(messagePropertyExtractor.extractProperties(message)).thenReturn(messageProperties); when(message.getJMSMessageID()).thenReturn(JMS_MESSAGE_ID); when(message.getTimestamp()).thenReturn(NOW.minusSeconds(5).toEpochMilli()); when(message.getBrokerInTime()).thenReturn(NOW.toEpochMilli()); FailedMessage failedMessage = underTest.createFailedMessage(message); assertThat(failedMessage, is(aFailedMessage() .withFailedMessageId(equalTo(FAILED_MESSAGE_ID_VALUE)) .withJmsMessageId(equalTo(JMS_MESSAGE_ID)) .withContent(equalTo(MESSAGE_CONTENT)) .withDestination(aDestination().withBrokerName("broker.name").withName("queue.name")) .withSentAt(equalTo(NOW.minusSeconds(5))) .withFailedAt(equalTo(NOW)) .withProperties(equalTo(messageProperties)))); }
|
@Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
ActiveMQFailedMessageFactory implements FailedMessageFactory { @Override public FailedMessage createFailedMessage(Message message) throws JMSException { validateMessageOfCorrectType(message); ActiveMQMessage activeMQMessage = (ActiveMQMessage) message; return FailedMessageBuilder.newFailedMessage() .withJmsMessageId(message.getJMSMessageID()) .withContent(messageTextExtractor.extractText(message)) .withDestination(destinationExtractor.extractDestination(activeMQMessage)) .withSentDateTime(extractTimestamp(activeMQMessage.getTimestamp())) .withFailedDateTime(extractTimestamp(activeMQMessage.getBrokerInTime())) .withProperties(messagePropertyExtractor.extractProperties(message)) .withFailedMessageIdFromPropertyIfPresent() .build(); } ActiveMQFailedMessageFactory(MessageTextExtractor messageTextExtractor,
DestinationExtractor<ActiveMQMessage> destinationExtractor,
MessagePropertyExtractor messagePropertyExtractor); @Override FailedMessage createFailedMessage(Message message); }
|
@Test public void browseDelegatesToJmsTemplate() { underTest.browse(); verify(jmsTemplate).browse("some-queue", browserCallback); }
|
public void browse() { jmsTemplate.browse(queueName, browserCallback); }
|
QueueBrowserService { public void browse() { jmsTemplate.browse(queueName, browserCallback); } }
|
QueueBrowserService { public void browse() { jmsTemplate.browse(queueName, browserCallback); } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); }
|
QueueBrowserService { public void browse() { jmsTemplate.browse(queueName, browserCallback); } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); void browse(); String getBrokerName(); }
|
QueueBrowserService { public void browse() { jmsTemplate.browse(queueName, browserCallback); } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); void browse(); String getBrokerName(); }
|
@Test public void brokerNameIsAvailable() { assertThat(underTest.getBrokerName(), is("some-broker")); }
|
public String getBrokerName() { return brokerName; }
|
QueueBrowserService { public String getBrokerName() { return brokerName; } }
|
QueueBrowserService { public String getBrokerName() { return brokerName; } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); }
|
QueueBrowserService { public String getBrokerName() { return brokerName; } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); void browse(); String getBrokerName(); }
|
QueueBrowserService { public String getBrokerName() { return brokerName; } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); void browse(); String getBrokerName(); }
|
@Test public void noMessagesToBrowse() throws JMSException { when(queueBrowser.getEnumeration()).thenReturn(enumeration); when(enumeration.hasMoreElements()).thenReturn(false); assertThat(underTest.doInJms(session, queueBrowser), is(0L)); verifyZeroInteractions(failedMessageListener); }
|
@Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } QueueBrowserCallback(FailedMessageListener failedMessageListener); }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } QueueBrowserCallback(FailedMessageListener failedMessageListener); @Override Long doInJms(Session session, QueueBrowser browser); }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } QueueBrowserCallback(FailedMessageListener failedMessageListener); @Override Long doInJms(Session session, QueueBrowser browser); }
|
@Test public void messagesToBrowse() throws JMSException { when(queueBrowser.getEnumeration()).thenReturn(enumeration); when(enumeration.hasMoreElements()).thenReturn(true).thenReturn(true).thenReturn(false); when(enumeration.nextElement()).thenReturn(textMessage1).thenReturn(textMessage2); assertThat(underTest.doInJms(session, queueBrowser), is(2L)); verify(failedMessageListener).onMessage(textMessage1); verify(failedMessageListener).onMessage(textMessage2); verifyZeroInteractions(failedMessageListener); }
|
@Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } QueueBrowserCallback(FailedMessageListener failedMessageListener); }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } QueueBrowserCallback(FailedMessageListener failedMessageListener); @Override Long doInJms(Session session, QueueBrowser browser); }
|
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } QueueBrowserCallback(FailedMessageListener failedMessageListener); @Override Long doInJms(Session session, QueueBrowser browser); }
|
@Test public void createQueueBrowserServiceBeanDefinition() { AbstractBeanDefinition abstractBeanDefinition = underTest.create("queueBrowserCallback", "messageSender", BROKER_NAME, QUEUE_NAME); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(QueueBrowserService.class)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(4)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, BrowserCallback.class).getValue(), is(equalTo(new RuntimeBeanReference("queueBrowserCallback")))); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(1, JmsTemplate.class).getValue(), is(equalTo(new RuntimeBeanReference("messageSender")))); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(2, String.class).getValue(), is(BROKER_NAME)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(3, String.class).getValue(), is(QUEUE_NAME)); }
|
public AbstractBeanDefinition create(String queueBrowserCallbackBeanName, String jmsTemplateBeanName, String brokerName, String queueName) { return genericBeanDefinition(QueueBrowserService.class) .addConstructorArgReference(queueBrowserCallbackBeanName) .addConstructorArgReference(jmsTemplateBeanName) .addConstructorArgValue(brokerName) .addConstructorArgValue(queueName) .getBeanDefinition(); }
|
QueueBrowserServiceBeanDefinitionFactory { public AbstractBeanDefinition create(String queueBrowserCallbackBeanName, String jmsTemplateBeanName, String brokerName, String queueName) { return genericBeanDefinition(QueueBrowserService.class) .addConstructorArgReference(queueBrowserCallbackBeanName) .addConstructorArgReference(jmsTemplateBeanName) .addConstructorArgValue(brokerName) .addConstructorArgValue(queueName) .getBeanDefinition(); } }
|
QueueBrowserServiceBeanDefinitionFactory { public AbstractBeanDefinition create(String queueBrowserCallbackBeanName, String jmsTemplateBeanName, String brokerName, String queueName) { return genericBeanDefinition(QueueBrowserService.class) .addConstructorArgReference(queueBrowserCallbackBeanName) .addConstructorArgReference(jmsTemplateBeanName) .addConstructorArgValue(brokerName) .addConstructorArgValue(queueName) .getBeanDefinition(); } }
|
QueueBrowserServiceBeanDefinitionFactory { public AbstractBeanDefinition create(String queueBrowserCallbackBeanName, String jmsTemplateBeanName, String brokerName, String queueName) { return genericBeanDefinition(QueueBrowserService.class) .addConstructorArgReference(queueBrowserCallbackBeanName) .addConstructorArgReference(jmsTemplateBeanName) .addConstructorArgValue(brokerName) .addConstructorArgValue(queueName) .getBeanDefinition(); } AbstractBeanDefinition create(String queueBrowserCallbackBeanName,
String jmsTemplateBeanName,
String brokerName,
String queueName); String createBeanName(String brokerName); }
|
QueueBrowserServiceBeanDefinitionFactory { public AbstractBeanDefinition create(String queueBrowserCallbackBeanName, String jmsTemplateBeanName, String brokerName, String queueName) { return genericBeanDefinition(QueueBrowserService.class) .addConstructorArgReference(queueBrowserCallbackBeanName) .addConstructorArgReference(jmsTemplateBeanName) .addConstructorArgValue(brokerName) .addConstructorArgValue(queueName) .getBeanDefinition(); } AbstractBeanDefinition create(String queueBrowserCallbackBeanName,
String jmsTemplateBeanName,
String brokerName,
String queueName); String createBeanName(String brokerName); }
|
@Test public void createBeanName() { assertThat(underTest.createBeanName(BROKER_NAME), is(equalTo(QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + BROKER_NAME))); }
|
public String createBeanName(String brokerName) { return QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + brokerName; }
|
QueueBrowserServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + brokerName; } }
|
QueueBrowserServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + brokerName; } }
|
QueueBrowserServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String queueBrowserCallbackBeanName,
String jmsTemplateBeanName,
String brokerName,
String queueName); String createBeanName(String brokerName); }
|
QueueBrowserServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String queueBrowserCallbackBeanName,
String jmsTemplateBeanName,
String brokerName,
String queueName); String createBeanName(String brokerName); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.