Enable Storage OSS Tests (Desktop)

Moved test files to tests/ folder and added CMakeLists.txt file for tests.

Also added json_util.h/cc to testing/cppsdk to replace the EqualsJson functionality that was being used from the internal version of jsoncpp (in third_party) to avoid having that as a dependency for open source.

PiperOrigin-RevId: 258970591

Author: ryanmeier

storage/CMakeLists.txt

@@ -149,3 +149,8 @@ if(IOS)
   # Add a dependency to downloading the headers onto admob.
   add_dependencies(firebase_storage ${pod_target_name})
 endif()
+
+if(FIREBASE_CPP_BUILD_TESTS)
+  # Add the tests subdirectory
+  add_subdirectory(tests)
+endif()

testing/CMakeLists.txt

@@ -115,11 +115,17 @@ else()
     set(util_SRCS "")
 endif()
 
+set(json_util_SRCS
+    json_util.h
+    json_util.cc)
+
 add_library(firebase_testing STATIC
     ${config_SRCS}
+    ${json_util_SRCS}
     ${reporter_SRCS}
     ${ticker_SRCS}
-    ${util_SRCS})
+    ${util_SRCS}
+)
 
 target_include_directories(firebase_testing
     PUBLIC

testing/json_util.cc

@@ -0,0 +1,143 @@
+#include "testing/json_util.h"
+
+#include <ostream>
+#include <string>
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/flexbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
+
+namespace firebase {
+namespace testing {
+namespace cppsdk {
+namespace internal {
+
+EqualsJsonMatcher::EqualsJsonMatcher(const std::string& expected_json)
+    : expected_json_(expected_json) {}
+
+bool EqualsJsonMatcher::MatchAndExplain(
+    const std::string& actual, ::testing::MatchResultListener* listener) const {
+  flatbuffers::Parser parser_actual;
+  flatbuffers::Parser parser_expected;
+
+  flexbuffers::Builder builder_actual;
+  flexbuffers::Builder builder_expected;
+
+  if (actual.empty() || !parser_actual.ParseFlexBuffer(actual.c_str(), nullptr,
+                                                       &builder_actual)) {
+    *listener << "Unable to parse actual value (" << parser_actual.error_
+              << ").\n";
+    return false;
+  }
+  if (expected_json_.empty() ||
+      !parser_expected.ParseFlexBuffer(expected_json_.c_str(), nullptr,
+                                       &builder_expected)) {
+    *listener << "Unable to parse expected value (" << parser_expected.error_
+              << ").\n";
+    return false;
+  }
+
+  std::vector<uint8_t> buffer_actual = builder_actual.GetBuffer();
+  std::vector<uint8_t> buffer_expected = builder_expected.GetBuffer();
+
+  auto root_actual = flexbuffers::GetRoot(buffer_actual);
+  auto root_expected = flexbuffers::GetRoot(buffer_expected);
+  return CompareFlexbufferReference(root_actual, root_expected, "root",
+                                    listener);
+}
+
+void EqualsJsonMatcher::DescribeTo(std::ostream* os) const {
+  *os << "equals JSON: \n" << expected_json_;
+}
+
+void EqualsJsonMatcher::DescribeNegationTo(std::ostream* os) const {
+  *os << "doesn't equal JSON: \n" << expected_json_;
+}
+
+bool EqualsJsonMatcher::CompareFlexbufferReference(
+    flexbuffers::Reference reference_actual,
+    flexbuffers::Reference reference_expected, std::string key_name,
+    ::testing::MatchResultListener* listener) const {
+
+  auto type_actual = reference_actual.GetType();
+  auto type_expected = reference_expected.GetType();
+  if (type_actual != type_expected) {
+    *listener << "Type Mismatch (" << key_name << ")\n";
+    return false;
+  } else if (type_actual == flexbuffers::FBT_MAP) {
+    flexbuffers::Map map_actual = reference_actual.AsMap();
+    flexbuffers::Map map_expected = reference_expected.AsMap();
+
+    auto keys_actual = map_actual.Keys();
+    auto keys_expected = map_expected.Keys();
+    if (keys_actual.size() != keys_expected.size()) {
+      *listener << "Size of " << key_name
+                << " does not match.  Expected: " << keys_expected.size()
+                << " Actual: " << keys_actual.size() << "\n";
+      return false;
+    }
+
+    bool map_matches = true;
+    for (int i = 0; i < keys_actual.size(); i++) {
+      auto key_actual = keys_actual[i];
+      auto key_expected = keys_expected[i];
+
+      if (key_actual.ToString() != key_expected.ToString()) {
+        *listener << "Key mismatch in " << key_name
+                  << " Expected: " << key_expected.ToString()
+                  << " Actual: " << key_actual.ToString() << "\n";
+        map_matches = false;
+        continue;
+      }
+
+      auto val_actual = map_actual.Values()[i];
+      auto val_expected = map_expected.Values()[i];
+      if (!CompareFlexbufferReference(
+              val_actual, val_expected,
+              key_name + "[" + key_actual.ToString() + "]", listener)) {
+        map_matches = false;
+      }
+    }
+    return map_matches;
+  } else if (type_actual == flexbuffers::FBT_VECTOR) {
+    flexbuffers::Vector vec_actual = reference_actual.AsVector();
+    flexbuffers::Vector vec_expected = reference_expected.AsVector();
+
+    if (vec_actual.size() != vec_expected.size()) {
+      *listener << "Size of " << key_name
+                << " does not match.  Expected: " << vec_expected.size()
+                << " Actual: " << vec_actual.size() << "\n";
+      return false;
+    }
+
+    bool vectors_match = true;
+    for (int i = 0; i < vec_actual.size(); i++) {
+      auto vec_element_actual = vec_actual[i];
+      auto vec_element_expected = vec_expected[i];
+      if (!CompareFlexbufferReference(vec_element_actual, vec_element_expected,
+                                      key_name + "[" + std::to_string(i) + "]",
+                                      listener)) {
+        vectors_match = false;
+      }
+    }
+    return vectors_match;
+  } else {
+    auto str_actual = reference_actual.ToString();
+    auto str_expected = reference_expected.ToString();
+
+    if (str_actual != str_expected) {
+      *listener << "Values for " << key_name << " do not match.\n"
+                << "Expected: " << str_expected << "\n"
+                << "Actual: " << str_actual << "\n";
+      return false;
+    }
+    return true;
+  }
+}
+
+}  // namespace internal
+
+}  // namespace cppsdk
+}  // namespace testing
+}  // namespace firebase

testing/json_util.h

@@ -0,0 +1,43 @@
+#ifndef FIREBASE_TESTING_CPPSDK_JSON_UTIL_H_
+#define FIREBASE_TESTING_CPPSDK_JSON_UTIL_H_
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include "flatbuffers/flexbuffers.h"
+
+namespace firebase {
+namespace testing {
+namespace cppsdk {
+
+namespace internal {
+
+class EqualsJsonMatcher {
+ public:
+  explicit EqualsJsonMatcher(const std::string& expected_json);
+  bool MatchAndExplain(const std::string& actual,
+                       ::testing::MatchResultListener* listener) const;
+  void DescribeTo(std::ostream* os) const;
+  void DescribeNegationTo(std::ostream* os) const;
+
+ private:
+  std::string expected_json_;
+
+  bool CompareFlexbufferReference(
+      flexbuffers::Reference reference_actual,
+      flexbuffers::Reference reference_expected, std::string key_name,
+      ::testing::MatchResultListener* listener) const;
+};
+
+}  // namespace internal
+
+inline ::testing::PolymorphicMatcher<internal::EqualsJsonMatcher> EqualsJson(
+    const std::string& expected_json) {
+  return ::testing::MakePolymorphicMatcher(
+      internal::EqualsJsonMatcher(expected_json));
+}
+
+}  // namespace cppsdk
+}  // namespace testing
+}  // namespace firebase
+
+#endif  // FIREBASE_TESTING_CPPSDK_JSON_UTIL_H_