Add UserRepositoryTest

Author: lakhina

build.sbt

@@ -158,14 +158,14 @@ lazy val transactionImpl = (project in file("transaction-impl"))
     itemImpl,
     testkit % "test"
   ).settings(
-    version := "1.0-SNAPSHOT",
-    libraryDependencies ++= Seq(
-      lagomJavadslPersistenceCassandra,
-      lagomJavadslTestKit,
-      lagomJavadslKafkaBroker,
-      cassandraExtras
-    )
+  version := "1.0-SNAPSHOT",
+  libraryDependencies ++= Seq(
+    lagomJavadslPersistenceCassandra,
+    lagomJavadslTestKit,
+    lagomJavadslKafkaBroker,
+    cassandraExtras
   )
+)
 
 lazy val userApi = (project in file("user-api"))
   .settings(commonSettings: _*)
@@ -181,7 +181,8 @@ lazy val userApi = (project in file("user-api"))
 lazy val userImpl = (project in file("user-impl"))
   .settings(commonSettings: _*)
   .enablePlugins(LagomJava)
-  .dependsOn(userApi, tools)
+  .dependsOn(userApi, tools,
+    testkit % "test")
   .settings(
     version := "1.0-SNAPSHOT",
     libraryDependencies ++= Seq(

user-impl/src/test/java/com/example/auction/user/impl/UserRepositoryTest.java

@@ -0,0 +1,107 @@
+package com.example.auction.user.impl;
+
+import com.example.auction.pagination.PaginatedSequence;
+import com.example.auction.user.api.User;
+import com.example.testkit.Await;
+import com.example.testkit.DoNothingTopicFactory;
+import com.example.testkit.ReadSideTestDriver;
+import com.lightbend.lagom.internal.javadsl.api.broker.TopicFactory;
+import com.lightbend.lagom.javadsl.persistence.Offset;
+import com.lightbend.lagom.javadsl.persistence.ReadSide;
+import com.lightbend.lagom.javadsl.testkit.ServiceTest;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static com.lightbend.lagom.javadsl.testkit.ServiceTest.bind;
+import static com.lightbend.lagom.javadsl.testkit.ServiceTest.defaultSetup;
+import static org.junit.Assert.assertEquals;
+
+public class UserRepositoryTest {
+
+    private final static ServiceTest.Setup setup = defaultSetup().withCassandra(true)
+            .configureBuilder(b ->
+                    // by default, cassandra-query-journal delays propagation of events by 10sec. In test we're using
+                    // a 1 node cluster so this delay is not necessary.
+                    b.configure("cassandra-query-journal.eventual-consistency-delay", "0")
+                            .overrides(bind(ReadSide.class).to(ReadSideTestDriver.class),
+                                    bind(TopicFactory.class).to(DoNothingTopicFactory.class))
+            );
+
+    private static ServiceTest.TestServer testServer;
+
+    @BeforeClass
+    public static void beforeAll() {
+        testServer = ServiceTest.startServer(setup);
+    }
+
+    @AfterClass
+    public static void afterAll() {
+        testServer.stop();
+    }
+
+    private ReadSideTestDriver testDriver = testServer.injector().instanceOf(ReadSideTestDriver.class);
+    private UserRepository UserRepository = testServer.injector().instanceOf(UserRepository.class);
+    private AtomicInteger offset;
+
+    private final UUID userId = UUID.randomUUID();
+    private final String name = "admin";
+    private final String email = "[email protected]";
+    private final String password = PUserCommand.hashPassword("admin");
+
+    private final PUser userCreated = new PUser(userId, name, email, password);
+
+    @Before
+    public void restartOffset() {
+        offset = new AtomicInteger(1);
+    }
+
+    @Test
+    public PaginatedSequence<User> shouldGetUsers() throws InterruptedException, ExecutionException, TimeoutException {
+        return Await.result(UserRepository.getUsers( 0, 10));
+    }
+
+
+    public void shouldCreateUser(UUID userId) throws InterruptedException, ExecutionException, TimeoutException {
+        feed(new PUserEvent.PUserCreated(userCreated));
+        PaginatedSequence<User> users = shouldGetUsers();
+        assertEquals(1, users.getCount());
+        User expected = new User(userId, name, email);
+        assertEquals(expected, users.getItems().get(0));
+    }
+
+
+    @Test
+    public void shouldPaginateUserRetrieval() throws InterruptedException, ExecutionException, TimeoutException {
+        for (int i = 0; i < 25; i++) {
+
+            feed(new PUserEvent.PUserCreated(userCreated));
+        }
+
+
+        PaginatedSequence<User> createdUsers = Await.result(UserRepository.getUsers( 1, 10));
+        assertEquals(25, createdUsers.getCount());
+        assertEquals(10, createdUsers.getItems().size());
+        // default ordering is time DESC so page 2 of size 10 over a set of 25 returns item ids 5-14. On that seq, the fifth item is id=10
+        assertEquals("user10", createdUsers.getItems().get(4).getName());
+
+    }
+
+    private User buildFixture(UUID  id) {
+        return new User(id,name,email);
+    }
+    private void feed(PUserEvent userEvent) throws InterruptedException, ExecutionException, TimeoutException {
+        Await.result(testDriver.feed(userEvent, Offset.sequence(offset.getAndIncrement())));
+    }
+
+   
+
+    }
+
+