@Test(expectedExceptions = AssertionError.class) public void assert_success_getFailure() { Result<String> test = Result.success("success"); assertThat(test).isFailure(); }
public void assert_failure() { Result<String> test = Result.failure(new IllegalArgumentException("failure")); assertThat(test) .isFailure(ERROR) .hasFailureMessageMatching("failure"); }
public void success_flatMap_throwing() { Result<String> success = Result.success("success"); Result<Integer> test = success.flatMap(r -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertThat(test) .isFailure(ERROR) .hasFailureMessageMatching("Big bad error"); }
/** * Assert that the {@code Result} is a failure with the specified message. * * @param regex the regex that the failure message is expected to match * @return this, if the wrapped object is a failure with the specified message * @throws AssertionError if the wrapped object is a success, or does not have the expected message */ public ResultAssert hasFailureMessageMatching(String regex) { isFailure(); String message = actual.getFailure().getMessage(); if (!message.matches(regex)) { failWithMessage("Expected Failure with message matching: <%s> but was Failure with message: <%s>", regex, message); } return this; }
public void success_map_throwing() { Result<String> success = Result.success("success"); Result<Integer> test = success.map(r -> { throw new IllegalArgumentException("Big bad error"); }); assertEquals(test.isSuccess(), false); assertThat(test) .isFailure(ERROR) .hasFailureMessageMatching("Big bad error"); }
public void assert_success_combineWith_failure() { Result<String> success = Result.success("Hello"); Result<String> failure = Result.failure(new IllegalArgumentException()); Result<String> test = success.combineWith(failure, FUNCTION_MERGE); assertThat(test).isFailure(ERROR); assertThat(test.getFailure().getItems().size()).isEqualTo(1); }
public void success_combineWith_success_throws() { Result<String> success1 = Result.success("Hello"); Result<String> success2 = Result.success("World"); Result<String> test = success1.combineWith(success2, (s1, s2) -> { throw new IllegalArgumentException("Ooops"); }); assertThat(test) .isFailure() .hasFailureMessageMatching("Ooops"); }
/** * Assert that the {@code Result} is a failure with the specified reason. * * @param expected the expected failure reason * @return this, if the wrapped object is a failure with the specified reason * @throws AssertionError if the wrapped object is a success, or does not have the expected reason */ public ResultAssert isFailure(FailureReason expected) { isFailure(); FailureReason actualReason = actual.getFailure().getReason(); if (actualReason != expected) { failWithMessage("Expected Failure with reason: <%s> but was Failure with reason: <%s>", expected, actualReason); } return this; }
public void flatCombine_iterableWithSuccesses_combineThrows() { Result<Integer> success1 = Result.success(1); Result<Integer> success2 = Result.success(2); Result<Integer> success3 = Result.success(3); Result<Integer> success4 = Result.success(4); Set<Result<Integer>> results = ImmutableSet.of(success1, success2, success3, success4); Result<String> combined = Result.flatCombine( results, s -> { throw new IllegalArgumentException("Ooops"); }); assertThat(combined) .isFailure(ERROR) .hasFailureMessageMatching("Ooops"); }
public void flatCombine_iterableWithFailures() { Result<String> success1 = Result.success("success 1"); Result<String> success2 = Result.success("success 2"); Result<String> failure1 = Result.failure(MISSING_DATA, "failure 1"); Result<String> failure2 = Result.failure(ERROR, "failure 2"); Set<Result<String>> results = ImmutableSet.of(success1, success2, failure1, failure2); assertThat(Result.flatCombine(results, Result::success)) .isFailure(FailureReason.MULTIPLE); }
public void combine_iterableWithFailures() { Result<String> success1 = Result.success("success 1"); Result<String> success2 = Result.success("success 2"); Result<String> failure1 = Result.failure(MISSING_DATA, "failure 1"); Result<String> failure2 = Result.failure(ERROR, "failure 2"); Set<Result<String>> results = ImmutableSet.of(success1, success2, failure1, failure2); assertThat(Result.combine(results, s -> s)) .isFailure(FailureReason.MULTIPLE); }
public void combine_iterableWithSuccesses_throws() { Result<Integer> success1 = Result.success(1); Result<Integer> success2 = Result.success(2); Result<Integer> success3 = Result.success(3); Result<Integer> success4 = Result.success(4); Set<Result<Integer>> results = ImmutableSet.of(success1, success2, success3, success4); Result<String> combined = Result.combine( results, s -> { throw new IllegalArgumentException("Ooops"); }); assertThat(combined) .isFailure(ERROR) .hasFailureMessageMatching("Ooops"); }
public void flatCombine_iterableWithSuccesses_combineFails() { Result<Integer> success1 = Result.success(1); Result<Integer> success2 = Result.success(2); Result<Integer> success3 = Result.success(3); Result<Integer> success4 = Result.success(4); Set<Result<Integer>> results = ImmutableSet.of(success1, success2, success3, success4); Result<String> combined = Result.flatCombine( results, s -> Result.failure(CALCULATION_FAILED, "Could not do it")); assertThat(combined) .isFailure(CALCULATION_FAILED); }
public void evaluate() { PositionTokenEvaluator evaluator = new PositionTokenEvaluator(); Position pos = trade(); EvaluationResult quantity = evaluator.evaluate(pos, FUNCTIONS, "quantity", ImmutableList.of()); assertThat(quantity.getResult()).hasValue(6d); EvaluationResult initialPrice = evaluator.evaluate(pos, FUNCTIONS, "security", ImmutableList.of()); assertThat(initialPrice.getResult()).hasValue(SECURITY); // Check that property name isn't case sensitive EvaluationResult initialPrice2 = evaluator.evaluate(pos, FUNCTIONS, "Security", ImmutableList.of()); assertThat(initialPrice2.getResult()).hasValue(SECURITY); // Unknown property EvaluationResult foo = evaluator.evaluate(pos, FUNCTIONS, "foo", ImmutableList.of()); assertThat(foo.getResult()).isFailure(); }
public void evaluate() { SecurityTokenEvaluator evaluator = new SecurityTokenEvaluator(); Security sec = security(); EvaluationResult quantity = evaluator.evaluate(sec, FUNCTIONS, "id", ImmutableList.of()); assertThat(quantity.getResult()).hasValue(ID); EvaluationResult initialPrice = evaluator.evaluate(sec, FUNCTIONS, "currency", ImmutableList.of()); assertThat(initialPrice.getResult()).hasValue(USD); // Check that property name isn't case sensitive EvaluationResult initialPrice2 = evaluator.evaluate(sec, FUNCTIONS, "Currency", ImmutableList.of()); assertThat(initialPrice2.getResult()).hasValue(USD); // Unknown property EvaluationResult foo = evaluator.evaluate(sec, FUNCTIONS, "foo", ImmutableList.of()); assertThat(foo.getResult()).isFailure(); }
public void evaluate() { TradeTokenEvaluator evaluator = new TradeTokenEvaluator(); Trade trade = trade(); EvaluationResult quantity = evaluator.evaluate(trade, FUNCTIONS, "quantity", ImmutableList.of()); assertThat(quantity.getResult()).hasValue(123d); EvaluationResult initialPrice = evaluator.evaluate(trade, FUNCTIONS, "price", ImmutableList.of()); assertThat(initialPrice.getResult()).hasValue(456d); // Check that property name isn't case sensitive EvaluationResult initialPrice2 = evaluator.evaluate(trade, FUNCTIONS, "price", ImmutableList.of()); assertThat(initialPrice2.getResult()).hasValue(456d); EvaluationResult counterparty = evaluator.evaluate(trade, FUNCTIONS, "counterparty", ImmutableList.of()); assertThat(counterparty.getResult()).hasValue(StandardId.of("cpty", "a")); // Optional property with no value EvaluationResult tradeTime = evaluator.evaluate(trade, FUNCTIONS, "tradeTime", ImmutableList.of()); assertThat(tradeTime.getResult()).isFailure(); // Unknown property EvaluationResult foo = evaluator.evaluate(trade, FUNCTIONS, "foo", ImmutableList.of()); assertThat(foo.getResult()).isFailure(); }
assertThat(result4.getResult()).isFailure();