Add LazySyncableAdapter

blimp/helium/lazy_syncable_adapter_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/helium/lazy_syncable_adapter.h"
+
+#include <stdint.h>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "blimp/helium/helium_test.h"
+#include "blimp/helium/serializable_struct.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+using testing::DoAll;
+using testing::Return;
+using testing::SaveArg;
+
+namespace blimp {
+namespace helium {
+namespace {
+
+struct TestSyncableChangeset : public SerializableStruct {
+  TestSyncableChangeset() : value(this) {}
+  ~TestSyncableChangeset() override {}
+
+  TestSyncableChangeset& operator=(const TestSyncableChangeset& other) {
+    value.Set(other.value());
+    return *this;
+  }
+
+  Field<int32_t> value;
+};
+
+class MockSyncable : public LazySyncable<TestSyncableChangeset> {
+ public:
+  MockSyncable() {}
+  ~MockSyncable() = default;
+
+  // LazySyncable implementation.
+  MOCK_CONST_METHOD1(CreateChangesetMock, TestSyncableChangeset*(Revision));
+  MOCK_METHOD1(ApplyChangeset, void(const TestSyncableChangeset&));
+  MOCK_METHOD1(SetLocalUpdateCallback, void(const base::Closure&));
+  MOCK_CONST_METHOD1(ValidateChangeset, bool(const TestSyncableChangeset&));
+  MOCK_METHOD1(ReleaseBefore, void(Revision));
+  MOCK_CONST_METHOD0(GetRevision, Revision());
+  MOCK_METHOD2(PrepareToCreateChangeset, void(Revision, base::Closure));
+
+  std::unique_ptr<TestSyncableChangeset> CreateChangeset(Revision from) const {
+    return base::WrapUnique<TestSyncableChangeset>(CreateChangesetMock(from));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockSyncable);
+};
+
+class LazySyncableAdapterTest : public HeliumTest {
+ public:
+  LazySyncableAdapterTest()
+      : adapter_(&syncable_), callback_(base::Bind(&base::DoNothing)) {}
+  ~LazySyncableAdapterTest() override = default;
+
+ protected:
+  MockSyncable syncable_;
+  LazySyncableAdapter<TestSyncableChangeset> adapter_;
+  base::Closure callback_;
+  Revision revision_ = 42;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LazySyncableAdapterTest);
+};
+
+TEST_F(LazySyncableAdapterTest, ForwardsSetLocalCallback) {
+  EXPECT_CALL(syncable_, SetLocalUpdateCallback(_)).Times(1);
+  adapter_.SetLocalUpdateCallback(callback_);
+}
+
+TEST_F(LazySyncableAdapterTest, ForwardsReleaseBefore) {
+  EXPECT_CALL(syncable_, ReleaseBefore(revision_)).Times(1);
+  adapter_.ReleaseBefore(revision_);
+}
+
+TEST_F(LazySyncableAdapterTest, ForwardsGetRevision) {
+  EXPECT_CALL(syncable_, GetRevision()).Times(1).WillOnce(Return(revision_));
+  EXPECT_EQ(revision_, adapter_.GetRevision());
+}
+
+TEST_F(LazySyncableAdapterTest, ForwardsPrepareToCreateChangeset) {
+  EXPECT_CALL(syncable_, PrepareToCreateChangeset(revision_, _)).Times(1);
+  adapter_.PrepareToCreateChangeset(revision_, callback_);
+}
+
+TEST_F(LazySyncableAdapterTest, SerializesParsesForwardsChangesets) {
+  std::unique_ptr<TestSyncableChangeset> changeset =
+      base::MakeUnique<TestSyncableChangeset>();
+  changeset->value.Set(33);
+
+  EXPECT_CALL(syncable_, CreateChangesetMock(revision_))
+      .Times(1)
+      .WillOnce(Return(changeset.release()));
+  std::unique_ptr<std::string> string_changeset =
+      adapter_.CreateChangeset(revision_);
+
+  TestSyncableChangeset validate_changeset;
+  EXPECT_CALL(syncable_, ValidateChangeset(_))
+      .Times(1)
+      .WillOnce(DoAll(SaveArg<0>(&validate_changeset), Return(true)));
+  EXPECT_EQ(true, adapter_.ValidateChangeset(*string_changeset));
+  EXPECT_EQ(33, validate_changeset.value());
+
+  TestSyncableChangeset apply_changeset;
+  EXPECT_CALL(syncable_, ApplyChangeset(_))
+      .Times(1)
+      .WillOnce(SaveArg<0>(&apply_changeset));
+  adapter_.ApplyChangeset(*string_changeset);
+  EXPECT_EQ(33, apply_changeset.value());
+}
+
+}  // namespace
+}  // namespace helium
+}  // namespace blimp