Adding Test for DbInfoController and SchemaController [resolves #715]

api-rest/src/test/java/com/homihq/db2rest/jdbc/rest/meta/db/DbInfoControllerIntegrationTest.java

@@ -0,0 +1,69 @@
+package com.homihq.db2rest.jdbc.rest.meta.db;
+
+import com.homihq.db2rest.BaseIntegrationTest;
+import com.homihq.db2rest.jdbc.JdbcManager;
+import com.homihq.db2rest.jdbc.config.model.DbColumn;
+import com.homihq.db2rest.jdbc.config.model.DbTable;
+import com.homihq.db2rest.jdbc.rest.meta.schema.SchemaController;
+import com.homihq.db2rest.jdbc.sql.DbMeta;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.homihq.db2rest.jdbc.rest.RdbmsRestApi.VERSION;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.core.AnyOf.anyOf;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
+import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+class DbInfoControllerIntegrationTest extends BaseIntegrationTest {
+
+    Map<String, DbMeta> metadataMap;
+    @MockBean
+    JdbcManager jdbcManager;
+
+    DbInfoController dbInfoController;
+    @BeforeEach
+    void setUp() {
+        List<DbTable> dbTableList = new ArrayList<>();
+        List<DbColumn> dbColumns = new ArrayList<>();
+        dbColumns.add(new DbColumn("tableName","name","alias",
+                "tableAlias",true,"columnDataType",false,false,
+                null,"coverChar","jsonParts"));
+
+        dbTableList.add(new DbTable("schema","name","fullName",
+                "alias",dbColumns,"type","coverChar"));
+
+        metadataMap = new HashMap<>();
+        metadataMap.put("1",new DbMeta("productName",2,"driverName",
+                "driverVersion",dbTableList));
+        dbInfoController = new DbInfoController(jdbcManager);
+        when(jdbcManager.getDbMetaMap()).thenReturn(metadataMap);
+    }
+
+    @Test
+    void getObjects() throws Exception {
+        mockMvc.perform(get(VERSION + "/$dbs")
+                        .contentType(APPLICATION_JSON).accept(APPLICATION_JSON))
+                .andDo(print())
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$").isArray())
+                .andExpect(jsonPath("$[0].dbId").value("1"))  // Validate dbId field of the first object
+                .andExpect(jsonPath("$[0].productName").value("productName"))  // Validate productName field
+                .andExpect(jsonPath("$[0].majorVersion").value(2))  // Validate majorVersion field
+                .andExpect(jsonPath("$[0].driverName").value("driverName"))  // Validate driverName field
+                .andExpect(jsonPath("$[0].driverVersion").value("driverVersion"));
+    }
+}

api-rest/src/test/java/com/homihq/db2rest/jdbc/rest/meta/db/DbInfoControllerTest.java

@@ -0,0 +1,52 @@
+package com.homihq.db2rest.jdbc.rest.meta.db;
+
+import com.homihq.db2rest.jdbc.JdbcManager;
+import com.homihq.db2rest.jdbc.config.model.DbColumn;
+import com.homihq.db2rest.jdbc.config.model.DbTable;
+import com.homihq.db2rest.jdbc.sql.DbMeta;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.when;
+
+class DbInfoControllerTest {
+
+    Map<String, DbMeta> metadataMap;
+    @BeforeEach
+    void setUp() {
+        List<DbTable> dbTableList = new ArrayList<>();
+        List<DbColumn> dbColumns = new ArrayList<>();
+        dbColumns.add(new DbColumn("tableName","name","alias",
+                "tableAlias",true,"columnDataType",false,false,
+                null,"coverChar","jsonParts"));
+
+        dbTableList.add(new DbTable("schema","name","fullName",
+                "alias",dbColumns,"type","coverChar"));
+
+        metadataMap = new HashMap<>();
+        metadataMap.put("key",new DbMeta("productName",2,"driverName",
+                "driverVersion",dbTableList));
+    }
+
+    @Test
+    void testGetObjects() {
+
+        JdbcManager jdbcManagerMock = Mockito.mock(JdbcManager.class);
+        when(jdbcManagerMock.getDbMetaMap()).thenReturn(metadataMap);
+        DbInfoController dbInfoController = new DbInfoController(jdbcManagerMock);
+        List<DbInfoObject> actualDbInfoList = dbInfoController.getObjects();
+        List<DbInfoObject> expectedDbInfoList = new ArrayList<>();
+        metadataMap.forEach(
+                (k,v) -> expectedDbInfoList.add(new DbInfoObject(k, v.productName(), v.majorVersion(), v.driverName(), v.driverVersion()))
+        );
+
+        assertEquals(expectedDbInfoList, actualDbInfoList);
+    }
+}

api-rest/src/test/java/com/homihq/db2rest/jdbc/rest/meta/schema/SchemaControllerIntegrationTest.java

@@ -0,0 +1,134 @@
+package com.homihq.db2rest.jdbc.rest.meta.schema;
+
+import com.homihq.db2rest.BaseIntegrationTest;
+import com.homihq.db2rest.jdbc.JdbcManager;
+import com.homihq.db2rest.jdbc.config.model.DbColumn;
+import com.homihq.db2rest.jdbc.config.model.DbTable;
+import com.homihq.db2rest.jdbc.sql.DbMeta;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.homihq.db2rest.jdbc.rest.RdbmsRestApi.VERSION;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.core.AnyOf.anyOf;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
+import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+class SchemaControllerIntegrationTest extends BaseIntegrationTest {
+
+    Map<String, DbMeta> metadataMap;
+    @MockBean
+    JdbcManager jdbcManager;
+    SchemaController schemaController;
+
+    @BeforeEach
+    void setUp() {
+        List<DbTable> dbTableList = new ArrayList<>();
+        List<DbColumn> dbColumns = new ArrayList<>();
+        dbColumns.add(new DbColumn("tableName","name","alias",
+                "tableAlias",true,"columnDataType",false,false,
+                null,"coverChar","jsonParts"));
+
+        dbTableList.add(new DbTable("schema","name","fullName",
+                "alias",dbColumns,"type","coverChar"));
+
+        metadataMap = new HashMap<>();
+        metadataMap.put("key",new DbMeta("productName",2,"driverName",
+                "driverVersion",dbTableList));
+        schemaController = new SchemaController(jdbcManager);
+        when(jdbcManager.getDbMetaByDbId(anyString())).thenReturn(metadataMap.get("key"));
+    }
+
+    /**
+     * This test tests the use case where we request for all schemas without
+     * providing any filter.
+     * @throws Exception
+     */
+    @Test
+    void testGetObjects() throws Exception {
+        mockMvc.perform(get(VERSION + "/1/$schemas")
+                        .contentType(APPLICATION_JSON).accept(APPLICATION_JSON))
+                .andDo(print())
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.*").isArray())
+                //.andExpect(jsonPath("$.*", hasSize(4)))
+                .andExpect(jsonPath("$.*", anyOf(hasSize(1))))
+                .andExpect(jsonPath("$[0].*", hasSize(3)))
+                .andDo(document("schema-no-filter"));
+    }
+
+    /**
+     * This test tests the use case where we are sending an invalid filter
+     * i.e, we are sending a filter which is not valid.
+     * @throws Exception
+     */
+    @Test
+    void testGetObjectsInvalidFilter() throws Exception {
+        mockMvc.perform(get(VERSION + "/1/$schemas")
+                        .param("filter","name=employee")
+                        .contentType(APPLICATION_JSON).accept(APPLICATION_JSON))
+                .andDo(print())
+                .andExpect(jsonPath("$.type").value("https://db2rest.com/error/generic-error"))
+                .andExpect(jsonPath("$.title").value("Generic Data Access Error"))
+                .andExpect(jsonPath("$.status").value(400))
+                .andExpect(jsonPath("$.detail").value("Invalid filter condition. Only == supported for schema filter using a single value only."))
+                .andExpect(jsonPath("$.instance").value("/v1/rdbms/1/$schemas"))
+                .andExpect(jsonPath("$.errorCategory").value("Data-access-error"))
+                .andExpect(jsonPath("$.timestamp").exists())
+                .andDo(document("schema-invalid-filter"));
+    }
+
+    /**
+     * Tests response if there is a filter, and it is a valid filter.
+     * Valid filters include
+     * 1. == sign in between filter field and filter value
+     * 2. A string to the left of == and a string value to the right of it.
+     * @throws Exception
+     */
+    @Test
+    void testGetObjectsValidFilter()  throws Exception {
+        mockMvc.perform(get("/v1/rdbms/1/$schemas")
+                        .param("filter", "schema==schema")
+                        .contentType("application/json"))
+                .andExpect(status().isOk())  // Expect 200 OK
+                .andExpect(jsonPath("$").isArray())  // Ensure it's an array
+                .andExpect(jsonPath("$[0].schema").value("schema"))  // Validate the first object's schema field
+                .andExpect(jsonPath("$[0].name").value("name"))  // Validate the name field
+                .andExpect(jsonPath("$[0].type").value("type"))
+                .andDo(document("schema-valid-filter"));
+    }
+
+    /**
+     * This test checks for the use case where we send a request to /$schemas,
+     * but we do not have a valid filter field.
+     * NOTE: In this use case, the filter in itself is valid because it contains ==.
+     *  Currently, we have filters based on schema, type and name.
+     * This test checks the response and ensures it is empty if the filter argument
+     * is not in (schema,type, name)
+     * @throws Exception
+     */
+    @Test
+    void testGetObjectsInvalidFilterField()  throws Exception {
+        mockMvc.perform(get("/v1/rdbms/1/$schemas")
+                        .param("filter", "someUnknownFilter==schema")
+                        .contentType("application/json"))
+                .andExpect(status().isOk())  // Expect 200 OK
+                .andExpect(jsonPath("$").isArray())  // Ensure it's an array
+                .andExpect(jsonPath("$").isEmpty()) //Ensure it is empty
+                .andDo(document("schema-unknown-filter"));
+    }
+}

api-rest/src/test/java/com/homihq/db2rest/jdbc/rest/meta/schema/SchemaControllerTest.java

@@ -0,0 +1,100 @@
+package com.homihq.db2rest.jdbc.rest.meta.schema;
+
+import com.homihq.db2rest.core.exception.GenericDataAccessException;
+import com.homihq.db2rest.jdbc.JdbcManager;
+import com.homihq.db2rest.jdbc.config.model.DbColumn;
+import com.homihq.db2rest.jdbc.config.model.DbTable;
+import com.homihq.db2rest.jdbc.sql.DbMeta;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.when;
+
+class SchemaControllerTest {
+    Map<String, DbMeta> metadataMap;
+    JdbcManager jdbcManager;
+    SchemaController schemaController;
+    @BeforeEach
+    void setUp() {
+        List<DbTable> dbTableList = new ArrayList<>();
+        List<DbColumn> dbColumns = new ArrayList<>();
+        dbColumns.add(new DbColumn("tableName","name","alias",
+                "tableAlias",true,"columnDataType",false,false,
+                null,"coverChar","jsonParts"));
+
+        dbTableList.add(new DbTable("schema","name","fullName",
+                "alias",dbColumns,"type","coverChar"));
+
+        metadataMap = new HashMap<>();
+        metadataMap.put("key",new DbMeta("productName",2,"driverName",
+                "driverVersion",dbTableList));
+        jdbcManager = Mockito.mock(JdbcManager.class);
+        schemaController = new SchemaController(jdbcManager);
+    }
+
+    @Test
+    void getObjectsNoFilter() {
+        when(jdbcManager.getDbMetaByDbId("key")).thenReturn(metadataMap.get("key"));
+        List<TableObject> actualTableObject = schemaController.getObjects("key",null);
+        List<TableObject> expectedTableObject = metadataMap.get("key").dbTables().stream().map(t-> new TableObject(t.schema(),t.name(),t.type())).toList();
+        schemaController.getObjects("key",null);
+        assertEquals(expectedTableObject,actualTableObject);
+    }
+    @Test
+    void testGetObjectsFilterInvalid() {
+        when(jdbcManager.getDbMetaByDbId("key")).thenReturn(metadataMap.get("key"));
+        Throwable exception = assertThrows(GenericDataAccessException.class,() -> schemaController.getObjects("key","invalidFilter"));
+        assertEquals("Invalid filter condition. Only == supported for schema filter using a single value only.",exception.getMessage());
+    }
+    @Test
+    void testGetObjectsValidFilter_schema(){
+        when(jdbcManager.getDbMetaByDbId("key")).thenReturn(metadataMap.get("key"));
+        List<TableObject> expectedTableObject = metadataMap.get("key").dbTables().stream().map(t-> new TableObject(t.schema(),t.name(),t.type())).toList();
+        List<TableObject> actualTableObject = schemaController.getObjects("key","schema==schema");
+        assertEquals(expectedTableObject,actualTableObject);
+
+        actualTableObject = schemaController.getObjects("key","schema==notPresentInList");
+        assertEquals(0,actualTableObject.size());
+    }
+
+    @Test
+    void testGetObjectsValidFilter_name() {
+        when(jdbcManager.getDbMetaByDbId("key")).thenReturn(metadataMap.get("key"));
+        List<TableObject> expectedTableObject = metadataMap.get("key").dbTables().stream().map(t-> new TableObject(t.schema(),t.name(),t.type())).toList();
+        List<TableObject> actualTableObject = schemaController.getObjects("key","name==name");
+        assertEquals(expectedTableObject,actualTableObject);
+
+        actualTableObject = schemaController.getObjects("key","name==notPresentInList");
+        assertEquals(0,actualTableObject.size());
+    }
+    @Test
+    void testGetObjectsValidFilter_type() {
+        when(jdbcManager.getDbMetaByDbId("key")).thenReturn(metadataMap.get("key"));
+        List<TableObject> expectedTableObject = metadataMap.get("key").dbTables().stream().map(t-> new TableObject(t.schema(),t.name(),t.type())).toList();
+        List<TableObject> actualTableObject = schemaController.getObjects("key","type==type");
+        assertEquals(expectedTableObject,actualTableObject);
+
+        actualTableObject = schemaController.getObjects("key","type==notPresentInList");
+        assertEquals(0,actualTableObject.size());
+    }
+    @Test
+    void testGetObjectsValidFilter_invalidFieldFilter() {
+        when(jdbcManager.getDbMetaByDbId("key")).thenReturn(metadataMap.get("key"));
+        List<TableObject> actualTableObject;
+        actualTableObject = schemaController.getObjects("key","invalidFilterField==notPresentInList");
+        assertEquals(0,actualTableObject.size());
+    }
+    @Test
+    void testGetObjectsDbIDInvalid(){
+        when(jdbcManager.getDbMetaByDbId("key")).thenReturn(null);
+        assertEquals(0,schemaController.getObjects("key","filter").size());
+
+    }
+}