Add in new gtests and update events cmd

Author: perkss

include/create_container_cmd.hh

@@ -17,6 +17,10 @@ struct CreateContainerRequest {
   std::vector<std::string> cmd;
 };
 
+struct HostConfig {
+  std::string hostName;
+};
+
 class CreateContainerCmd
     : public SynchDockerCmd<model::CreateContainerResponse>,
       public std::enable_shared_from_this<CreateContainerCmd> {

src/events_cmd_exec.hh include/events_cmd_exec.hhsrc/events_cmd_exec.hh renamed to include/events_cmd_exec.hh

@@ -9,21 +9,21 @@
 
 namespace dockercpp::command::test {
 
-// TEST(create_container_cmd_Test, toJson) {
-//   auto createContainerCmd = command::CreateContainerCmdImpl(
-//       std::move(std::make_unique<command::exec::CreateContainerCmdExec>()),
-//       "alpine");
+TEST(create_container_cmd_Test, toJson) {
+  auto createContainerCmd = command::CreateContainerCmdImpl(
+      std::move(std::make_unique<command::exec::CreateContainerCmdExec>()),
+      "alpine");
 
-//   createContainerCmd.withHost("local");
+  createContainerCmd.withHost("local");
 
-//   auto expectedResponse = nlohmann::json::parse(R"(
-// {"Hostname":"local","Image":"alpine"}
-// )");
+  auto expectedResponse = nlohmann::json::parse(R"(
+{"Hostname":"local","Image":"alpine"}
+)");
 
-//   nlohmann::json json = createContainerCmd.getRequest();
+  nlohmann::json json = createContainerCmd.getRequest();
 
-//   spdlog::info("Json {}", json.dump());
+  spdlog::info("Json {}", json.dump());
 
-//   ASSERT_TRUE(json == expectedResponse);
-// }
+  ASSERT_TRUE(json == expectedResponse);
+}
 }  // namespace dockercpp::command::test

tests/create_container_cmd_test.cc

@@ -1,4 +1,4 @@
-#include "../src/events_cmd_exec.hh"
+#include "events_cmd_exec.hh"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -9,14 +9,14 @@
 
 namespace dockercpp::command::exec {
 
-// TEST(EventsTest, create) {
-//     auto eventsExec = std::make_unique<command::exec::EventsCmdExec>();
+TEST(EventsTest, create) {
+    auto eventsExec = std::make_unique<command::exec::EventsCmdExec>();
 
-//     auto eventsCmd = std::make_shared<command::EventsCmdImpl>(std::move(eventsExec));
-//     eventsCmd->withSince(1234567890)
-//              .withUntil(2234567890);
+    auto eventsCmd = std::make_shared<command::EventsCmdImpl>(std::move(eventsExec));
+    eventsCmd->withSince(1234567890)
+             .withUntil(2234567890);
 
-//     auto result = eventsCmd->exec();
-// }
+    ASSERT_EQ(2234567890, eventsCmd->getUntil());
+}
 
 }  // namespace dockercpp::command::exec

tests/events_cmd_exec_test.cc

@@ -1,10 +1,10 @@
 #include <gtest/gtest.h>
 #include <memory>
+#include "events_cmd_exec.hh"
 
 #include "events_cmd.hh"
-#include "docker_client.hh"
 
-using namespace dockercpp::command;
+namespace dockercpp::command::exec::test {
 
 class EventsCmdTest : public ::testing::Test {
 protected:
@@ -17,35 +17,44 @@ class EventsCmdTest : public ::testing::Test {
     }
 };
 
-// TEST_F(EventsCmdTest, TestEventsCmdWithSince) {
-//     std::unique_ptr<events::Exec> exec = std::make_unique<events::Exec>();
-//     EventsCmdImpl cmd(std::move(exec));
+TEST_F(EventsCmdTest, TestEventsCmdWithSince) {
+    auto eventsExec = std::make_unique<command::exec::EventsCmdExec>();
 
-//     int64_t testSince = 1234567890;
-//     cmd.withSince(testSince);
+    auto cmd = std::make_shared<command::EventsCmdImpl>(std::move(eventsExec));
+ 
+    int64_t testSince = 1234567890;
+    cmd->withSince(testSince);
 
-//     EXPECT_EQ(cmd.getSince(), testSince);
-// }
+    EXPECT_EQ(cmd->getSince(), testSince);
+}
 
-// TEST_F(EventsCmdTest, TestEventsCmdWithUntil) {
-//     std::unique_ptr<events::Exec> exec = std::make_unique<events::Exec>();
-//     EventsCmdImpl cmd(std::move(exec));
+TEST_F(EventsCmdTest, TestEventsCmdWithUntil) {
+    auto eventsExec = std::make_unique<command::exec::EventsCmdExec>();
 
-//     int64_t testUntil = 1234567890;
-//     cmd.withUntil(testUntil);
+    auto cmd = std::make_shared<command::EventsCmdImpl>(std::move(eventsExec));
+ 
+   
+    int64_t testUntil = 1234567890;
+    cmd->withUntil(testUntil);
 
-//     EXPECT_EQ(cmd.getUntil(), testUntil);
-// }
+    EXPECT_EQ(cmd->getUntil(), testUntil);
+}
 
-// TEST_F(EventsCmdTest, TestEventsCmdChaining) {
-//     std::unique_ptr<events::Exec> exec = std::make_unique<events::Exec>();
-//     EventsCmdImpl cmd(std::move(exec));
+TEST_F(EventsCmdTest, TestEventsCmdChaining) {
+   auto eventsExec = std::make_unique<command::exec::EventsCmdExec>();
 
-//     int64_t testSince = 1234567890;
-//     int64_t testUntil = 2234567890;
+    auto cmd = std::make_shared<command::EventsCmdImpl>(std::move(eventsExec));
+ 
+   
+    int64_t testSince = 1234567890;
+    int64_t testUntil = 2234567890;
 
-//     cmd.withSince(testSince).withUntil(testUntil);
+    cmd->withSince(testSince).withUntil(testUntil);
+
+    EXPECT_EQ(cmd->getSince(), testSince);
+    EXPECT_EQ(cmd->getUntil(), testUntil);
+}
+
+
+}
 
-//     EXPECT_EQ(cmd.getSince(), testSince);
-//     EXPECT_EQ(cmd.getUntil(), testUntil);
-// }