@SuppressWarnings("unused") private Next<?, Number> canInferFromVarargOnlyEffects() { return dispatch(effects((short) 1, 2, (long) 3)); }
@SuppressWarnings("unused") private Next<?, Number> canInferFromVarargOnlyEffectsSingle() { return dispatch(effects((short) 1)); }
@Nonnull @Override public Next<M, F> handleInnerEffects(M model, boolean modelUpdated, Set<FI> innerEffects) { if (innerEffects.isEmpty()) { return modelUpdated ? Next.<M, F>next(model) : Next.<M, F>noChange(); } Set<F> effects = new HashSet<>(); for (FI innerEffect : innerEffects) { F outerEffect = checkNotNull(f).apply(innerEffect); effects.add(checkNotNull(outerEffect)); } if (modelUpdated) { return Next.next(model, effects); } else { return Next.dispatch(effects); } } };
@Test public void testHasEffectsWithConcreteInstancesOutOfOrder() throws Exception { next = dispatch(effects(94, 74, 65)); matcher = hasEffects(65, 94, 74); assertTrue(matcher.matches(next)); } }
@Test public void testHasEffectsWithConcreteInstancesPartialMatch() throws Exception { next = dispatch(effects(94, 74)); matcher = hasEffects(94); assertTrue(matcher.matches(next)); }
@Test public void testHasEffectsWithConcreteInstancesMismatch() throws Exception { next = dispatch(effects(94)); matcher = hasEffects(74); assertFalse(matcher.matches(next)); }
@Test public void testHasEffectsWithConcreteInstancesMatch() throws Exception { next = dispatch(effects(94)); matcher = hasEffects(94); assertTrue(matcher.matches(next)); }
@Test public void testHasNoModel() throws Exception { next = dispatch(effects(1, 2)); matcher = hasNoModel(); assertTrue(matcher.matches(next)); matcher.describeMismatch(next, desc); assertEquals("no model", desc.toString()); }
@Test public void testHasNoEffectsMismatch() throws Exception { next = dispatch(effects(1, 2, 3)); matcher = hasNoEffects(); assertFalse(matcher.matches(next)); matcher.describeMismatch(next, desc); assertEquals("has effects", desc.toString()); }
@Test public void testHasEffectsSpecific() throws Exception { next = dispatch(effects(1, 3, 2)); matcher = hasEffects(hasItems(1, 2, 3)); assertTrue(matcher.matches(next)); matcher.describeMismatch(next, desc); assertEquals("has effects: ", desc.toString()); }
@Test public void testHasEffectsSpecificButWrong() throws Exception { next = dispatch(effects(1)); matcher = hasEffects(hasItems(2)); assertFalse(matcher.matches(next)); matcher.describeMismatch(next, desc); assertEquals("bad effects: a collection containing <2> was <1>", desc.toString()); }
@Test public void testHasNothing() throws Exception { matcher = hasNothing(); assertFalse(matcher.matches(null)); assertFalse(matcher.matches(next("1234"))); assertFalse(matcher.matches(dispatch(effects("f1")))); assertFalse(matcher.matches(next("123", effects("f1")))); assertTrue(matcher.matches(noChange())); }
@Test public void nextEffectsOnlyHasEffects() throws Exception { Next<String, String> next = dispatch(effects("foo")); assertFalse(next.hasModel()); assertTrue(next.hasEffects()); }
@Test public void canMergeInnerEffects() throws Exception { Next<String, String> outerNext = Next.next("m", effects("f1", "f2")); Next<?, String> innerNext = dispatch(effects("f2", "f3")); Next<String, String> merged = Next.next( outerNext.modelOrElse("fail"), unionSets(innerNext.effects(), outerNext.effects())); assertEquals(Next.next("m", effects("f1", "f2", "f3")), merged); }
@Test public void dispatchEffectCallsInnerEffectHandler() throws Exception { InnerUpdate<String, String, String, String, String, String> innerUpdate = InnerUpdate.<String, String, String, String, String, String>builder() .modelExtractor(m -> m) .eventExtractor(e -> e) .innerUpdate((model, event) -> dispatch(effects("1", "2", "3"))) .modelUpdater((m, mi) -> mi) .innerEffectHandler((model, updated, effects) -> Next.next("effect_handler")) .build(); Next<String, String> next = innerUpdate.update("model", "event"); assertThat(next, NextMatchers.<String, String>hasModel("effect_handler")); }