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"
+
+namespace blimp {
+namespace {
+
+class LwwRegisterTest : public testing::Test {

[Kevin M, 2016/10/13 22:03:36]

This has too many helper functions :\

[steimel, 2016/10/17 21:46:00]

Done.

+ public:
+  void SetUp() override {
+    local_gen_ = base::MakeUnique<VersionVectorGenerator>();
+    remote_gen_ = base::MakeUnique<VersionVectorGenerator>();
+    local_client_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, Bias::ClientWins>>(local_gen_.get(),
+                                                             RunningAs::Client);
+    remote_client_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, Bias::ClientWins>>(remote_gen_.get(),
+                                                             RunningAs::Engine);
+    local_engine_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, Bias::EngineWins>>(local_gen_.get(),
+                                                             RunningAs::Client);
+    remote_engine_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, Bias::EngineWins>>(remote_gen_.get(),
+                                                             RunningAs::Engine);
+  }
+
+ protected:
+  std::unique_ptr<VersionVectorGenerator> local_gen_;

[Kevin M, 2016/10/13 22:03:36]

Why are these unique ptrs instead of just declared directly in the class?

[Kevin M, 2016/10/13 22:03:36]

"Local" and "remote"? Can we be consistent with "client" and "engine"
terminology?

[steimel, 2016/10/17 21:46:00]

Done.

+  std::unique_ptr<VersionVectorGenerator> remote_gen_;
+
+  std::unique_ptr<LwwRegister<int, Bias::ClientWins>>
+      local_client_wins_lww_register_;
+  std::unique_ptr<LwwRegister<int, Bias::ClientWins>>
+      remote_client_wins_lww_register_;
+  std::unique_ptr<LwwRegister<int, Bias::EngineWins>>
+      local_engine_wins_lww_register_;
+  std::unique_ptr<LwwRegister<int, Bias::EngineWins>>
+      remote_engine_wins_lww_register_;
+
+  template <Bias bias>
+  LwwRegister<int, bias>* getLwwRegister(RunningAs running_as);

[Kevin M, 2016/10/13 22:03:36]

Why don't we just declare protected LwwRegister fields |client_register_| and
|engine_register_| instead? We can get rid of these templated methods that way.

[steimel, 2016/10/17 21:45:59]

Done.

+
+  template <Bias bias>
+  LwwRegister<int, bias>* getClient() {
+    return getLwwRegister<bias>(RunningAs::Client);
+  }
+
+  template <Bias bias>
+  LwwRegister<int, bias>* getEngine() {
+    return getLwwRegister<bias>(RunningAs::Engine);
+  }
+
+  VersionVectorGenerator* getVersionGenerator(RunningAs running_as) {

[Kevin M, 2016/10/13 22:03:36]

Helper fn isn't necessary; just have test code call local_gen_/remote_gen_
directly.

[steimel, 2016/10/17 21:46:00]

Done.

+    switch (running_as) {
+      case RunningAs::Client:
+        return local_gen_.get();
+      case RunningAs::Engine:
+        return remote_gen_.get();
+    }
+  }
+
+  template <Bias bias>

[Kevin M, 2016/10/13 22:03:36]

This can be simplified as

template <typename FromRegisterType, ToRegisterType>
Sync(FromRegisterType* from_lww..., ToRegisterType* to_lww..., VersionVector etc
etc)

which doesn't need helper functions to be useful.

So you'd write

Sync(&engine_register_, &client_register_, &engine_gen_, &client_gen);

+  void SyncFromClient();
+
+  template <Bias bias>
+  void SyncFromEngine();
+
+  template <Bias bias>
+  void Sync(LwwRegister<int, bias>* from_lww_register,
+            LwwRegister<int, bias>* to_lww_register,
+            VersionVector from,
+            VersionVector to);
+};
+
+template <>
+LwwRegister<int, Bias::ClientWins>* LwwRegisterTest::getLwwRegister(
+    RunningAs running_as) {
+  switch (running_as) {
+    case RunningAs::Client:
+      return local_client_wins_lww_register_.get();
+    case RunningAs::Engine:
+      return remote_client_wins_lww_register_.get();
+  }
+}
+
+template <>
+LwwRegister<int, Bias::EngineWins>* LwwRegisterTest::getLwwRegister(
+    RunningAs running_as) {
+  switch (running_as) {
+    case RunningAs::Client:
+      return local_engine_wins_lww_register_.get();
+    case RunningAs::Engine:
+      return remote_engine_wins_lww_register_.get();
+  }
+}
+
+template <Bias bias>
+void LwwRegisterTest::SyncFromClient() {
+  Sync<bias>(getClient<bias>(), getEngine<bias>(),
+             getVersionGenerator(RunningAs::Engine)->current(),
+             getVersionGenerator(RunningAs::Client)->current());
+}
+
+template <Bias bias>
+void LwwRegisterTest::SyncFromEngine() {
+  Sync<bias>(getEngine<bias>(), getClient<bias>(),
+             getVersionGenerator(RunningAs::Client)->current(),
+             getVersionGenerator(RunningAs::Engine)->current());
+}
+
+template <Bias bias>
+void LwwRegisterTest::Sync(LwwRegister<int, bias>* from_lww_register,
+                           LwwRegister<int, bias>* to_lww_register,
+                           VersionVector from,
+                           VersionVector to) {
+  std::string changeset;
+  google::protobuf::io::StringOutputStream output_stream(&changeset);
+  from_lww_register->CreateChangesetToCurrent(from.Invert(), &output_stream);
+
+  google::protobuf::io::ArrayInputStream input_stream(changeset.data(),
+                                                      changeset.size());
+  to_lww_register->ApplyChangeset(from, to.Invert(), &input_stream);
+}
+
+TEST_F(LwwRegisterTest, SetSetsStateAndIncrementsLocalVersion) {
+  auto lww_register = getLwwRegister<Bias::ClientWins>(RunningAs::Client);
+  auto version_gen = getVersionGenerator(RunningAs::Client);
+
+  VersionVector earlier_version = version_gen->current();
+  lww_register->Set(42);
+  VersionVector current_version = version_gen->current();
+
+  EXPECT_EQ(42, lww_register->get());
+  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, CreateChangesetToCurrentReturnsMessageWithState) {
+  auto lww_register = getLwwRegister<Bias::ClientWins>(RunningAs::Client);
+  auto other_version_gen = getVersionGenerator(RunningAs::Engine);
+
+  lww_register->Set(1992);
+
+  std::string changeset;
+  google::protobuf::io::StringOutputStream output_stream(&changeset);
+  lww_register->CreateChangesetToCurrent(other_version_gen->current().Invert(),
+                                         &output_stream);
+
+  EXPECT_EQ("1992", changeset);
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetLaterChangesetChangesState) {
+  auto client = getClient<Bias::ClientWins>();
+  auto engine = getEngine<Bias::ClientWins>();
+
+  client->Set(123);
+
+  SyncFromClient<Bias::ClientWins>();
+
+  EXPECT_EQ(123, engine->get());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetEarlierChangesetDoesNotChangeState) {
+  auto client = getClient<Bias::ClientWins>();
+  auto engine = getEngine<Bias::ClientWins>();
+
+  client->Set(123);
+  SyncFromClient<Bias::ClientWins>();
+
+  engine->Set(456);
+  SyncFromClient<Bias::ClientWins>();
+
+  EXPECT_EQ(456, engine->get());
+}
+
+TEST_F(LwwRegisterTest,
+       ApplyChangesetConflictClientWinsClientDoesNotChangeState) {
+  auto client = getClient<Bias::ClientWins>();
+  auto engine = getEngine<Bias::ClientWins>();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromEngine<Bias::ClientWins>();
+
+  EXPECT_EQ(123, client->get());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetConflictClientWinsRemoteChangesState) {
+  auto client = getClient<Bias::ClientWins>();
+  auto engine = getEngine<Bias::ClientWins>();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromClient<Bias::ClientWins>();
+
+  EXPECT_EQ(123, engine->get());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetConflictEngineWinsClientChangesState) {
+  auto client = getClient<Bias::EngineWins>();
+  auto engine = getEngine<Bias::EngineWins>();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromEngine<Bias::EngineWins>();
+
+  EXPECT_EQ(456, client->get());
+}
+
+TEST_F(LwwRegisterTest,
+       ApplyChangesetConflictEngineWinsRemoteDoesNotChangeState) {
+  auto client = getClient<Bias::EngineWins>();
+  auto engine = getEngine<Bias::EngineWins>();
+
+  client->Set(123);
+  engine->Set(456);
+  SyncFromClient<Bias::EngineWins>();
+
+  EXPECT_EQ(456, engine->get());
+}
+
+}  // namespace
+}  // namespace blimp