From 39d90a0a19b43a092429f0f76aa6f36598621835 Mon Sep 17 00:00:00 2001 From: dirong Date: Mon, 14 Mar 2016 11:03:14 +0200 Subject: [PATCH 1/2] Junit tests for janet core module. Also: 1. Add unsubscribe from observable when receives final statuses 2. Renaming --- janet/build.gradle | 6 +- .../java/io/techery/janet/ActionPipe.java | 2 +- .../src/main/java/io/techery/janet/Janet.java | 8 +- .../test/java/io/techery/janet/JanetTest.java | 199 ++++++++++++++++++ 4 files changed, 211 insertions(+), 4 deletions(-) create mode 100644 janet/src/test/java/io/techery/janet/JanetTest.java diff --git a/janet/build.gradle b/janet/build.gradle index cfc4cc7..40569a5 100644 --- a/janet/build.gradle +++ b/janet/build.gradle @@ -1,5 +1,4 @@ apply plugin: 'java' -apply plugin: 'provided-base' apply plugin: 'maven' sourceCompatibility = 1.6 @@ -21,5 +20,8 @@ artifacts { } dependencies { - provided 'io.reactivex:rxjava:+' + compile 'io.reactivex:rxjava:1.1.1' + + testCompile 'junit:junit:4.12' + testCompile 'org.mockito:mockito-core:1.10.19' } diff --git a/janet/src/main/java/io/techery/janet/ActionPipe.java b/janet/src/main/java/io/techery/janet/ActionPipe.java index 9c7fb1c..0ad1dfb 100644 --- a/janet/src/main/java/io/techery/janet/ActionPipe.java +++ b/janet/src/main/java/io/techery/janet/ActionPipe.java @@ -160,7 +160,7 @@ public Observable> createObservable(final A action) { * * @param action prepared action to send */ - public Observable createActionObservable(A action) { + public Observable createObservableSuccess(A action) { return createObservable(action).compose(new ActionStateToActionTransformer()); } diff --git a/janet/src/main/java/io/techery/janet/Janet.java b/janet/src/main/java/io/techery/janet/Janet.java index 2ec2119..84b1418 100644 --- a/janet/src/main/java/io/techery/janet/Janet.java +++ b/janet/src/main/java/io/techery/janet/Janet.java @@ -118,7 +118,13 @@ private Observable> send(final A action) { @Override public void call() { doSend(action); } - })); + })) + .takeUntil(new Func1() { + @Override public Boolean call(ActionState actionState) { + return actionState.status == ActionState.Status.SUCCESS + || actionState.status == ActionState.Status.FAIL; + } + }); } private void doSend(A action) { diff --git a/janet/src/test/java/io/techery/janet/JanetTest.java b/janet/src/test/java/io/techery/janet/JanetTest.java new file mode 100644 index 0000000..aa7d615 --- /dev/null +++ b/janet/src/test/java/io/techery/janet/JanetTest.java @@ -0,0 +1,199 @@ +package io.techery.janet; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; +import java.util.List; + +import io.techery.janet.helper.ActionStateSubscriber; +import rx.functions.Action0; +import rx.observers.TestSubscriber; + +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +public class JanetTest { + + + private Janet janet; + private ActionService service; + private ActionPipe actionPipe; + + @Before + public void setup() throws JanetException { + service = spy(ActionService.class); + when(service.getSupportedAnnotationType()).thenReturn(MockAction.class); + doAnswer(new SuccessAnswer(service)).when(service).sendInternal(any(ActionHolder.class)); + janet = new Janet.Builder().addService(service).build(); + actionPipe = janet.createPipe(TestAction.class); + } + + @Test + public void testCreateObservable() { + TestSubscriber> subscriber = new TestSubscriber>(); + actionPipe.createObservable(new TestAction()).subscribe(subscriber); + assertSubscriberWithStates(subscriber); + } + + @Test + public void testSendWithObserve() { + TestSubscriber> subscriber = new TestSubscriber>(); + actionPipe.observe().subscribe(subscriber); + actionPipe.send(new TestAction()); + subscriber.unsubscribe(); + assertSubscriberWithStates(subscriber); + } + + @Test + public void testSendWithObserveWithReplay() { + TestSubscriber> subscriber = new TestSubscriber>(); + actionPipe.observeWithReplay() + .subscribe(subscriber); + actionPipe.send(new TestAction()); + subscriber.unsubscribe(); + assertSubscriberWithStates(subscriber); + + subscriber = new TestSubscriber>(); + actionPipe.observeWithReplay().subscribe(subscriber); + subscriber.unsubscribe(); + assertSubscriberWithSingleValue(subscriber); + } + + @Test + public void testCreateObservableSuccess() { + TestSubscriber subscriber = new TestSubscriber(); + TestAction action = new TestAction(); + actionPipe.createObservableSuccess(action).subscribe(subscriber); + subscriber.unsubscribe(); + assertSubscriberWithSingleValue(subscriber); + subscriber.assertValue(action); + } + + @Test + public void testSendWithObserveSuccess() { + TestSubscriber subscriber = new TestSubscriber(); + TestAction action = new TestAction(); + actionPipe.observeSuccess().subscribe(subscriber); + actionPipe.send(action); + subscriber.unsubscribe(); + assertSubscriberWithSingleValue(subscriber); + subscriber.assertValue(action); + } + + @Test + public void testSendWithObserveSuccessWithReplay() { + TestSubscriber subscriber = new TestSubscriber(); + TestAction action = new TestAction(); + actionPipe.observeSuccessWithReplay() + .subscribe(subscriber); + actionPipe.send(action); + subscriber.unsubscribe(); + assertSubscriberWithSingleValue(subscriber); + subscriber.assertValue(action); + + subscriber = new TestSubscriber(); + actionPipe.observeSuccessWithReplay() + .subscribe(subscriber); + subscriber.unsubscribe(); + assertSubscriberWithSingleValue(subscriber); + subscriber.assertValue(action); + } + + @Test + public void testCancel() { + final TestAction action = new TestAction(); + TestSubscriber> subscriber = new TestSubscriber>( + new ActionStateSubscriber() + .onStart(new Action0() { + @Override public void call() { + actionPipe.cancel(action); + } + })); + actionPipe.createObservable(action).subscribe(subscriber); + subscriber.unsubscribe(); + assertSubscriberWithSingleValue(subscriber); + } + + @Test + public void testClearReplays() { + actionPipe.send(new TestAction()); + actionPipe.clearReplays(); + TestSubscriber> subscriber = new TestSubscriber>(); + actionPipe.observeWithReplay().subscribe(subscriber); + subscriber.unsubscribe(); + subscriber.assertNoErrors(); + subscriber.assertNoValues(); + subscriber.assertUnsubscribed(); + } + + @Test + public void testStatusFail() throws JanetException { + TestSubscriber> subscriber = new TestSubscriber>(); + doThrow(JanetException.class).when(service).sendInternal(any(ActionHolder.class)); + actionPipe.createObservable(new TestAction()).subscribe(subscriber); + subscriber.unsubscribe(); + assertSubscriberWithSingleValue(subscriber); + assertStatusCount(subscriber.getOnNextEvents(), ActionState.Status.FAIL, 1); + } + + + private static void assertSubscriberWithStates(TestSubscriber> subscriber) { + subscriber.assertNoErrors(); + subscriber.assertValueCount(4); + subscriber.assertUnsubscribed(); + List> values = subscriber.getOnNextEvents(); + assertStatusCount(values, ActionState.Status.START, 1); + assertStatusCount(values, ActionState.Status.PROGRESS, 2); + assertStatusCount(values, ActionState.Status.SUCCESS, 1); + } + + private static void assertSubscriberWithSingleValue(TestSubscriber subscriber) { + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertUnsubscribed(); + } + + private static void assertStatusCount(List> values, ActionState.Status status, int count) { + int i = 0; + for (ActionState state : values) { + if (status == state.status) { + i++; + } + } + if (i != count) { + throw new AssertionError("Number of events with status " + status + " differ; expected: " + count + ", actual: " + i); + } + } + + @MockAction + private static class TestAction {} + + @Target(TYPE) + @Retention(RUNTIME) + private @interface MockAction {} + + private static class SuccessAnswer implements Answer { + + private final ActionService service; + + private SuccessAnswer(ActionService service) {this.service = service;} + + @Override public Void answer(InvocationOnMock invocation) throws Throwable { + ActionHolder holder = (ActionHolder) invocation.getArguments()[0]; + service.callback.onStart(holder); + service.callback.onProgress(holder, 1); + service.callback.onProgress(holder, 99); + service.callback.onSuccess(holder); + return null; + } + } +} From 632062cba6fba7ce55a65a57c18372118865c663 Mon Sep 17 00:00:00 2001 From: dirong Date: Mon, 14 Mar 2016 11:27:08 +0200 Subject: [PATCH 2/2] Remove prefix `test` from junit4 methods --- .../test/java/io/techery/janet/JanetTest.java | 21 +++++++++---------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/janet/src/test/java/io/techery/janet/JanetTest.java b/janet/src/test/java/io/techery/janet/JanetTest.java index aa7d615..22f6a69 100644 --- a/janet/src/test/java/io/techery/janet/JanetTest.java +++ b/janet/src/test/java/io/techery/janet/JanetTest.java @@ -38,14 +38,14 @@ public void setup() throws JanetException { } @Test - public void testCreateObservable() { + public void createObservable() { TestSubscriber> subscriber = new TestSubscriber>(); actionPipe.createObservable(new TestAction()).subscribe(subscriber); assertSubscriberWithStates(subscriber); } @Test - public void testSendWithObserve() { + public void sendWithObserve() { TestSubscriber> subscriber = new TestSubscriber>(); actionPipe.observe().subscribe(subscriber); actionPipe.send(new TestAction()); @@ -54,7 +54,7 @@ public void testSendWithObserve() { } @Test - public void testSendWithObserveWithReplay() { + public void sendWithObserveWithReplay() { TestSubscriber> subscriber = new TestSubscriber>(); actionPipe.observeWithReplay() .subscribe(subscriber); @@ -69,7 +69,7 @@ public void testSendWithObserveWithReplay() { } @Test - public void testCreateObservableSuccess() { + public void createObservableSuccess() { TestSubscriber subscriber = new TestSubscriber(); TestAction action = new TestAction(); actionPipe.createObservableSuccess(action).subscribe(subscriber); @@ -79,7 +79,7 @@ public void testCreateObservableSuccess() { } @Test - public void testSendWithObserveSuccess() { + public void sendWithObserveSuccess() { TestSubscriber subscriber = new TestSubscriber(); TestAction action = new TestAction(); actionPipe.observeSuccess().subscribe(subscriber); @@ -90,11 +90,10 @@ public void testSendWithObserveSuccess() { } @Test - public void testSendWithObserveSuccessWithReplay() { + public void sendWithObserveSuccessWithReplay() { TestSubscriber subscriber = new TestSubscriber(); TestAction action = new TestAction(); - actionPipe.observeSuccessWithReplay() - .subscribe(subscriber); + actionPipe.observeSuccessWithReplay().subscribe(subscriber); actionPipe.send(action); subscriber.unsubscribe(); assertSubscriberWithSingleValue(subscriber); @@ -109,7 +108,7 @@ public void testSendWithObserveSuccessWithReplay() { } @Test - public void testCancel() { + public void cancelAfterSend() { final TestAction action = new TestAction(); TestSubscriber> subscriber = new TestSubscriber>( new ActionStateSubscriber() @@ -124,7 +123,7 @@ public void testCancel() { } @Test - public void testClearReplays() { + public void clearReplays() { actionPipe.send(new TestAction()); actionPipe.clearReplays(); TestSubscriber> subscriber = new TestSubscriber>(); @@ -136,7 +135,7 @@ public void testClearReplays() { } @Test - public void testStatusFail() throws JanetException { + public void statusFail() throws JanetException { TestSubscriber> subscriber = new TestSubscriber>(); doThrow(JanetException.class).when(service).sendInternal(any(ActionHolder.class)); actionPipe.createObservable(new TestAction()).subscribe(subscriber);