Add LwwRegister CRDT

blimp/net/helium/lww_register_unittest.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "blimp/net/helium/lww_register.h"
+
+#include <string>
+
+#include "blimp/net/helium/version_vector.h"
+#include "blimp/net/helium/version_vector_generator.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"
+
+namespace blimp {
+namespace {
+
+class LwwRegisterTest : public testing::Test {
+ protected:
+  VersionVectorGenerator client_gen_;
+  VersionVectorGenerator engine_gen_;
+
+  Bias bias_;
+
+  std::unique_ptr<LwwRegister<int>> client_lww_register_;
+  std::unique_ptr<LwwRegister<int>> engine_lww_register_;
+
+  void set_bias(Bias bias) { bias_ = bias; }
+
+  LwwRegister<int>* getClient() {
+    if (client_lww_register_) {
+      return client_lww_register_.get();
+    }
+    client_lww_register_ = base::MakeUnique<LwwRegister<int>>(
+        &client_gen_, bias_, RunningAs::Client);
+    return client_lww_register_.get();
+  }
+
+  LwwRegister<int>* getEngine() {
+    if (engine_lww_register_) {
+      return engine_lww_register_.get();
+    }
+    engine_lww_register_ = base::MakeUnique<LwwRegister<int>>(
+        &engine_gen_, bias_, RunningAs::Engine);
+    return engine_lww_register_.get();
+  }
+
+  void SyncFromClient() {
+    Sync(getClient(), getEngine(), engine_gen_.current(),
+         client_gen_.current());
+  }
+
+  void SyncFromEngine() {
+    Sync(getEngine(), getClient(), client_gen_.current(),
+         engine_gen_.current());
+  }
+
+  void Sync(LwwRegister<int>* from_lww_register,
+            LwwRegister<int>* to_lww_register,
+            VersionVector from,
+            VersionVector to);
+};
+
+void LwwRegisterTest::Sync(LwwRegister<int>* from_lww_register,
+                           LwwRegister<int>* to_lww_register,
+                           VersionVector from,
+                           VersionVector to) {
+  std::string changeset;
+  google::protobuf::io::StringOutputStream raw_output_stream(&changeset);
+  google::protobuf::io::CodedOutputStream output_stream(&raw_output_stream);
+
+  from_lww_register->CreateChangesetToCurrent(from.Invert(), &output_stream);
+
+  google::protobuf::io::ArrayInputStream raw_input_stream(changeset.data(),
+                                                          changeset.size());
+  google::protobuf::io::CodedInputStream input_stream(&raw_input_stream);
+  to_lww_register->ApplyChangeset(from, to.Invert(), &input_stream);
+}
+
+TEST_F(LwwRegisterTest, SetSetsStateAndIncrementsLocalVersion) {
+  set_bias(Bias::ClientWins);
+  auto lww_register = getClient();
+
+  VersionVector earlier_version = client_gen_.current();
+  lww_register->Set(42);
+  VersionVector current_version = client_gen_.current();
+
+  EXPECT_EQ(42, lww_register->value());
+  EXPECT_LT(earlier_version.local_revision(), current_version.local_revision());
+  EXPECT_TRUE(lww_register->ModifiedSince(earlier_version));
+  EXPECT_FALSE(lww_register->ModifiedSince(current_version));
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetLaterChangesetChangesState) {
+  set_bias(Bias::ClientWins);
+  auto client = getClient();
+  auto engine = getEngine();
+
+  client->Set(123);
+  SyncFromClient();
+
+  EXPECT_EQ(123, engine->value());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetEarlierChangesetDoesNotChangeState) {
+  set_bias(Bias::ClientWins);
+  auto client = getClient();
+  auto engine = getEngine();
+
+  client->Set(123);
+  SyncFromClient();
+
+  engine->Set(456);
+  SyncFromClient();
+
+  EXPECT_EQ(456, engine->value());
+}
+
+TEST_F(LwwRegisterTest,
+       ApplyChangesetConflictClientWinsClientDoesNotChangeState) {
+  set_bias(Bias::ClientWins);
+  auto client = getClient();
+  auto engine = getEngine();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromEngine();
+
+  EXPECT_EQ(123, client->value());

[scf, 2016/10/17 22:09:51]

I would always assert the state in both sides. Then this way you could
parameterize the similar tests into helper functions. For example: 
ApplyChangesetConflictClientWinsClientDoesNotChangeState and 
ApplyChangesetConflictEngineWinsClientChangesState

[steimel, 2016/10/18 23:53:20]

Well, at least the way it's currently working, I only sync in one direction, so
checking the unsynced one wouldn't make too much sense, and then it's not clear
if I would sync one side and then the other, or sync both directions with
changesets created before the sync. I think the way it's currently done is
pretty clear and concise, but if you still have doubts we should discuss. Thanks

+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetConflictClientWinsRemoteChangesState) {
+  set_bias(Bias::ClientWins);
+  auto client = getClient();
+  auto engine = getEngine();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromClient();
+
+  EXPECT_EQ(123, engine->value());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetConflictEngineWinsClientChangesState) {
+  set_bias(Bias::EngineWins);
+  auto client = getClient();
+  auto engine = getEngine();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromEngine();
+
+  EXPECT_EQ(456, client->value());
+}
+
+TEST_F(LwwRegisterTest,
+       ApplyChangesetConflictEngineWinsRemoteDoesNotChangeState) {
+  set_bias(Bias::EngineWins);
+  auto client = getClient();
+  auto engine = getEngine();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromClient();
+
+  EXPECT_EQ(456, engine->value());
+}
+
+}  // namespace
+}  // namespace blimp