Implement PatchMutation::ApplyToLocalView

Firestore/core/src/firebase/firestore/model/mutation.cc

@@ -19,6 +19,7 @@
 #include <utility>
 
 #include "Firestore/core/src/firebase/firestore/model/document.h"
+#include "Firestore/core/src/firebase/firestore/model/field_path.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 
 namespace firebase {
@@ -67,6 +68,58 @@ std::shared_ptr<const MaybeDocument> SetMutation::ApplyToLocalView(
                                      /*has_local_mutations=*/true);
 }
 
+PatchMutation::PatchMutation(DocumentKey&& key,
+                             FieldValue&& value,
+                             FieldMask&& mask,
+                             Precondition&& precondition)
+    : Mutation(std::move(key), std::move(precondition)),
+      value_(std::move(value)),
+      mask_(std::move(mask)) {
+}
+
+std::shared_ptr<const MaybeDocument> PatchMutation::ApplyToLocalView(
+    const std::shared_ptr<const MaybeDocument>& maybe_doc,
+    const MaybeDocument*,
+    const Timestamp&) const {
+  VerifyKeyMatches(maybe_doc.get());
+
+  if (!precondition().IsValidFor(maybe_doc.get())) {
+    if (maybe_doc) {
+      return absl::make_unique<MaybeDocument>(maybe_doc->key(),
+                                              maybe_doc->version());
+    }
+    return nullptr;
+  }
+
+  SnapshotVersion version = GetPostMutationVersion(maybe_doc.get());
+  FieldValue new_data = PatchDocument(maybe_doc.get());
+  return absl::make_unique<Document>(std::move(new_data), key(), version,
+                                     /*has_local_mutations=*/true);
+}
+
+FieldValue PatchMutation::PatchDocument(const MaybeDocument* maybe_doc) const {
+  if (maybe_doc && maybe_doc->type() == MaybeDocument::Type::Document) {
+    return PatchObject(static_cast<const Document*>(maybe_doc)->data());
+  } else {
+    return PatchObject(FieldValue::FromMap({}));
+  }
+}
+
+FieldValue PatchMutation::PatchObject(FieldValue obj) const {
+  HARD_ASSERT(obj.type() == FieldValue::Type::Object);
+  for (const FieldPath& path : mask_) {
+    if (!path.empty()) {
+      absl::optional<FieldValue> new_value = value_.Get(path);
+      if (!new_value) {
+        obj = obj.Delete(path);
+      } else {
+        obj = obj.Set(path, *new_value);
+      }
+    }
+  }
+  return obj;
+}
+
 }  // namespace model
 }  // namespace firestore
 }  // namespace firebase

Firestore/core/src/firebase/firestore/model/mutation.h

@@ -20,6 +20,7 @@
 #include <memory>
 
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"
+#include "Firestore/core/src/firebase/firestore/model/field_mask.h"
 #include "Firestore/core/src/firebase/firestore/model/field_value.h"
 #include "Firestore/core/src/firebase/firestore/model/maybe_document.h"
 #include "Firestore/core/src/firebase/firestore/model/precondition.h"
@@ -141,6 +142,41 @@ class SetMutation : public Mutation {
   const FieldValue value_;
 };
 
+/**
+ * A mutation that modifies fields of the document at the given key with the
+ * given values. The values are applied through a field mask:
+ *
+ * - When a field is in both the mask and the values, the corresponding field is
+ *   updated.
+ * - When a field is in neither the mask nor the values, the corresponding field
+ *   is unmodified.
+ * - When a field is in the mask but not in the values, the corresponding field
+ *   is deleted.
+ * - When a field is not in the mask but is in the values, the values map is
+ *   ignored.
+ */
+class PatchMutation : public Mutation {
+ public:
+  PatchMutation(DocumentKey&& key,
+                FieldValue&& value,
+                FieldMask&& mask,
+                Precondition&& precondition);
+
+  // TODO(rsgowman): ApplyToRemoteDocument()
+
+  std::shared_ptr<const MaybeDocument> ApplyToLocalView(
+      const std::shared_ptr<const MaybeDocument>& maybe_doc,
+      const MaybeDocument* base_doc,
+      const Timestamp& local_write_time) const override;
+
+ private:
+  FieldValue PatchDocument(const MaybeDocument* maybe_doc) const;
+  FieldValue PatchObject(FieldValue obj) const;
+
+  const FieldValue value_;
+  const FieldMask mask_;
+};
+
 }  // namespace model
 }  // namespace firestore
 }  // namespace firebase

Firestore/core/test/firebase/firestore/model/CMakeLists.txt

@@ -29,4 +29,5 @@ cc_test(
     snapshot_version_test.cc
   DEPENDS
     firebase_firestore_model
+    firebase_firestore_testutil
 )

Firestore/core/test/firebase/firestore/model/mutation_test.cc

@@ -27,7 +27,10 @@ namespace firebase {
 namespace firestore {
 namespace model {
 
+using testutil::DeletedDoc;
 using testutil::Doc;
+using testutil::Field;
+using testutil::PatchMutation;
 using testutil::SetMutation;
 
 TEST(Mutation, AppliesSetsToDocuments) {
@@ -41,10 +44,106 @@ TEST(Mutation, AppliesSetsToDocuments) {
   std::shared_ptr<const MaybeDocument> set_doc =
       set->ApplyToLocalView(base_doc, base_doc.get(), Timestamp::Now());
   ASSERT_TRUE(set_doc);
+  ASSERT_EQ(set_doc->type(), MaybeDocument::Type::Document);
+  EXPECT_EQ(*set_doc.get(), Doc("collection/key", 0,
+                                {{"bar", FieldValue::FromString("bar-value")}},
+                                /*has_local_mutations=*/true));
+}
+
+TEST(Mutation, AppliesPatchToDocuments) {
+  auto base_doc = std::make_shared<Document>(Doc(
+      "collection/key", 0,
+      {{"foo",
+        FieldValue::FromMap({{"bar", FieldValue::FromString("bar-value")}})},
+       {"baz", FieldValue::FromString("baz-value")}}));
+
+  std::unique_ptr<Mutation> patch = PatchMutation(
+      "collection/key", {{"foo.bar", FieldValue::FromString("new-bar-value")}});
+  std::shared_ptr<const MaybeDocument> local =
+      patch->ApplyToLocalView(base_doc, base_doc.get(), Timestamp::Now());
+  ASSERT_TRUE(local);
+  EXPECT_EQ(
+      *local.get(),
+      Doc("collection/key", 0,
+          {{"foo", FieldValue::FromMap(
+                       {{"bar", FieldValue::FromString("new-bar-value")}})},
+           {"baz", FieldValue::FromString("baz-value")}},
+          /*has_local_mutations=*/true));
+}
+
+TEST(Mutation, AppliesPatchWithMergeToDocuments) {
+  auto base_doc = std::make_shared<NoDocument>(DeletedDoc("collection/key", 0));
+
+  std::unique_ptr<Mutation> upsert = PatchMutation(
+      "collection/key", {{"foo.bar", FieldValue::FromString("new-bar-value")}},
+      {Field("foo.bar")});
+  std::shared_ptr<const MaybeDocument> new_doc =
+      upsert->ApplyToLocalView(base_doc, base_doc.get(), Timestamp::Now());
+  ASSERT_TRUE(new_doc);
+  EXPECT_EQ(
+      *new_doc.get(),
+      Doc("collection/key", 0,
+          {{"foo", FieldValue::FromMap(
+                       {{"bar", FieldValue::FromString("new-bar-value")}})}},
+          /*has_local_mutations=*/true));
+}
+
+TEST(Mutation, AppliesPatchToNullDocWithMergeToDocuments) {
+  std::shared_ptr<NoDocument> base_doc = nullptr;
+
+  std::unique_ptr<Mutation> upsert = PatchMutation(
+      "collection/key", {{"foo.bar", FieldValue::FromString("new-bar-value")}},
+      {Field("foo.bar")});
+  std::shared_ptr<const MaybeDocument> new_doc =
+      upsert->ApplyToLocalView(base_doc, base_doc.get(), Timestamp::Now());
+  ASSERT_TRUE(new_doc);
+  EXPECT_EQ(
+      *new_doc.get(),
+      Doc("collection/key", 0,
+          {{"foo", FieldValue::FromMap(
+                       {{"bar", FieldValue::FromString("new-bar-value")}})}},
+          /*has_local_mutations=*/true));
+}
+
+TEST(Mutation, DeletesValuesFromTheFieldMask) {
+  auto base_doc = std::make_shared<Document>(Doc(
+      "collection/key", 0,
+      {{"foo",
+        FieldValue::FromMap({{"bar", FieldValue::FromString("bar-value")},
+                             {"baz", FieldValue::FromString("baz-value")}})}}));
+
+  std::unique_ptr<Mutation> patch =
+      PatchMutation("collection/key", {}, {Field("foo.bar")});
+
+  std::shared_ptr<const MaybeDocument> patch_doc =
+      patch->ApplyToLocalView(base_doc, base_doc.get(), Timestamp::Now());
+  ASSERT_TRUE(patch_doc);
+  EXPECT_EQ(*patch_doc.get(),
+            Doc("collection/key", 0,
+                {{"foo", FieldValue::FromMap(
+                             {{"baz", FieldValue::FromString("baz-value")}})}},
+                /*has_local_mutations=*/true));
+}
+
+TEST(Mutation, PatchesPrimitiveValue) {
+  auto base_doc = std::make_shared<Document>(
+      Doc("collection/key", 0,
+          {{"foo", FieldValue::FromString("foo-value")},
+           {"baz", FieldValue::FromString("baz-value")}}));
+
+  std::unique_ptr<Mutation> patch = PatchMutation(
+      "collection/key", {{"foo.bar", FieldValue::FromString("new-bar-value")}});
+
+  std::shared_ptr<const MaybeDocument> patched_doc =
+      patch->ApplyToLocalView(base_doc, base_doc.get(), Timestamp::Now());
+  ASSERT_TRUE(patched_doc);
   EXPECT_EQ(
-      Doc("collection/key", 0, {{"bar", FieldValue::FromString("bar-value")}},
-          /*has_local_mutations=*/true),
-      *set_doc.get());
+      *patched_doc.get(),
+      Doc("collection/key", 0,
+          {{"foo", FieldValue::FromMap(
+                       {{"bar", FieldValue::FromString("new-bar-value")}})},
+           {"baz", FieldValue::FromString("baz-value")}},
+          /*has_local_mutations=*/true));
 }
 
 }  // namespace model

Firestore/core/test/firebase/firestore/testutil/testutil.cc

@@ -20,7 +20,30 @@ namespace firebase {
 namespace firestore {
 namespace testutil {
 
-void dummy() {
+std::unique_ptr<model::PatchMutation> PatchMutation(
+    absl::string_view path,
+    const model::ObjectValue::Map& values,
+    const std::vector<model::FieldPath>* update_mask) {
+  model::FieldValue object_value = model::FieldValue::FromMap({});
+  std::vector<model::FieldPath> object_mask;
+
+  for (const auto& kv : values) {
+    model::FieldPath field_path = Field(kv.first);
+    object_mask.push_back(field_path);
+    if (kv.second.string_value() != kDeleteSentinel) {
+      object_value = object_value.Set(field_path, kv.second);
+    }
+  }
+
+  bool merge = update_mask != nullptr;
+
+  // We sort the field_mask_paths to make the order deterministic in tests.
+  std::sort(object_mask.begin(), object_mask.end());
+
+  return absl::make_unique<model::PatchMutation>(
+      Key(path), std::move(object_value),
+      model::FieldMask(merge ? *update_mask : object_mask),
+      merge ? model::Precondition::None() : model::Precondition::Exists(true));
 }
 
 }  // namespace testutil

Firestore/core/test/firebase/firestore/testutil/testutil.h

@@ -17,6 +17,7 @@
 #ifndef FIRESTORE_CORE_TEST_FIREBASE_FIRESTORE_TESTUTIL_TESTUTIL_H_
 #define FIRESTORE_CORE_TEST_FIREBASE_FIRESTORE_TESTUTIL_TESTUTIL_H_
 
+#include <algorithm>
 #include <chrono>  // NOLINT(build/c++11)
 #include <cstdint>
 #include <memory>
@@ -43,6 +44,12 @@ namespace firebase {
 namespace firestore {
 namespace testutil {
 
+/**
+ * A string sentinel that can be used with PatchMutation() to mark a field for
+ * deletion.
+ */
+constexpr const char* kDeleteSentinel = "<DELETE>";
+
 // Below are convenience methods for creating instances for tests.
 
 inline model::DocumentKey Key(absl::string_view path) {
@@ -131,6 +138,18 @@ inline std::unique_ptr<model::SetMutation> SetMutation(
       model::Precondition::None());
 }
 
+std::unique_ptr<model::PatchMutation> PatchMutation(
+    absl::string_view path,
+    const model::ObjectValue::Map& values = {},
+    const std::vector<model::FieldPath>* update_mask = nullptr);
+
+inline std::unique_ptr<model::PatchMutation> PatchMutation(
+    absl::string_view path,
+    const model::ObjectValue::Map& values,
+    const std::vector<model::FieldPath>& update_mask) {
+  return PatchMutation(path, values, &update_mask);
+}
+
 inline std::vector<uint8_t> ResumeToken(int64_t snapshot_version) {
   if (snapshot_version == 0) {
     // TODO(rsgowman): The other platforms return null here, though I'm not sure
@@ -145,10 +164,6 @@ inline std::vector<uint8_t> ResumeToken(int64_t snapshot_version) {
   return {snapshot_string.begin(), snapshot_string.end()};
 }
 
-// Add a non-inline function to make this library buildable.
-// TODO(zxu123): remove once there is non-inline function.
-void dummy();
-
 }  // namespace testutil
 }  // namespace firestore
 }  // namespace firebase