chore: add tests

Author: diegomarquezp

google/cloud/bigtable/value_test.cc

@@ -18,6 +18,7 @@
 #include "google/cloud/testing_util/is_proto_equal.h"
 #include "google/cloud/testing_util/status_matchers.h"
 #include "absl/strings/cord.h"
+#include "absl/strings/substitute.h"
 #include <google/protobuf/text_format.h>
 #include <google/type/date.pb.h>
 #include <gmock/gmock.h>
@@ -40,6 +41,7 @@ namespace {
 using ::google::cloud::testing_util::IsOk;
 using ::google::cloud::testing_util::IsOkAndHolds;
 using ::google::cloud::testing_util::IsProtoEqual;
+using ::google::cloud::testing_util::StatusIs;
 using ::google::protobuf::TextFormat;
 using ::testing::Not;
 
@@ -1749,40 +1751,44 @@ TEST(Value, OutputStreamMatchesT) {
 }
 
 void TestTypeAndValuesMatch(std::string const& type_text,
-                            std::string const& value_text, bool expected) {
+                            std::string const& value_text,
+                            Status const& expected_status) {
   google::bigtable::v2::Type type;
   ASSERT_TRUE(TextFormat::ParseFromString(type_text, &type));
   google::bigtable::v2::Value value;
   ASSERT_TRUE(TextFormat::ParseFromString(value_text, &value));
   auto result = Value::TypeAndValuesMatch(type, value);
-  if (expected) {
-    EXPECT_STATUS_OK(result);
-  } else {
-    EXPECT_THAT(result, Not(IsOk()));
-  }
+  EXPECT_THAT(result,
+              StatusIs(expected_status.code(), expected_status.message()));
 }
 
 TEST(Value, TypeAndValuesMatchScalar) {
-  TestTypeAndValuesMatch("int64_type {}", "int_value: 123", true);
-  TestTypeAndValuesMatch("string_type {}", "string_value: 'hello'", true);
-  TestTypeAndValuesMatch("bool_type {}", "bool_value: true", true);
-  TestTypeAndValuesMatch("float64_type {}", "float_value: 3.14", true);
-  TestTypeAndValuesMatch("float32_type {}", "float_value: 3.14", true);
-  TestTypeAndValuesMatch("bytes_type {}", "bytes_value: 'bytes'", true);
+  TestTypeAndValuesMatch("int64_type {}", "int_value: 123", Status{});
+  TestTypeAndValuesMatch("string_type {}", "string_value: 'hello'", Status{});
+  TestTypeAndValuesMatch("bool_type {}", "bool_value: true", Status{});
+  TestTypeAndValuesMatch("float64_type {}", "float_value: 3.14", Status{});
+  TestTypeAndValuesMatch("float32_type {}", "float_value: 3.14", Status{});
+  TestTypeAndValuesMatch("bytes_type {}", "bytes_value: 'bytes'", Status{});
   TestTypeAndValuesMatch("timestamp_type {}",
-                         "timestamp_value: { seconds: 123 }", true);
-  TestTypeAndValuesMatch("date_type {}",
-                         "date_value: { year: 2025, month: 1, day: 1 }", true);
+                         "timestamp_value: { seconds: 123 }", Status{});
+  TestTypeAndValuesMatch(
+      "date_type {}", "date_value: { year: 2025, month: 1, day: 1 }", Status{});
 }
 
 TEST(Value, TypeAndValuesMatchScalarMismatch) {
-  TestTypeAndValuesMatch("int64_type {}", "string_value: 'mismatch'", false);
-  TestTypeAndValuesMatch("string_type {}", "int_value: 123", false);
+  TestTypeAndValuesMatch(
+      "int64_type {}", "string_value: 'mismatch'",
+      internal::InternalError(
+          "Value kind must be INT_VALUE for columns of type: INT64"));
+  TestTypeAndValuesMatch(
+      "string_type {}", "int_value: 123",
+      internal::InternalError(
+          "Value kind must be STRING_VALUE for columns of type: STRING"));
 }
 
 TEST(Value, TypeAndValuesMatchNullScalar) {
-  TestTypeAndValuesMatch("int64_type {}", "", true);
-  TestTypeAndValuesMatch("string_type {}", "", true);
+  TestTypeAndValuesMatch("int64_type {}", "", Status{});
+  TestTypeAndValuesMatch("string_type {}", "", Status{});
 }
 
 TEST(Value, TypeAndValuesMatchArray) {
@@ -1795,7 +1801,7 @@ TEST(Value, TypeAndValuesMatchArray) {
       values { int_value: 2 }
     }
   )pb";
-  TestTypeAndValuesMatch(type, matching_value, true);
+  TestTypeAndValuesMatch(type, matching_value, Status{});
 }
 
 TEST(Value, TypeAndValuesMatchArrayMismatchElementType) {
@@ -1808,14 +1814,20 @@ TEST(Value, TypeAndValuesMatchArrayMismatchElementType) {
       values { string_value: "2" }
     }
   )pb";
-  TestTypeAndValuesMatch(type, mismatched_value, false);
+  TestTypeAndValuesMatch(
+      type, mismatched_value,
+      internal::InternalError(
+          "Value kind must be INT_VALUE for columns of type: INT64"));
 }
 
 TEST(Value, TypeAndValuesMatchArrayMismatchScalar) {
   auto const* type = R"pb(
     array_type { element_type { int64_type {} } }
   )pb";
-  TestTypeAndValuesMatch(type, "int_value: 123", false);
+  TestTypeAndValuesMatch(type, "int_value: 123",
+                         internal::InternalError("Value kind must be "
+                                                 "ARRAY_VALUE for columns of "
+                                                 "type: MAP"));
 }
 
 TEST(Value, TypeAndValuesMatchArrayWithNull) {
@@ -1829,7 +1841,7 @@ TEST(Value, TypeAndValuesMatchArrayWithNull) {
       values { int_value: 3 }
     }
   )pb";
-  TestTypeAndValuesMatch(type, value_with_null, true);
+  TestTypeAndValuesMatch(type, value_with_null, Status{});
 }
 
 TEST(Value, TypeAndValuesMatchStruct) {
@@ -1851,7 +1863,7 @@ TEST(Value, TypeAndValuesMatchStruct) {
       values { int_value: 42 }
     }
   )pb";
-  TestTypeAndValuesMatch(type, matching_value, true);
+  TestTypeAndValuesMatch(type, matching_value, Status{});
 }
 
 TEST(Value, TypeAndValuesMatchStructMismatchFieldType) {
@@ -1873,7 +1885,10 @@ TEST(Value, TypeAndValuesMatchStructMismatchFieldType) {
       values { string_value: "42" }
     }
   )pb";
-  TestTypeAndValuesMatch(type, mismatched_value, false);
+  TestTypeAndValuesMatch(
+      type, mismatched_value,
+      internal::InternalError(
+          "Value kind must be INT_VALUE for columns of type: INT64"));
 }
 
 TEST(Value, TypeAndValuesMatchStructMismatchFieldCount) {
@@ -1886,16 +1901,20 @@ TEST(Value, TypeAndValuesMatchStructMismatchFieldCount) {
   auto const* mismatched_value = R"pb(
     array_value { values { string_value: "John" } }
   )pb";
-  // The current implementation has a bug and will return true here.
-  // This test will fail until the bug is fixed.
-  TestTypeAndValuesMatch(type, mismatched_value, false);
+  TestTypeAndValuesMatch(
+      type, mismatched_value,
+      internal::InternalError(
+          "received Struct with 1 values, but metadata has 2 fields"));
 }
 
 TEST(Value, TypeAndValuesMatchStructMismatchScalar) {
   auto const* type = R"pb(
     struct_type { fields { type { string_type {} } } }
   )pb";
-  TestTypeAndValuesMatch(type, "string_value: 'John'", false);
+  TestTypeAndValuesMatch(
+      type, "string_value: 'John'",
+      internal::InternalError(
+          "Value kind must be ARRAY_VALUE for columns of type: STRUCT"));
 }
 
 TEST(Value, TypeAndValuesMatchStructWithNull) {
@@ -1911,7 +1930,7 @@ TEST(Value, TypeAndValuesMatchStructWithNull) {
       values {}
     }
   )pb";
-  TestTypeAndValuesMatch(type, value_with_null, true);
+  TestTypeAndValuesMatch(type, value_with_null, Status{});
 }
 
 TEST(Value, TypeAndValuesMatchMap) {
@@ -1931,7 +1950,7 @@ TEST(Value, TypeAndValuesMatchMap) {
       }
     }
   )pb";
-  TestTypeAndValuesMatch(type, matching_value, true);
+  TestTypeAndValuesMatch(type, matching_value, Status{});
 }
 
 TEST(Value, TypeAndValuesMatchMapMismatchKeyType) {
@@ -1951,7 +1970,10 @@ TEST(Value, TypeAndValuesMatchMapMismatchKeyType) {
       }
     }
   )pb";
-  TestTypeAndValuesMatch(type, mismatched_value, false);
+  TestTypeAndValuesMatch(
+      type, mismatched_value,
+      internal::InternalError(
+          "Value kind must be STRING_VALUE for columns of type: STRING"));
 }
 
 TEST(Value, TypeAndValuesMatchMapMismatchValueType) {
@@ -1971,7 +1993,10 @@ TEST(Value, TypeAndValuesMatchMapMismatchValueType) {
       }
     }
   )pb";
-  TestTypeAndValuesMatch(type, mismatched_value, false);
+  TestTypeAndValuesMatch(
+      type, mismatched_value,
+      internal::InternalError(
+          "Value kind must be INT_VALUE for columns of type: INT64"));
 }
 
 TEST(Value, TypeAndValuesMatchMapMismatchScalar) {
@@ -1981,7 +2006,10 @@ TEST(Value, TypeAndValuesMatchMapMismatchScalar) {
       value_type { int64_type {} }
     }
   )pb";
-  TestTypeAndValuesMatch(type, "string_value: 'foo'", false);
+  TestTypeAndValuesMatch(
+      type, "string_value: 'foo'",
+      internal::InternalError(
+          "Value kind must be ARRAY_VALUE for columns of type: MAP"));
 }
 
 TEST(Value, TypeAndValuesMatchMapMalformedEntry) {
@@ -1994,7 +2022,9 @@ TEST(Value, TypeAndValuesMatchMapMalformedEntry) {
   auto const* malformed_value = R"pb(
     array_value { values { array_value { values { string_value: "key1" } } } }
   )pb";
-  TestTypeAndValuesMatch(type, malformed_value, false);
+  TestTypeAndValuesMatch(
+      type, malformed_value,
+      internal::InternalError("ARRAY_VALUE must contain entries of 2 values"));
 }
 
 TEST(Value, TypeAndValuesMatchMapWithNullValue) {
@@ -2014,7 +2044,36 @@ TEST(Value, TypeAndValuesMatchMapWithNullValue) {
       }
     }
   )pb";
-  TestTypeAndValuesMatch(type, value_with_null, true);
+  TestTypeAndValuesMatch(type, value_with_null, Status{});
+}
+
+TEST(Value, TypeAndValuesMatchDepthExceeded) {
+  std::string type_text = "int64_type {}";
+  std::string value_text = "int_value: 1";
+
+  // Each layer of struct nesting increases the depth count. The initial call is
+  // at depth 1. With the current implementation, each level of nesting
+  // increases the depth by 2. To exceed the limit of 10, we need 5 levels of
+  // nesting, which will result in a call with depth 11.
+  for (int i = 0; i < 5; ++i) {
+    type_text =
+        absl::Substitute("struct_type { fields { type { $0 } } }", type_text);
+    value_text = absl::Substitute("array_value { values { $0 } }", value_text);
+  }
+
+  TestTypeAndValuesMatch(
+      type_text, value_text,
+      internal::InternalError("Nested value depth exceeds 10 levels"));
+
+  // Verify that nesting up to the limit is fine. 4 levels of nesting will
+  // result in a maximum depth of 9.
+  type_text = "int64_type {}";
+  value_text = "int_value: 1";
+  for (int i = 0; i < 4; ++i) {
+    type_text = "struct_type { fields { type { " + type_text + "} } }";
+    value_text = "array_value { values { " + value_text + "} }";
+  }
+  TestTypeAndValuesMatch(type_text, value_text, Status{});
 }
 
 }  // namespace