Merge pull request #9 from ktnr/master

Added simple test to add and delete users.

Author: lganzzzo

.gitignore

@@ -41,3 +41,4 @@ cmake-build-debug/
 
 # sqlite
 **/*.sqlite
+/.vs

CMakeLists.txt

@@ -51,8 +51,10 @@ add_definitions(
         ## define path to swagger-ui static resources folder
         -DOATPP_SWAGGER_RES_PATH="${oatpp-swagger_INCLUDE_DIRS}/../bin/oatpp-swagger/res"
 
-        ## SQLite databse file
+        ## SQLite database file
         -DDATABASE_FILE="${CMAKE_CURRENT_SOURCE_DIR}/db.sqlite"
+        ## SQLite database test file
+        -DTESTDATABASE_FILE="${CMAKE_CURRENT_SOURCE_DIR}/test-db.sqlite"
 
         ## Path to database migration scripts
         -DDATABASE_MIGRATIONS="${CMAKE_CURRENT_SOURCE_DIR}/sql"
@@ -70,7 +72,11 @@ target_link_libraries(crud-exe crud-lib)
 
 add_executable(crud-test
         test/tests.cpp
-)
+        test/app/DatabaseTestClient.hpp 
+        test/app/TestDatabaseComponent.hpp
+        test/app/TestComponent.hpp 
+        test/DatabaseTest.hpp 
+        test/DatabaseTest.cpp)
 target_link_libraries(crud-test crud-lib)
 
 enable_testing()

src/controller/UserController.hpp

@@ -15,7 +15,7 @@
  */
 class UserController : public oatpp::web::server::api::ApiController {
 public:
-  UserController(const std::shared_ptr<ObjectMapper>& objectMapper)
+  UserController(OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
     : oatpp::web::server::api::ApiController(objectMapper)
   {}
 private:

test/DatabaseTest.cpp

@@ -0,0 +1,71 @@
+#include "DatabaseTest.hpp"
+
+#include "oatpp/web/client/HttpRequestExecutor.hpp"
+#include "oatpp-test/web/ClientServerTestRunner.hpp"
+
+#include "controller/UserController.hpp"
+
+#include "app/DatabaseTestClient.hpp"
+#include "app/TestComponent.hpp"
+
+void DatabaseTest::onRun() {
+    /* Register test components */
+    TestComponent component;
+
+    /* Create client-server test runner */
+    oatpp::test::web::ClientServerTestRunner runner;
+
+    /* Add UserController endpoints to the router of the test server */
+    runner.addController(std::make_shared<UserController>());
+
+    /* Run test */
+    runner.run([this, &runner] {
+
+        /* Get client connection provider for Api Client */
+        OATPP_COMPONENT(std::shared_ptr<oatpp::network::ClientConnectionProvider>, clientConnectionProvider);
+
+        /* Get object mapper component */
+        OATPP_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, objectMapper);
+
+        /* Create http request executor for Api Client */
+        auto requestExecutor = oatpp::web::client::HttpRequestExecutor::createShared(clientConnectionProvider);
+
+        /* Create Test API client */
+        auto client = DatabaseTestClient::createShared(requestExecutor, objectMapper);
+
+        auto dto = UserDto::createShared();
+
+        dto->userName = "jondoe";
+        dto->email = "[email protected]";
+        dto->password = "1234";
+
+        /* Call server API */
+        auto addedUserResponse = client->addUser(dto);
+
+        /* Assert that server responds with 200 */
+        OATPP_ASSERT(addedUserResponse->getStatusCode() == 200);
+
+        /* Read response body as MessageDto */
+        auto addedUserDto = addedUserResponse->readBodyToDto<oatpp::Object<UserDto>>(objectMapper.get());
+
+        int addedUserId = addedUserDto->id;
+
+        /* Assert that user has been added */
+        auto newUserResponse = client->getUser(addedUserId);
+
+        OATPP_ASSERT(newUserResponse->getStatusCode() == 200);
+
+        auto newUserDto = newUserResponse->readBodyToDto<oatpp::Object<UserDto>>(objectMapper.get());
+
+        OATPP_ASSERT(newUserDto->id == addedUserId);
+
+        /* Delete newly added users */
+        auto deletedUserResponse = client->deleteUser(addedUserId);
+
+        OATPP_ASSERT(deletedUserResponse->getStatusCode() == 200);
+
+        }, std::chrono::minutes(10) /* test timeout */);
+
+    /* wait all server threads finished */
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+}

test/DatabaseTest.hpp

@@ -0,0 +1,14 @@
+#ifndef DatabaseTest_hpp
+#define DatabaseTest_hpp
+
+#include "oatpp-test/UnitTest.hpp"
+
+class DatabaseTest : public oatpp::test::UnitTest {
+public:
+    DatabaseTest() : oatpp::test::UnitTest("TEST[DatabaseTest]")
+    {}
+
+    void onRun() override;
+};
+
+#endif // DatabaseTest_hpp

test/app/DatabaseTestClient.hpp

@@ -0,0 +1,31 @@
+#ifndef DatabaseTestClient_hpp
+#define DatabaseTestClient_hpp
+
+#include "oatpp/web/client/ApiClient.hpp"
+#include "oatpp/core/macro/codegen.hpp"
+
+#include "../../src/dto/UserDto.hpp"
+
+/* Begin Api Client code generation */
+#include OATPP_CODEGEN_BEGIN(ApiClient)
+
+/**
+ * Test API client.
+ * Use this client to call application APIs.
+ */
+class DatabaseTestClient : public oatpp::web::client::ApiClient {
+
+    API_CLIENT_INIT(DatabaseTestClient)
+
+    API_CALL("POST", "/users", addUser, BODY_DTO(Object<UserDto>, userDto))
+    API_CALL("GET", "/users/{userId}", getUser, PATH(Int32, userId))
+    API_CALL("DELETE", "/users/{userId}", deleteUser, PATH(Int32, userId))
+
+    // TODO - add more client API calls here
+
+};
+
+/* End Api Client code generation */
+#include OATPP_CODEGEN_END(ApiClient)
+
+#endif // DatabaseTestClient_hpp

test/app/TestComponent.hpp

@@ -0,0 +1,72 @@
+#ifndef TestComponent_hpp
+#define TestComponent_hpp
+
+#include "oatpp/web/server/HttpConnectionHandler.hpp"
+
+#include "oatpp/network/virtual_/client/ConnectionProvider.hpp"
+#include "oatpp/network/virtual_/server/ConnectionProvider.hpp"
+#include "oatpp/network/virtual_/Interface.hpp"
+
+#include "oatpp/parser/json/mapping/ObjectMapper.hpp"
+
+#include "oatpp/core/macro/component.hpp"
+
+#include "TestDatabaseComponent.hpp"
+
+/**
+ * Test Components config
+ */
+class TestComponent {
+public:
+
+    TestDatabaseComponent databaseComponent;
+
+    /**
+     * Create oatpp virtual network interface for test networking
+     */
+    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::virtual_::Interface>, virtualInterface)([] {
+        return oatpp::network::virtual_::Interface::obtainShared("virtualhost");
+        }());
+
+    /**
+     * Create server ConnectionProvider of oatpp virtual connections for test
+     */
+    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ServerConnectionProvider>, serverConnectionProvider)([] {
+        OATPP_COMPONENT(std::shared_ptr<oatpp::network::virtual_::Interface>, interface);
+        return oatpp::network::virtual_::server::ConnectionProvider::createShared(interface);
+        }());
+
+    /**
+     * Create client ConnectionProvider of oatpp virtual connections for test
+     */
+    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ClientConnectionProvider>, clientConnectionProvider)([] {
+        OATPP_COMPONENT(std::shared_ptr<oatpp::network::virtual_::Interface>, interface);
+        return oatpp::network::virtual_::client::ConnectionProvider::createShared(interface);
+        }());
+
+    /**
+     *  Create Router component
+     */
+    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, httpRouter)([] {
+        return oatpp::web::server::HttpRouter::createShared();
+        }());
+
+    /**
+     *  Create ConnectionHandler component which uses Router component to route requests
+     */
+    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ConnectionHandler>, serverConnectionHandler)([] {
+        OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router); // get Router component
+        return oatpp::web::server::HttpConnectionHandler::createShared(router);
+        }());
+
+    /**
+     *  Create ObjectMapper component to serialize/deserialize DTOs in Contoller's API
+     */
+    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, apiObjectMapper)([] {
+        return oatpp::parser::json::mapping::ObjectMapper::createShared();
+        }());
+
+};
+
+
+#endif // TestComponent_hpp

test/app/TestDatabaseComponent.hpp

@@ -0,0 +1,34 @@
+
+#ifndef TEST_DATABASECOMPONENT_HPP
+#define TEST_DATABASECOMPONENT_HPP
+
+#include "db/UserDb.hpp"
+
+class TestDatabaseComponent {
+public:
+
+    /**
+     * Create database client
+     */
+    OATPP_CREATE_COMPONENT(std::shared_ptr<UserDb>, userDb)([] {
+
+        /* Create database-specific ConnectionProvider */
+        auto connectionProvider = std::make_shared<oatpp::sqlite::ConnectionProvider>(TESTDATABASE_FILE);
+
+        /* Create database-specific ConnectionPool */
+        auto connectionPool = oatpp::sqlite::ConnectionPool::createShared(connectionProvider,
+            10 /* max-connections */,
+            std::chrono::seconds(5) /* connection TTL */);
+
+        /* Create database-specific Executor */
+        auto executor = std::make_shared<oatpp::sqlite::Executor>(connectionPool);
+
+        /* Create MyClient database client */
+        return std::make_shared<UserDb>(executor);
+
+        }());
+
+
+};
+
+#endif //TEST_DATABASECOMPONENT_HPP

test/tests.cpp

@@ -6,6 +6,8 @@
 
 #include "oatpp-swagger/oas3/Model.hpp"
 
+#include "DatabaseTest.hpp"
+
 #include <iostream>
 
 namespace {
@@ -25,7 +27,7 @@ void runTests() {
   OATPP_LOGD("test", "insert oatpp-swagger tests here");
 
   OATPP_RUN_TEST(Test);
-
+  OATPP_RUN_TEST(DatabaseTest);
 }
 
 }