Update AbstractMongoBackend

Change method visibility to public for extensibility
Add tests to cover synchronous and asynchronous method call

Author: justinchuch

core/src/main/java/de/bwaldvogel/mongo/backend/AbstractMongoBackend.java

@@ -50,7 +50,7 @@ public abstract class AbstractMongoBackend implements MongoBackend {
 
     protected static final String OPLOG_COLLECTION_NAME = "oplog.rs";
 
-    private static final String ADMIN_DB_NAME = "admin";
+    protected static final String ADMIN_DB_NAME = "admin";
 
     private final Map<String, MongoDatabase> databases = new ConcurrentHashMap<>();
 
@@ -148,7 +148,7 @@ private Document getLog(String argument) {
         return response;
     }
 
-    private Document handleAdminCommand(String command, Document query) {
+    protected Document handleAdminCommand(String command, Document query) {
         if (command.equalsIgnoreCase("listdatabases")) {
             List<Document> databases = listDatabaseNames().stream()
                 .sorted()
@@ -296,8 +296,7 @@ private MongoCollection<?> resolveCollection(final String namespace) {
 
     protected abstract MongoDatabase openOrCreateDatabase(String databaseName);
 
-    @Override
-    public Document handleCommand(Channel channel, String databaseName, String command, Document query) {
+    protected Document handleCommandSync(Channel channel, String databaseName, String command, Document query) {
         if (command.equalsIgnoreCase("whatsmyuri")) {
             Document response = new Document();
             InetSocketAddress remoteAddress = (InetSocketAddress) channel.remoteAddress();
@@ -327,13 +326,21 @@ public Document handleCommand(Channel channel, String databaseName, String comma
         } else if (command.equalsIgnoreCase("killCursors")) {
             return handleKillCursors(query);
         }
+        return null;
+    }
+
+    @Override
+    public Document handleCommand(Channel channel, String databaseName, String command, Document query) {
+        Document commandResponse = handleCommandSync(channel, databaseName, command, query);
+        if (commandResponse != null) {
+            return commandResponse;
+        }
 
         if (databaseName.equals(ADMIN_DB_NAME)) {
             return handleAdminCommand(command, query);
-        } else {
-            MongoDatabase db = resolveDatabase(databaseName);
-            return db.handleCommand(channel, command, query, oplog);
         }
+
+        return resolveDatabase(databaseName).handleCommand(channel, command, query, oplog);
     }
 
     @Override

core/src/test/java/de/bwaldvogel/mongo/backend/AbstractMongoBackendTest.java

@@ -1,21 +1,28 @@
 package de.bwaldvogel.mongo.backend;
 
+import static de.bwaldvogel.mongo.backend.AbstractMongoBackend.ADMIN_DB_NAME;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
 
+import java.net.InetSocketAddress;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.CompletionStage;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
 
 import de.bwaldvogel.mongo.MongoBackend;
 import de.bwaldvogel.mongo.MongoDatabase;
 import de.bwaldvogel.mongo.bson.Document;
 import de.bwaldvogel.mongo.exception.CursorNotFoundException;
 import de.bwaldvogel.mongo.wire.message.MongoGetMore;
 import de.bwaldvogel.mongo.wire.message.MongoKillCursors;
+import io.netty.channel.Channel;
 
 class AbstractMongoBackendTest {
 
@@ -32,7 +39,15 @@ public void setup() {
 
             @Override
             protected MongoDatabase openOrCreateDatabase(String databaseName) {
-                return null;
+                MongoDatabase mockDatabase = Mockito.mock(AbstractMongoDatabase.class);
+
+                Document fakeResponse = new Document();
+                Utils.markOkay(fakeResponse);
+                fakeResponse.put("message", "fakeResponse");
+
+                when(mockDatabase.handleCommand(any(), any(), any(), any())).thenReturn(fakeResponse);
+
+                return mockDatabase;
             }
         };
     }
@@ -73,4 +88,66 @@ void testHandleKillCursor() {
         assertThat(cursorRegistry.getCursor(cursor2.getId())).isNotNull();
     }
 
+    @Test
+    void testHandleCommandSync() {
+        Channel channel = Mockito.mock(Channel.class);
+        when(channel.remoteAddress()).thenReturn(new InetSocketAddress("127.0.1.254", 27017));
+
+        Document response = backend.handleCommand(channel, null, "whatsmyuri", null);
+        assertThat(response).isNotNull();
+        assertThat(response.get("ok")).isEqualTo(1.0);
+        assertThat(response.get("you")).isEqualTo("127.0.1.254:27017");
+    }
+
+    @Test
+    void testHandleCommandAsync() throws Exception {
+        Channel channel = Mockito.mock(Channel.class);
+        when(channel.remoteAddress()).thenReturn(new InetSocketAddress("127.0.1.254", 27017));
+
+        CompletionStage<Document> responseFuture = backend.handleCommandAsync(channel, null, "whatsmyuri", null);
+        Document response = responseFuture.toCompletableFuture().get();
+        assertThat(response).isNotNull();
+        assertThat(response.get("ok")).isEqualTo(1.0);
+        assertThat(response.get("you")).isEqualTo("127.0.1.254:27017");
+    }
+
+    @Test
+    void testHandleAdminCommand() {
+        Channel channel = Mockito.mock(Channel.class);
+
+        Document response = backend.handleCommand(channel, ADMIN_DB_NAME, "ping", null);
+        assertThat(response).isNotNull();
+        assertThat(response.get("ok")).isEqualTo(1.0);
+    }
+
+    @Test
+    void testHandleAdminCommandAsync() throws Exception {
+        Channel channel = Mockito.mock(Channel.class);
+
+        CompletionStage<Document> responseFuture = backend.handleCommandAsync(channel, ADMIN_DB_NAME, "ping", null);
+        Document response = responseFuture.toCompletableFuture().get();
+        assertThat(response).isNotNull();
+        assertThat(response.get("ok")).isEqualTo(1.0);
+    }
+
+    @Test
+    void testMongoDatabaseHandleCommand() {
+        Channel channel = Mockito.mock(Channel.class);
+
+        Document response = backend.handleCommand(channel, "mockDatabase", "find", null);
+        assertThat(response).isNotNull();
+        assertThat(response.get("ok")).isEqualTo(1.0);
+        assertThat(response.get("message")).isEqualTo("fakeResponse");
+    }
+
+    @Test
+    void testMongoDatabaseHandleCommandAsync() throws Exception {
+        Channel channel = Mockito.mock(Channel.class);
+
+        CompletionStage<Document> responseFuture = backend.handleCommandAsync(channel, "mockDatabase", "find", null);
+        Document response = responseFuture.toCompletableFuture().get();
+        assertThat(response).isNotNull();
+        assertThat(response.get("ok")).isEqualTo(1.0);
+        assertThat(response.get("message")).isEqualTo("fakeResponse");
+    }
 }