@Override public synchronized void accept(F effect) { if (disposed) { return; } actual.accept(effect); }
@Override public synchronized void accept(F effect) { effectConsumer.accept(effect); }
@Override public synchronized void accept(F effect) { effectConsumer.accept(effect); }
@Override public void onUpdateView(M model) { renderer.accept(model); }
@Override public synchronized void accept(F effect) { if (disposed) { return; } actual.accept(effect); }
@Override public void onUpdateView(M model) { renderer.accept(model); }
@Override public void accept(F effect) { try { effectConsumer.accept(effect); } catch (Throwable t) { throw new ConnectionException(effect, t); } } };
@Override public void run() { safeConsumer.accept(1); } });
@Override public void accept(F effect) { try { effectConsumer.accept(effect); } catch (Throwable t) { throw new ConnectionException(effect, t); } } };
@Test public void updaterCanReceiveViewUpdates() throws Exception { @SuppressWarnings("unchecked") Connection<String> renderer = mock(Connection.class); AtomicReference<Consumer<String>> consumer = new AtomicReference<>(); underTest.connect( eventConsumer -> { consumer.set(eventConsumer); return renderer; }); underTest.start(); consumer.get().accept("!"); verify(renderer).accept("init!"); }
@Test public void shouldApplyMappingFunctionToIncoming() throws Exception { mapped.connect(output).accept(98.0); assertThat(mapParameter.get(), is(98.0)); }
@Test public void startsFromDefaultModel() throws Exception { @SuppressWarnings("unchecked") Connection<String> renderer = mock(Connection.class); underTest.connect(eventConsumer -> renderer); underTest.start(); verify(renderer).accept("init"); }
@Test public void eventsWhenNotRunningAreDropped() throws Exception { @SuppressWarnings("unchecked") Connection<String> renderer = mock(Connection.class); AtomicReference<Consumer<String>> consumer = new AtomicReference<>(); underTest.connect( eventConsumer -> { consumer.set(eventConsumer); return renderer; }); consumer.get().accept("!"); underTest.start(); verify(renderer, never()).accept("init!"); } }
@Test public void resumingStartsFromMostRecentModel() throws Exception { @SuppressWarnings("unchecked") Connection<String> renderer = mock(Connection.class); AtomicReference<Consumer<String>> consumer = new AtomicReference<>(); underTest.connect( eventConsumer -> { consumer.set(eventConsumer); return renderer; }); underTest.start(); consumer.get().accept("!"); verify(renderer).accept("init!"); underTest.stop(); reset(renderer); underTest.start(); verify(renderer).accept("init!"); } }
@Test public void shouldPropagateToOutgoing() throws Exception { mapped.connect(output).accept(101.0); assertThat(output.received(), is(singletonList(5))); }
@Test public void restoringStartsFromRestoredModel() throws Exception { @SuppressWarnings("unchecked") Connection<String> renderer = mock(Connection.class); underTest.replaceModel("restored"); underTest.connect(eventConsumer -> renderer); underTest.start(); verify(renderer).accept("restored"); }
@Test public void delegatesEffectsToActualSink() throws Exception { safeConsumer = underTest.connect(recordingConsumer); safeConsumer.accept(1); recordingConsumer.assertValues("Value is: 1"); }
@Test public void discardsEffectsAfterDisposal() throws Exception { // given a disposed sink safeConsumer = underTest.connect(recordingConsumer); safeConsumer.dispose(); // when an effect is performed safeConsumer.accept(1); // then no effects or events happen blockableConnection.assertEffects(); recordingConsumer.assertValues(); }