Fix incorrect test parallelWritesWithoutTransaction.

storio-sqlite/src/test/java/com/pushtorefresh/storio2/sqlite/integration/BaseTest.java

@@ -14,6 +14,8 @@
 import com.pushtorefresh.storio2.sqlite.operations.put.PutResults;
 
 import org.junit.Before;
+import org.junit.Rule;
+import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
@@ -30,6 +32,9 @@
 @Config(constants = BuildConfig.class, sdk = 21)
 public abstract class BaseTest {
 
+    @Rule
+    public Timeout timeout = Timeout.seconds(30);
+
     @NonNull
     protected StorIOSQLite storIOSQLite;
 

storio-sqlite/src/test/java/com/pushtorefresh/storio2/sqlite/integration/NotifyAboutChangesTest.java

@@ -6,7 +6,10 @@
 import com.pushtorefresh.storio2.sqlite.BuildConfig;
 import com.pushtorefresh.storio2.sqlite.Changes;
 import com.pushtorefresh.storio2.sqlite.StorIOSQLite;
+import com.pushtorefresh.storio2.test.Repeat;
+import com.pushtorefresh.storio2.test.RepeatRule;
 
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
@@ -28,6 +31,9 @@
 @Config(constants = BuildConfig.class, sdk = 21)
 public class NotifyAboutChangesTest extends BaseTest {
 
+    @Rule
+    public RepeatRule repeat = new RepeatRule();
+
     @Test
     public void notifyAboutChange() {
         TestSubscriber<Changes> testObserver = new TestSubscriber<Changes>();
@@ -197,11 +203,12 @@ public void run() {
     }
 
     @Test
+    @Repeat(times = 20)
     public void shouldReceiveOneNotificationWithAllAffectedTablesInTransactionWithMultipleThreads() throws InterruptedException {
         final String table1 = "test_table1";
         final String table2 = "test_table2";
 
-        final int numberOfThreads = 100;
+        final int numberOfThreads = 50;
 
         final TestSubscriber<Changes> testSubscriber = new TestSubscriber<Changes>();
 
@@ -239,14 +246,15 @@ public void run() {
         // Steady!
         startAllThreadsLock.countDown(); // Go!
 
-        assertThat(allThreadsFinishedLock.await(20, SECONDS)).isTrue();
+        assertThat(allThreadsFinishedLock.await(25, SECONDS)).isTrue();
 
         // While we in transaction, no changes should be sent.
         assertThat(testSubscriber.getOnNextEvents()).hasSize(0);
 
         lowLevel.endTransaction();
 
         testSubscriber.assertNoErrors();
+
         List<Changes> actualChanges = testSubscriber.getOnNextEvents();
         assertThat(actualChanges).hasSize(1);
         assertThat(actualChanges.get(0).affectedTables()).containsOnly("test_table1", "test_table2");
@@ -298,4 +306,4 @@ public void run() {
         testSubscriber.assertNoErrors();
         testSubscriber.assertNoValues();
     }
-}
+}

storio-sqlite/src/test/java/com/pushtorefresh/storio2/sqlite/integration/RxQueryTest.java

@@ -6,7 +6,10 @@
 import com.pushtorefresh.storio2.sqlite.Changes;
 import com.pushtorefresh.storio2.sqlite.queries.Query;
 import com.pushtorefresh.storio2.test.AbstractEmissionChecker;
+import com.pushtorefresh.storio2.test.Repeat;
+import com.pushtorefresh.storio2.test.RepeatRule;
 
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
@@ -55,6 +58,9 @@ public void call(List<User> users) {
         }
     }
 
+    @Rule
+    public RepeatRule repeat = new RepeatRule();
+
     @Test
     public void insertEmission() {
         final List<User> initialUsers = putUsersBlocking(10);
@@ -151,19 +157,20 @@ public void deleteEmission() {
     }
 
     @Test
-    public void parallelWritesWithoutTransaction() {
-        final int numberOfParallelWorkers = 50;
+    @Repeat(times = 20)
+    public void parallelPutWithoutGlobalTransaction() {
+        final int numberOfParallelPuts = 50;
 
         TestSubscriber<Changes> testSubscriber = new TestSubscriber<Changes>();
 
         storIOSQLite
                 .observeChangesInTable(TweetTableMeta.TABLE)
-                .take(numberOfParallelWorkers)
+                .take(numberOfParallelPuts)
                 .subscribe(testSubscriber);
 
         final CountDownLatch countDownLatch = new CountDownLatch(1);
 
-        for (int i = 0; i < numberOfParallelWorkers; i++) {
+        for (int i = 0; i < numberOfParallelPuts; i++) {
             final int copyOfCurrentI = i;
             new Thread(new Runnable() {
                 @Override
@@ -188,7 +195,15 @@ public void run() {
 
         testSubscriber.awaitTerminalEvent();
         testSubscriber.assertNoErrors();
-        assertThat(testSubscriber.getOnNextEvents()).hasSize(numberOfParallelWorkers);
+
+        // Put operation creates short-term transaction which might result in merge of some notifications.
+        // So we have two extreme cases:
+        // - no merged notifications → isEqualTo(numberOfParallelPuts)
+        // - all notifications merged → isEqualTo(1)
+        // Obviously truth is somewhere between those (depends on CPU of machine that runs test).
+        assertThat(testSubscriber.getOnNextEvents().size())
+                .isLessThanOrEqualTo(numberOfParallelPuts)
+                .isGreaterThanOrEqualTo(1);
     }
 
     @Test

storio-test-common/build.gradle

@@ -23,6 +23,7 @@ dependencies {
     provided libraries.supportAnnotations
     provided libraries.rxJava
 
+    compile libraries.junit
     compile libraries.mockitoCore
 
     testCompile libraries.junit

storio-test-common/src/main/java/com/pushtorefresh/storio2/test/Repeat.java

@@ -0,0 +1,13 @@
+package com.pushtorefresh.storio2.test;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(RUNTIME)
+@Target(METHOD)
+public @interface Repeat {
+    int times();
+}

storio-test-common/src/main/java/com/pushtorefresh/storio2/test/RepeatRule.java

@@ -0,0 +1,36 @@
+package com.pushtorefresh.storio2.test;
+
+import android.support.annotation.NonNull;
+
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+public class RepeatRule implements TestRule {
+
+    @Override
+    @NonNull
+    public Statement apply(@NonNull final Statement test, @NonNull final Description description) {
+        final Repeat repeat = description.getAnnotation(Repeat.class);
+
+        if (repeat != null) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    final int times = repeat.times();
+
+                    if (times < 1) {
+                        throw new IllegalArgumentException("Repeat times should be >= 1, times = " + times);
+                    }
+
+                    for (int i = 0; i < times; i++) {
+                        System.out.println(description.getMethodName() + " iteration " + (i + 1));
+                        test.evaluate();
+                    }
+                }
+            };
+        } else {
+            return test;
+        }
+    }
+}

storio-test-common/src/test/java/com/pushtorefresh/storio2/test/RepeatRuleTest.java

@@ -0,0 +1,71 @@
+package com.pushtorefresh.storio2.test;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class RepeatRuleTest {
+
+    private Statement test = mock(Statement.class);
+    private Description description = mock(Description.class);
+    private Repeat repeat = mock(Repeat.class);
+
+    @Test
+    public void repeats10Times() throws Throwable {
+        when(description.getAnnotation(Repeat.class)).thenReturn(repeat);
+        when(repeat.times()).thenReturn(10);
+
+        new RepeatRule().apply(test, description).evaluate();
+
+        verify(test, times(10)).evaluate();
+    }
+
+    @Test
+    public void noAnnotation() throws Throwable {
+        when(description.getAnnotation(Repeat.class)).thenReturn(null);
+
+        new RepeatRule().apply(test, description).evaluate();
+
+        verify(test).evaluate();
+    }
+
+    @Test
+    public void lessThan1Time() throws Throwable {
+        when(description.getAnnotation(Repeat.class)).thenReturn(repeat);
+        when(repeat.times()).thenReturn(0);
+
+        try {
+            new RepeatRule().apply(test, description).evaluate();
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertThat(expected).hasMessage("Repeat times should be >= 1, times = 0");
+        }
+    }
+
+    @Test
+    public void lazyWithoutAnnotation() throws Throwable {
+        when(description.getAnnotation(Repeat.class)).thenReturn(null);
+
+        new RepeatRule().apply(test, description);
+
+        verify(test, never()).evaluate();
+    }
+
+    @Test
+    public void lazyWithAnnotation() throws Throwable {
+        when(description.getAnnotation(Repeat.class)).thenReturn(repeat);
+        when(repeat.times()).thenReturn(10);
+
+        new RepeatRule().apply(test, description);
+
+        verify(test, never()).evaluate();
+    }
+}