dev: Improve serializer, add tests.

cosmin42 · Oct 5, 2024 · 34a30de · 34a30de
1 parent 4be3d7b
commit 34a30de
Show file tree

Hide file tree

Showing 4 changed files with 121 additions and 3 deletions.
diff --git a/PB/include/pb/components/Serializer.h b/PB/include/pb/components/Serializer.h
@@ -58,6 +58,19 @@ std::variant<Json, PBDev::Error> flatAndTagSimple(int depth, std::string tag,
   return json;
 }
 
+template <typename Head, typename... Tail>
+std::variant<Json, PBDev::Error>
+flatDictionary(int depth, std::tuple<std::string, Head> const &head)
+{
+  auto &[tag, object] = head;
+
+  std::variant<Json, PBDev::Error> headJsonOrError =
+      flatAndTagSimple<Head>(depth + 1, tag, object);
+
+  return headJsonOrError;
+}
+
+
 template <typename Head, typename... Tail>
 std::variant<Json, PBDev::Error>
 flatDictionary(int depth, std::tuple<std::string, Head> const &head,
@@ -73,10 +86,10 @@ flatDictionary(int depth, std::tuple<std::string, Head> const &head,
   spdlog::info("{}T {}\n", std::string(depth * 2, ' '),
                std::get<Json>(jsonOrError).dump());
 #endif
-  auto &[tag, head] = head;
+  auto &[tag, object] = head;
 
   std::variant<Json, PBDev::Error> headJsonOrError =
-      flatAndTagSimple<Head>(depth + 1, tag, head);
+      flatAndTagSimple<Head>(depth + 1, tag, object);
 
   if (std::holds_alternative<PBDev::Error>(headJsonOrError)) {
     return headJsonOrError;

diff --git a/PB/src/Serializer.cpp b/PB/src/Serializer.cpp
@@ -1,7 +1,11 @@
 #include <pb/components/Serializer.h>
 
+#include <magic_enum.hpp>
+
 #include <boost/uuid/uuid_io.hpp>
 
+#include <pb/entities/GenericImage.h>
+
 namespace PB {
 template <>
 std::variant<Json, PBDev::Error> flatSimple(int depth, boost::uuids::uuid uuid)
@@ -15,4 +19,21 @@ std::variant<Json, PBDev::Error> flatSimple(int depth, boost::uuids::uuid uuid)
   return json;
 }
 
+template <>
+std::variant<Json, PBDev::Error> flatSimple(int depth, ImageType imageType)
+{
+  Json json;
+  json = magic_enum::enum_name(imageType);
+  return json;
+}
+
+template <>
+std::variant<Json, PBDev::Error> flatSimple(int             depth,
+                                            GenericImagePtr genericImage)
+{
+  return flatDictionary<std::string, ImageType>(
+      depth, std::make_tuple("hash", genericImage->hash()),
+      std::make_tuple("type", genericImage->type()));
+}
+
 } // namespace PB
diff --git a/PB/tests/TestMain.cpp b/PB/tests/TestMain.cpp
@@ -14,7 +14,7 @@ int main(int argc, char **argv)
   catch (const spdlog::spdlog_ex &ex) {
     std::cout << "Log init failed: " << ex.what() << std::endl;
   }
-  ::testing::GTEST_FLAG(filter) = "TestProjectManagementSystem.*";
+  ::testing::GTEST_FLAG(filter) = "TestSerializer.*";
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
diff --git a/PB/tests/TestSerializer.cpp b/PB/tests/TestSerializer.cpp
@@ -6,6 +6,7 @@
 #include <boost/uuid/uuid_io.hpp>
 
 #include <pb/components/Serializer.h>
+#include <pb/entities/RegularImageV2.h>
 
 TEST(TestSerializer, TestSimple)
 {
@@ -124,3 +125,86 @@ TEST(TestSerializer, TestMap)
   ASSERT_EQ(json1["b"], 2);
   ASSERT_EQ(json1["c"], 3);
 }
+
+TEST(TestSerializer, TestGenericImage)
+{
+  PB::GenericImagePtr genericImage = std::make_shared<PB::RegularImageV2>(
+      Path("projectPath"), "hash", Path("original"));
+  auto json = PB::flatAndTagSimple<PB::GenericImagePtr>(0, "image", genericImage);
+  ASSERT_TRUE(std::holds_alternative<Json>(json));
+  Json json0 = std::get<Json>(json);
+  ASSERT_TRUE(json0.is_object());
+  ASSERT_EQ(json0.size(), 1);
+  ASSERT_TRUE(json0.contains("image"));
+  ASSERT_TRUE(json0["image"].is_object());
+  ASSERT_EQ(json0["image"].size(), 2);
+  ASSERT_TRUE(json0["image"].contains("hash"));
+  ASSERT_EQ(json0["image"]["hash"], "hash");
+  ASSERT_TRUE(json0["image"].contains("type"));
+  ASSERT_EQ(json0["image"]["type"], "Regular");
+}
+
+TEST(TestSerializer, TestStagedAndUnstaged)
+{
+      std::vector<PB::GenericImagePtr> staged;
+  staged.push_back(std::make_shared<PB::RegularImageV2>(
+	  Path("projectPath"), "hash0", Path("original")));
+  staged.push_back(std::make_shared<PB::RegularImageV2>(
+	  Path("projectPath"), "hash1", Path("original")));
+
+
+  auto jsonOrError = PB::flatMaybeContainer<PB::GenericImagePtrLine>(0, staged);
+  ASSERT_TRUE(std::holds_alternative<Json>(jsonOrError));
+  Json json = std::get<Json>(jsonOrError);
+  ASSERT_TRUE(json.is_array());
+  ASSERT_EQ(json.size(), 2);
+  ASSERT_TRUE(json[0].is_object());
+  ASSERT_EQ(json[0].size(), 2);
+  ASSERT_TRUE(json[0].contains("hash"));
+  ASSERT_EQ(json[0]["hash"], "hash0");
+  ASSERT_TRUE(json[0].contains("type"));
+  ASSERT_EQ(json[0]["type"], "Regular");
+  ASSERT_TRUE(json[1].is_object());
+  ASSERT_EQ(json[1].size(), 2);
+  ASSERT_TRUE(json[1].contains("hash"));
+  ASSERT_EQ(json[1]["hash"], "hash1");
+  ASSERT_TRUE(json[1].contains("type"));
+  ASSERT_EQ(json[1]["type"], "Regular");
+
+  PB::GenericImagePtrMatrix unstaged;
+  unstaged.push_back(staged);
+  unstaged.push_back(staged);
+  jsonOrError = PB::flatMaybeContainer<PB::GenericImagePtrMatrix>(0, unstaged);
+  ASSERT_TRUE(std::holds_alternative<Json>(jsonOrError));
+  json = std::get<Json>(jsonOrError);
+  ASSERT_TRUE(json.is_array());
+  ASSERT_EQ(json.size(), 2);
+  ASSERT_TRUE(json[0].is_array());
+  ASSERT_EQ(json[0].size(), 2);
+  ASSERT_TRUE(json[0][0].is_object());
+  ASSERT_EQ(json[0][0].size(), 2);
+  ASSERT_TRUE(json[0][0].contains("hash"));
+  ASSERT_EQ(json[0][0]["hash"], "hash0");
+  ASSERT_TRUE(json[0][0].contains("type"));
+  ASSERT_EQ(json[0][0]["type"], "Regular");
+  ASSERT_TRUE(json[0][1].is_object());
+  ASSERT_EQ(json[0][1].size(), 2);
+  ASSERT_TRUE(json[0][1].contains("hash"));
+  ASSERT_EQ(json[0][1]["hash"], "hash1");
+  ASSERT_TRUE(json[0][1].contains("type"));
+  ASSERT_EQ(json[0][1]["type"], "Regular");
+  ASSERT_TRUE(json[1].is_array());
+  ASSERT_EQ(json[1].size(), 2);
+  ASSERT_TRUE(json[1][0].is_object());
+  ASSERT_EQ(json[1][0].size(), 2);
+  ASSERT_TRUE(json[1][0].contains("hash"));
+  ASSERT_EQ(json[1][0]["hash"], "hash0");
+  ASSERT_TRUE(json[1][0].contains("type"));
+  ASSERT_EQ(json[1][0]["type"], "Regular");
+  ASSERT_TRUE(json[1][1].is_object());
+  ASSERT_EQ(json[1][1].size(), 2);
+  ASSERT_TRUE(json[1][1].contains("hash"));
+  ASSERT_EQ(json[1][1]["hash"], "hash1");
+  ASSERT_TRUE(json[1][1].contains("type"));
+  ASSERT_EQ(json[1][1]["type"], "Regular");
+}