Add LwwRegister CRDT

blimp/net/helium/lww_register_unittest.cc

Index: blimp/net/helium/lww_register_unittest.cc
diff --git a/blimp/net/helium/lww_register_unittest.cc b/blimp/net/helium/lww_register_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..330eb277dc7a09660c57d4363626389121baa230
--- /dev/null
+++ b/blimp/net/helium/lww_register_unittest.cc
@@ -0,0 +1,193 @@
+// 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 "blimp/common/proto/helium.pb.h"
+#include "blimp/net/helium/vector_clock.h"
+#include "blimp/net/helium/vector_clock_generator.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace blimp {
+namespace {
+
+class LwwRegisterTest : public testing::Test {
+ public:
+  void SetUp() override {
+    local_gen_ = base::MakeUnique<VectorClockGenerator>();
+    remote_gen_ = base::MakeUnique<VectorClockGenerator>();
+    local_client_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, LwwBias::ClientWins>>(
+            local_gen_.get(), RunningAs::RunningAsClient);
+    remote_client_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, LwwBias::ClientWins>>(
+            remote_gen_.get(), RunningAs::RunningAsEngine);
+    local_engine_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, LwwBias::EngineWins>>(
+            local_gen_.get(), RunningAs::RunningAsClient);
+    remote_engine_wins_lww_register_ =
+        base::MakeUnique<LwwRegister<int, LwwBias::EngineWins>>(
+            remote_gen_.get(), RunningAs::RunningAsEngine);
+
+    lww_register_ = local_client_wins_lww_register_.get();
+  }
+
+ protected:
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset_;
+  std::unique_ptr<VectorClockGenerator> local_gen_;
+  std::unique_ptr<VectorClockGenerator> remote_gen_;
+  std::unique_ptr<LwwRegister<int, LwwBias::ClientWins>>
+      local_client_wins_lww_register_;
+  std::unique_ptr<LwwRegister<int, LwwBias::ClientWins>>
+      remote_client_wins_lww_register_;
+  std::unique_ptr<LwwRegister<int, LwwBias::EngineWins>>
+      local_engine_wins_lww_register_;
+  std::unique_ptr<LwwRegister<int, LwwBias::EngineWins>>
+      remote_engine_wins_lww_register_;
+  LwwRegister<int, LwwBias::ClientWins>* lww_register_;
+};

[scf, 2016/10/10 19:45:47]

It would be great if the test could be written a bit more declarative and with
the help of some more helper functions.

For example:

```
auto& client = getClient(ClientWins);
auto& engine = getEngine(ClientWins);

client.Set(123);

SyncFromClient();

EXPECT_EQ(123, engine.value());
```

Ideally you would feed ClientWins or EngineWins and reuse the same body, except
the outcome of the test that could be different.

Maybe focus on 1-3 tests checking for ModifiedSince, but the remainder would be
focused on Set/Get/Creating and applying changesets.

[steimel, 2016/10/11 16:39:17]

Done.

+
+TEST_F(LwwRegisterTest, SetSetsStateAndIncrementsLocalVersion) {
+  Revision current_local_revision = local_gen_->current().local_revision();
+  lww_register_->set(42);
+
+  EXPECT_EQ(42, lww_register_->state());
+  EXPECT_EQ(current_local_revision + 1, local_gen_->current().local_revision());

[scf, 2016/10/10 19:45:47]

you probably don't want to make assumptions wrt counter being just + 1 with the
local value. 

[steimel, 2016/10/11 16:39:17]

Done.

+}
+
+TEST_F(LwwRegisterTest, ModifiedSinceWorks) {

[scf, 2016/10/10 19:45:47]

probably want to merge with the previous test.

[steimel, 2016/10/11 16:39:17]

Done.

+  VectorClock earlier_revision = local_gen_->current();
+  lww_register_->set(229);
+  VectorClock current_revision = local_gen_->current();
+  VectorClock later_revision = VectorClock(current_revision);
+  later_revision.IncrementLocal();

[scf, 2016/10/10 19:45:47]

i dont think you need this, if its greater than earlier its probably good enough

[steimel, 2016/10/11 16:39:17]

Done.

+
+  EXPECT_TRUE(lww_register_->ModifiedSince(earlier_revision));
+  EXPECT_FALSE(lww_register_->ModifiedSince(current_revision));
+  EXPECT_FALSE(lww_register_->ModifiedSince(later_revision));
+}
+
+TEST_F(LwwRegisterTest, CreateChangesetToCurrentReturnsMessageWithState) {
+  lww_register_->set(1992);
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset =
+      lww_register_->CreateChangesetToCurrent(remote_gen_->current());
+
+  EXPECT_EQ(1992, changeset->integer_value());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetLaterChangesetChangesState) {
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset =
+      base::MakeUnique<proto::LwwRegisterChangesetMessage>();
+  changeset->set_integer_value(111);
+  VectorClock from(remote_gen_->current());
+  VectorClock to(from);
+  to.IncrementLocal();
+  from = from.Invert();
+  to = to.Invert();
+
+  lww_register_->ApplyChangeset(from, to, std::move(changeset));

[scf, 2016/10/10 19:45:47]

probably want to encapsulate this to something like:

Sync(LwwRegister src, LwwRegister target)

[steimel, 2016/10/11 16:39:17]

Done.

+
+  EXPECT_EQ(111, lww_register_->state());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetEarlierChangesetDoesNotChangeState) {
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset =
+      base::MakeUnique<proto::LwwRegisterChangesetMessage>();
+  changeset->set_integer_value(111);
+  VectorClock from(local_gen_->current());
+  VectorClock to(from);
+  from = from.Invert();
+  to = to.Invert();
+
+  lww_register_->set(20);
+
+  lww_register_->ApplyChangeset(from, to, std::move(changeset));
+
+  EXPECT_EQ(20, lww_register_->state());
+}
+
+TEST_F(LwwRegisterTest,
+       ApplyChangesetConflictClientWinsClientDoesNotChangeState) {
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset =
+      base::MakeUnique<proto::LwwRegisterChangesetMessage>();
+  changeset->set_integer_value(8);
+  VectorClock from(remote_gen_->current());
+  VectorClock to(from);
+  to.IncrementLocal();
+  from = from.Invert();
+  to = to.Invert();
+  local_client_wins_lww_register_->set(29);
+
+  local_client_wins_lww_register_->ApplyChangeset(from, to,
+                                                  std::move(changeset));
+
+  EXPECT_EQ(29, local_client_wins_lww_register_->state());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetConflictClientWinsRemoteChangesState) {
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset =
+      base::MakeUnique<proto::LwwRegisterChangesetMessage>();
+  changeset->set_integer_value(8);
+  VectorClock from(local_gen_->current());
+  VectorClock to(from);
+  to.IncrementLocal();
+  from = from.Invert();
+  to = to.Invert();
+  remote_client_wins_lww_register_->set(29);
+
+  remote_client_wins_lww_register_->ApplyChangeset(from, to,
+                                                   std::move(changeset));
+
+  EXPECT_EQ(8, remote_client_wins_lww_register_->state());
+}
+
+TEST_F(LwwRegisterTest, ApplyChangesetConflictEngineWinsClientChangesState) {
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset =
+      base::MakeUnique<proto::LwwRegisterChangesetMessage>();
+  changeset->set_integer_value(8);
+  VectorClock from(remote_gen_->current());
+  VectorClock to(from);
+  to.IncrementLocal();
+  from = from.Invert();
+  to = to.Invert();
+  local_engine_wins_lww_register_->set(29);
+
+  local_engine_wins_lww_register_->ApplyChangeset(from, to,
+                                                  std::move(changeset));
+
+  EXPECT_EQ(8, local_engine_wins_lww_register_->state());
+}
+
+TEST_F(LwwRegisterTest,
+       ApplyChangesetConflictEngineWinsRemoteDoesNotChangeState) {
+  std::unique_ptr<proto::LwwRegisterChangesetMessage> changeset =
+      base::MakeUnique<proto::LwwRegisterChangesetMessage>();
+  changeset->set_integer_value(8);
+  VectorClock from(local_gen_->current());
+  VectorClock to(from);
+  to.IncrementLocal();
+  from = from.Invert();
+  to = to.Invert();
+  remote_engine_wins_lww_register_->set(29);
+
+  remote_engine_wins_lww_register_->ApplyChangeset(from, to,
+                                                   std::move(changeset));
+
+  EXPECT_EQ(29, remote_engine_wins_lww_register_->state());
+}
+
+TEST_F(LwwRegisterTest, ApplyingCreatedChangesetWorks) {
+  VectorClock from = remote_gen_->current();
+  remote_engine_wins_lww_register_->set(29);
+  VectorClock to = remote_gen_->current();
+  from = from.Invert();
+  to = to.Invert();
+  local_engine_wins_lww_register_->ApplyChangeset(
+      from, to,
+      remote_engine_wins_lww_register_->CreateChangesetToCurrent(from));
+  EXPECT_EQ(29, local_engine_wins_lww_register_->state());
+}
+
+}  // namespace
+}  // namespace blimp