Add shared MockClock class and cleaned up base::Clock usage
Change-Id: I8492747700274591eab1a3f591ddb94814723943
Reviewed-on: https://weave-review.googlesource.com/1870
Reviewed-by: Alex Vakulenko <avakulenko@google.com>
diff --git a/libweave.gypi b/libweave.gypi
index b529add..6f64c89 100644
--- a/libweave.gypi
+++ b/libweave.gypi
@@ -115,6 +115,7 @@
'third_party/chromium/base/third_party/dmg_fp/dtoa.cc',
'third_party/chromium/base/third_party/icu/icu_utf.cc',
'third_party/chromium/base/time/clock.cc',
+ 'third_party/chromium/base/time/default_clock.cc',
'third_party/chromium/base/time/time.cc',
'third_party/chromium/base/time/time_posix.cc',
'third_party/chromium/base/values.cc',
diff --git a/src/base_api_handler_unittest.cc b/src/base_api_handler_unittest.cc
index ca47626..14421b0 100644
--- a/src/base_api_handler_unittest.cc
+++ b/src/base_api_handler_unittest.cc
@@ -5,6 +5,7 @@
#include "src/base_api_handler.h"
#include <base/strings/string_number_conversions.h>
+#include <base/time/default_clock.h>
#include <base/values.h>
#include <gtest/gtest.h>
#include <weave/provider/test/mock_config_store.h>
diff --git a/src/component_manager_impl.cc b/src/component_manager_impl.cc
index a23f34d..89ca0cd 100644
--- a/src/component_manager_impl.cc
+++ b/src/component_manager_impl.cc
@@ -31,10 +31,8 @@
LIBWEAVE_EXPORT EnumToStringMap<UserRole>::EnumToStringMap()
: EnumToStringMap(kMap) {}
-ComponentManagerImpl::ComponentManagerImpl() {}
-
-ComponentManagerImpl::ComponentManagerImpl(base::Clock* clock) : clock_{clock} {
-}
+ComponentManagerImpl::ComponentManagerImpl(base::Clock* clock)
+ : clock_{clock ? clock : &default_clock_} {}
ComponentManagerImpl::~ComponentManagerImpl() {}
@@ -343,7 +341,7 @@
auto& queue = state_change_queues_[component_path];
if (!queue)
queue.reset(new StateChangeQueue{kMaxStateChangeQueueSize});
- base::Time timestamp = clock_ ? clock_->Now() : base::Time::Now();
+ base::Time timestamp = clock_->Now();
queue->NotifyPropertiesUpdated(timestamp, dict);
for (const auto& cb : on_state_changed_)
cb.Run();
diff --git a/src/component_manager_impl.h b/src/component_manager_impl.h
index c59c6d9..426b4b0 100644
--- a/src/component_manager_impl.h
+++ b/src/component_manager_impl.h
@@ -5,6 +5,8 @@
#ifndef LIBWEAVE_SRC_COMPONENT_MANAGER_IMPL_H_
#define LIBWEAVE_SRC_COMPONENT_MANAGER_IMPL_H_
+#include <base/time/default_clock.h>
+
#include "src/commands/command_queue.h"
#include "src/component_manager.h"
#include "src/states/state_change_queue.h"
@@ -13,8 +15,7 @@
class ComponentManagerImpl final : public ComponentManager {
public:
- ComponentManagerImpl();
- explicit ComponentManagerImpl(base::Clock* clock);
+ explicit ComponentManagerImpl(base::Clock* clock = nullptr);
~ComponentManagerImpl() override;
// Loads trait definition schema.
@@ -188,6 +189,7 @@
const std::string& path,
ErrorPtr* error);
+ base::DefaultClock default_clock_;
base::Clock* clock_{nullptr};
// An ID of last state change update. Each NotifyPropertiesUpdated()
// invocation increments this value by 1.
diff --git a/src/component_manager_unittest.cc b/src/component_manager_unittest.cc
index 902ee15..c63d2dd 100644
--- a/src/component_manager_unittest.cc
+++ b/src/component_manager_unittest.cc
@@ -12,10 +12,12 @@
#include "src/bind_lambda.h"
#include "src/commands/schema_constants.h"
#include "src/mock_component_manager.h"
+#include "src/test/mock_clock.h"
namespace weave {
using test::CreateDictionaryValue;
+using testing::Return;
namespace {
@@ -65,47 +67,36 @@
// }
// }
// }
-void CreateTestComponentTree(ComponentManager* manager) {
- const char kTraits[] = R"({"t1":{},"t2":{},"t3":{},"t4":{},"t5":{},"t6":{}})";
- auto json = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager->LoadTraits(*json, nullptr));
- EXPECT_TRUE(manager->AddComponent("", "comp1", {"t1"}, nullptr));
- EXPECT_TRUE(manager->AddComponentArrayItem("comp1", "comp2", {"t2"},
- nullptr));
- EXPECT_TRUE(manager->AddComponentArrayItem("comp1", "comp2", {"t3"},
- nullptr));
- EXPECT_TRUE(manager->AddComponent("comp1.comp2[1]", "comp3", {"t4"},
- nullptr));
- EXPECT_TRUE(manager->AddComponent("comp1.comp2[1].comp3", "comp4",
- {"t5", "t6"}, nullptr));
-}
+class ComponentManagerTest : public ::testing::Test {
+ protected:
+ void CreateTestComponentTree(ComponentManager* manager) {
+ const char kTraits[] =
+ R"({"t1":{},"t2":{},"t3":{},"t4":{},"t5":{},"t6":{}})";
+ auto json = CreateDictionaryValue(kTraits);
+ ASSERT_TRUE(manager->LoadTraits(*json, nullptr));
+ EXPECT_TRUE(manager->AddComponent("", "comp1", {"t1"}, nullptr));
+ EXPECT_TRUE(
+ manager->AddComponentArrayItem("comp1", "comp2", {"t2"}, nullptr));
+ EXPECT_TRUE(
+ manager->AddComponentArrayItem("comp1", "comp2", {"t3"}, nullptr));
+ EXPECT_TRUE(
+ manager->AddComponent("comp1.comp2[1]", "comp3", {"t4"}, nullptr));
+ EXPECT_TRUE(manager->AddComponent("comp1.comp2[1].comp3", "comp4",
+ {"t5", "t6"}, nullptr));
+ }
-// Test clock class to record predefined time intervals.
-// Implementation from base/test/simple_test_clock.{h|cc}
-class SimpleTestClock : public base::Clock {
- public:
- base::Time Now() override { return now_; }
-
- // Advances the clock by |delta|.
- void Advance(base::TimeDelta delta) { now_ += delta; }
-
- // Sets the clock to the given time.
- void SetNow(base::Time now) { now_ = now; }
-
- private:
- base::Time now_;
+ test::MockClock clock_;
+ ComponentManagerImpl manager_{&clock_};
};
} // anonymous namespace
-TEST(ComponentManager, Empty) {
- ComponentManagerImpl manager;
- EXPECT_TRUE(manager.GetTraits().empty());
- EXPECT_TRUE(manager.GetComponents().empty());
+TEST_F(ComponentManagerTest, Empty) {
+ EXPECT_TRUE(manager_.GetTraits().empty());
+ EXPECT_TRUE(manager_.GetComponents().empty());
}
-TEST(ComponentManager, LoadTraits) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraits) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -125,13 +116,12 @@
}
})";
auto json = CreateDictionaryValue(kTraits);
- EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
- EXPECT_JSON_EQ(kTraits, manager.GetTraits());
- EXPECT_TRUE(manager.GetComponents().empty());
+ EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
+ EXPECT_JSON_EQ(kTraits, manager_.GetTraits());
+ EXPECT_TRUE(manager_.GetComponents().empty());
}
-TEST(ComponentManager, LoadTraitsDuplicateIdentical) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraitsDuplicateIdentical) {
const char kTraits1[] = R"({
"trait1": {
"commands": {
@@ -151,7 +141,7 @@
}
})";
auto json = CreateDictionaryValue(kTraits1);
- EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+ EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
const char kTraits2[] = R"({
"trait1": {
"commands": {
@@ -171,7 +161,7 @@
}
})";
json = CreateDictionaryValue(kTraits2);
- EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+ EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
const char kExpected[] = R"({
"trait1": {
"commands": {
@@ -195,11 +185,10 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected, manager.GetTraits());
+ EXPECT_JSON_EQ(kExpected, manager_.GetTraits());
}
-TEST(ComponentManager, LoadTraitsDuplicateOverride) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraitsDuplicateOverride) {
const char kTraits1[] = R"({
"trait1": {
"commands": {
@@ -219,7 +208,7 @@
}
})";
auto json = CreateDictionaryValue(kTraits1);
- EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+ EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
const char kTraits2[] = R"({
"trait1": {
"commands": {
@@ -239,15 +228,14 @@
}
})";
json = CreateDictionaryValue(kTraits2);
- EXPECT_FALSE(manager.LoadTraits(*json, nullptr));
+ EXPECT_FALSE(manager_.LoadTraits(*json, nullptr));
}
-TEST(ComponentManager, AddTraitDefChangedCallback) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddTraitDefChangedCallback) {
int count = 0;
int count2 = 0;
- manager.AddTraitDefChangedCallback(base::Bind([&count]() { count++; }));
- manager.AddTraitDefChangedCallback(base::Bind([&count2]() { count2++; }));
+ manager_.AddTraitDefChangedCallback(base::Bind([&count]() { count++; }));
+ manager_.AddTraitDefChangedCallback(base::Bind([&count2]() { count2++; }));
EXPECT_EQ(1, count);
EXPECT_EQ(1, count2);
// New definitions.
@@ -264,7 +252,7 @@
}
})";
auto json = CreateDictionaryValue(kTraits1);
- EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+ EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
EXPECT_EQ(2, count);
// Duplicate definition, shouldn't call the callback.
const char kTraits2[] = R"({
@@ -275,7 +263,7 @@
}
})";
json = CreateDictionaryValue(kTraits2);
- EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+ EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
EXPECT_EQ(2, count);
// New definition, should call the callback now.
const char kTraits3[] = R"({
@@ -286,30 +274,28 @@
}
})";
json = CreateDictionaryValue(kTraits3);
- EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+ EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
EXPECT_EQ(3, count);
// Wrong definition, shouldn't call the callback.
const char kTraits4[] = R"({
"trait4": "foo"
})";
json = CreateDictionaryValue(kTraits4);
- EXPECT_FALSE(manager.LoadTraits(*json, nullptr));
+ EXPECT_FALSE(manager_.LoadTraits(*json, nullptr));
EXPECT_EQ(3, count);
// Make sure both callbacks were called the same number of times.
EXPECT_EQ(count2, count);
}
-TEST(ComponentManager, LoadTraitsNotAnObject) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraitsNotAnObject) {
const char kTraits1[] = R"({"trait1": 0})";
auto json = CreateDictionaryValue(kTraits1);
ErrorPtr error;
- EXPECT_FALSE(manager.LoadTraits(*json, &error));
+ EXPECT_FALSE(manager_.LoadTraits(*json, &error));
EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
}
-TEST(ComponentManager, FindTraitDefinition) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, FindTraitDefinition) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -329,9 +315,9 @@
}
})";
auto json = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
- const base::DictionaryValue* trait = manager.FindTraitDefinition("trait1");
+ const base::DictionaryValue* trait = manager_.FindTraitDefinition("trait1");
ASSERT_NE(nullptr, trait);
const char kExpected1[] = R"({
"commands": {
@@ -346,7 +332,7 @@
})";
EXPECT_JSON_EQ(kExpected1, *trait);
- trait = manager.FindTraitDefinition("trait2");
+ trait = manager_.FindTraitDefinition("trait2");
ASSERT_NE(nullptr, trait);
const char kExpected2[] = R"({
"state": {
@@ -355,11 +341,10 @@
})";
EXPECT_JSON_EQ(kExpected2, *trait);
- EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait3"));
+ EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait3"));
}
-TEST(ComponentManager, FindCommandDefinition) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, FindCommandDefinition) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -381,9 +366,9 @@
}
})";
auto json = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
- const auto* cmd_def = manager.FindCommandDefinition("trait1.command1");
+ const auto* cmd_def = manager_.FindCommandDefinition("trait1.command1");
ASSERT_NE(nullptr, cmd_def);
const char kExpected1[] = R"({
"minimalRole": "user",
@@ -391,28 +376,28 @@
})";
EXPECT_JSON_EQ(kExpected1, *cmd_def);
- cmd_def = manager.FindCommandDefinition("trait2.command1");
+ cmd_def = manager_.FindCommandDefinition("trait2.command1");
ASSERT_NE(nullptr, cmd_def);
const char kExpected2[] = R"({
"minimalRole": "manager"
})";
EXPECT_JSON_EQ(kExpected2, *cmd_def);
- cmd_def = manager.FindCommandDefinition("trait2.command2");
+ cmd_def = manager_.FindCommandDefinition("trait2.command2");
ASSERT_NE(nullptr, cmd_def);
const char kExpected3[] = R"({
"minimalRole": "owner"
})";
EXPECT_JSON_EQ(kExpected3, *cmd_def);
- EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait1.command2"));
- EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait3.command1"));
- EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait"));
- EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait1.command1.parameters"));
+ EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait1.command2"));
+ EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait3.command1"));
+ EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait"));
+ EXPECT_EQ(nullptr,
+ manager_.FindTraitDefinition("trait1.command1.parameters"));
}
-TEST(ComponentManager, GetMinimalRole) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, GetMinimalRole) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -428,31 +413,31 @@
}
})";
auto json = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
UserRole role;
- ASSERT_TRUE(manager.GetMinimalRole("trait1.command1", &role, nullptr));
+ ASSERT_TRUE(manager_.GetMinimalRole("trait1.command1", &role, nullptr));
EXPECT_EQ(UserRole::kUser, role);
- ASSERT_TRUE(manager.GetMinimalRole("trait1.command2", &role, nullptr));
+ ASSERT_TRUE(manager_.GetMinimalRole("trait1.command2", &role, nullptr));
EXPECT_EQ(UserRole::kViewer, role);
- ASSERT_TRUE(manager.GetMinimalRole("trait2.command1", &role, nullptr));
+ ASSERT_TRUE(manager_.GetMinimalRole("trait2.command1", &role, nullptr));
EXPECT_EQ(UserRole::kManager, role);
- ASSERT_TRUE(manager.GetMinimalRole("trait2.command2", &role, nullptr));
+ ASSERT_TRUE(manager_.GetMinimalRole("trait2.command2", &role, nullptr));
EXPECT_EQ(UserRole::kOwner, role);
- EXPECT_FALSE(manager.GetMinimalRole("trait1.command3", &role, nullptr));
+ EXPECT_FALSE(manager_.GetMinimalRole("trait1.command3", &role, nullptr));
}
-TEST(ComponentManager, AddComponent) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddComponent) {
const char kTraits[] = R"({"trait1": {}, "trait2": {}, "trait3": {}})";
auto json = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
- EXPECT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
- EXPECT_TRUE(manager.AddComponent("", "comp2", {"trait3"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
+ EXPECT_TRUE(
+ manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("", "comp2", {"trait3"}, nullptr));
const char kExpected[] = R"({
"comp1": {
"traits": ["trait1", "trait2"]
@@ -461,18 +446,17 @@
"traits": ["trait3"]
}
})";
- EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
// 'trait4' is undefined, so can't add a component referring to it.
- EXPECT_FALSE(manager.AddComponent("", "comp3", {"trait4"}, nullptr));
+ EXPECT_FALSE(manager_.AddComponent("", "comp3", {"trait4"}, nullptr));
}
-TEST(ComponentManager, AddSubComponent) {
- ComponentManagerImpl manager;
- EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
- EXPECT_TRUE(manager.AddComponent("comp1", "comp2", {}, nullptr));
- EXPECT_TRUE(manager.AddComponent("comp1", "comp3", {}, nullptr));
- EXPECT_TRUE(manager.AddComponent("comp1.comp2", "comp4", {}, nullptr));
+TEST_F(ComponentManagerTest, AddSubComponent) {
+ EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("comp1", "comp3", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("comp1.comp2", "comp4", {}, nullptr));
const char kExpected[] = R"({
"comp1": {
"traits": [],
@@ -491,23 +475,22 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
}
-TEST(ComponentManager, AddComponentArrayItem) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddComponentArrayItem) {
const char kTraits[] = R"({"foo": {}, "bar": {}})";
auto json = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
- EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
- EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp2", {"foo"},
- nullptr));
- EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp2", {"bar"},
- nullptr));
- EXPECT_TRUE(manager.AddComponent("comp1.comp2[1]", "comp3", {}, nullptr));
- EXPECT_TRUE(manager.AddComponent("comp1.comp2[1].comp3", "comp4", {},
- nullptr));
+ EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
+ EXPECT_TRUE(
+ manager_.AddComponentArrayItem("comp1", "comp2", {"foo"}, nullptr));
+ EXPECT_TRUE(
+ manager_.AddComponentArrayItem("comp1", "comp2", {"bar"}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("comp1.comp2[1]", "comp3", {}, nullptr));
+ EXPECT_TRUE(
+ manager_.AddComponent("comp1.comp2[1].comp3", "comp4", {}, nullptr));
const char kExpected[] = R"({
"comp1": {
"traits": [],
@@ -533,96 +516,91 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
}
-TEST(ComponentManager, AddComponentExist) {
- ComponentManagerImpl manager;
- EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
- EXPECT_FALSE(manager.AddComponent("", "comp1", {}, nullptr));
- EXPECT_TRUE(manager.AddComponent("comp1", "comp2", {}, nullptr));
- EXPECT_FALSE(manager.AddComponent("comp1", "comp2", {}, nullptr));
+TEST_F(ComponentManagerTest, AddComponentExist) {
+ EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
+ EXPECT_FALSE(manager_.AddComponent("", "comp1", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
+ EXPECT_FALSE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
}
-TEST(ComponentManager, AddComponentDoesNotExist) {
- ComponentManagerImpl manager;
- EXPECT_FALSE(manager.AddComponent("comp1", "comp2", {}, nullptr));
+TEST_F(ComponentManagerTest, AddComponentDoesNotExist) {
+ EXPECT_FALSE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
}
-TEST(ComponentManager, AddComponentTreeChangedCallback) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddComponentTreeChangedCallback) {
int count = 0;
int count2 = 0;
- manager.AddComponentTreeChangedCallback(base::Bind([&count]() { count++; }));
- manager.AddComponentTreeChangedCallback(
+ manager_.AddComponentTreeChangedCallback(base::Bind([&count]() { count++; }));
+ manager_.AddComponentTreeChangedCallback(
base::Bind([&count2]() { count2++; }));
EXPECT_EQ(1, count);
EXPECT_EQ(1, count2);
- EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
EXPECT_EQ(2, count);
- EXPECT_TRUE(manager.AddComponent("comp1", "comp2", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
EXPECT_EQ(3, count);
- EXPECT_TRUE(manager.AddComponent("comp1.comp2", "comp4", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponent("comp1.comp2", "comp4", {}, nullptr));
EXPECT_EQ(4, count);
- EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
EXPECT_EQ(5, count);
- EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
+ EXPECT_TRUE(manager_.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
EXPECT_EQ(6, count);
// Make sure both callbacks were called the same number of times.
EXPECT_EQ(count2, count);
}
-TEST(ComponentManager, FindComponent) {
- ComponentManagerImpl manager;
- CreateTestComponentTree(&manager);
+TEST_F(ComponentManagerTest, FindComponent) {
+ CreateTestComponentTree(&manager_);
- const base::DictionaryValue* comp = manager.FindComponent("comp1", nullptr);
+ const base::DictionaryValue* comp = manager_.FindComponent("comp1", nullptr);
ASSERT_NE(nullptr, comp);
EXPECT_TRUE(HasTrait(*comp, "t1"));
- comp = manager.FindComponent("comp1.comp2[0]", nullptr);
+ comp = manager_.FindComponent("comp1.comp2[0]", nullptr);
ASSERT_NE(nullptr, comp);
EXPECT_TRUE(HasTrait(*comp, "t2"));
- comp = manager.FindComponent("comp1.comp2[1]", nullptr);
+ comp = manager_.FindComponent("comp1.comp2[1]", nullptr);
ASSERT_NE(nullptr, comp);
EXPECT_TRUE(HasTrait(*comp, "t3"));
- comp = manager.FindComponent("comp1.comp2[1].comp3", nullptr);
+ comp = manager_.FindComponent("comp1.comp2[1].comp3", nullptr);
ASSERT_NE(nullptr, comp);
EXPECT_TRUE(HasTrait(*comp, "t4"));
- comp = manager.FindComponent("comp1.comp2[1].comp3.comp4", nullptr);
+ comp = manager_.FindComponent("comp1.comp2[1].comp3.comp4", nullptr);
ASSERT_NE(nullptr, comp);
EXPECT_TRUE(HasTrait(*comp, "t5"));
// Some whitespaces don't hurt.
- comp = manager.FindComponent(" comp1 . comp2 [ \t 1 ] . comp3.comp4 ",
- nullptr);
+ comp = manager_.FindComponent(" comp1 . comp2 [ \t 1 ] . comp3.comp4 ",
+ nullptr);
EXPECT_NE(nullptr, comp);
// Now check some failure cases.
ErrorPtr error;
- EXPECT_EQ(nullptr, manager.FindComponent("", &error));
+ EXPECT_EQ(nullptr, manager_.FindComponent("", &error));
EXPECT_NE(nullptr, error.get());
// 'comp2' doesn't exist:
- EXPECT_EQ(nullptr, manager.FindComponent("comp2", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp2", nullptr));
// 'comp1.comp2' is an array, not a component:
- EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2", nullptr));
// 'comp1.comp2[3]' doesn't exist:
- EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[3]", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[3]", nullptr));
// Empty component names:
- EXPECT_EQ(nullptr, manager.FindComponent(".comp2[1]", nullptr));
- EXPECT_EQ(nullptr, manager.FindComponent("comp1.[1]", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent(".comp2[1]", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp1.[1]", nullptr));
// Invalid array indices:
- EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[s]", nullptr));
- EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[-2]", nullptr));
- EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[1e1]", nullptr));
- EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[1", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[s]", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[-2]", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[1e1]", nullptr));
+ EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[1", nullptr));
}
-TEST(ComponentManager, ParseCommandInstance) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, ParseCommandInstance) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -644,9 +622,9 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait2"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp2", {"trait2"}, nullptr));
std::string id;
const char kCommand1[] = R"({
@@ -657,13 +635,15 @@
})";
auto command1 = CreateDictionaryValue(kCommand1);
EXPECT_NE(nullptr,
- manager.ParseCommandInstance(*command1, Command::Origin::kLocal,
- UserRole::kUser, &id, nullptr).get());
+ manager_.ParseCommandInstance(*command1, Command::Origin::kLocal,
+ UserRole::kUser, &id, nullptr)
+ .get());
EXPECT_EQ("1234-12345", id);
// Not enough access rights
EXPECT_EQ(nullptr,
- manager.ParseCommandInstance(*command1, Command::Origin::kLocal,
- UserRole::kViewer, &id, nullptr).get());
+ manager_.ParseCommandInstance(*command1, Command::Origin::kLocal,
+ UserRole::kViewer, &id, nullptr)
+ .get());
const char kCommand2[] = R"({
"name": "trait1.command3",
@@ -673,8 +653,9 @@
auto command2 = CreateDictionaryValue(kCommand2);
// trait1.command3 doesn't exist
EXPECT_EQ(nullptr,
- manager.ParseCommandInstance(*command2, Command::Origin::kLocal,
- UserRole::kOwner, &id, nullptr).get());
+ manager_.ParseCommandInstance(*command2, Command::Origin::kLocal,
+ UserRole::kOwner, &id, nullptr)
+ .get());
EXPECT_TRUE(id.empty());
const char kCommand3[] = R"({
@@ -685,8 +666,9 @@
auto command3 = CreateDictionaryValue(kCommand3);
// Component comp1 doesn't have trait2.
EXPECT_EQ(nullptr,
- manager.ParseCommandInstance(*command3, Command::Origin::kLocal,
- UserRole::kOwner, &id, nullptr).get());
+ manager_.ParseCommandInstance(*command3, Command::Origin::kLocal,
+ UserRole::kOwner, &id, nullptr)
+ .get());
// No component specified, find the suitable component
const char kCommand4[] = R"({
@@ -694,7 +676,7 @@
"parameters": {}
})";
auto command4 = CreateDictionaryValue(kCommand4);
- auto command_instance = manager.ParseCommandInstance(
+ auto command_instance = manager_.ParseCommandInstance(
*command4, Command::Origin::kLocal, UserRole::kOwner, &id, nullptr);
EXPECT_NE(nullptr, command_instance.get());
EXPECT_EQ("comp1", command_instance->GetComponent());
@@ -704,7 +686,7 @@
"parameters": {}
})";
auto command5 = CreateDictionaryValue(kCommand5);
- command_instance = manager.ParseCommandInstance(
+ command_instance = manager_.ParseCommandInstance(
*command5, Command::Origin::kLocal, UserRole::kOwner, &id, nullptr);
EXPECT_NE(nullptr, command_instance.get());
EXPECT_EQ("comp2", command_instance->GetComponent());
@@ -716,12 +698,12 @@
})";
auto command6 = CreateDictionaryValue(kCommand6);
EXPECT_EQ(nullptr,
- manager.ParseCommandInstance(*command6, Command::Origin::kLocal,
- UserRole::kOwner, &id, nullptr).get());
+ manager_.ParseCommandInstance(*command6, Command::Origin::kLocal,
+ UserRole::kOwner, &id, nullptr)
+ .get());
}
-TEST(ComponentManager, AddCommand) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddCommand) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -730,8 +712,8 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
std::string id;
const char kCommand[] = R"({
@@ -741,17 +723,16 @@
"parameters": {}
})";
auto command = CreateDictionaryValue(kCommand);
- auto command_instance = manager.ParseCommandInstance(
+ auto command_instance = manager_.ParseCommandInstance(
*command, Command::Origin::kLocal, UserRole::kUser, &id, nullptr);
ASSERT_NE(nullptr, command_instance.get());
- manager.AddCommand(std::move(command_instance));
- const auto* queued_command = manager.FindCommand(id);
+ manager_.AddCommand(std::move(command_instance));
+ const auto* queued_command = manager_.FindCommand(id);
ASSERT_NE(nullptr, queued_command);
EXPECT_EQ("trait1.command1", queued_command->GetName());
}
-TEST(ComponentManager, AddCommandHandler) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddCommandHandler) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -765,9 +746,10 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
+ ASSERT_TRUE(
+ manager_.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
std::string last_tags;
auto handler = [&last_tags](int tag, const std::weak_ptr<Command>& command) {
@@ -776,9 +758,12 @@
last_tags += std::to_string(tag);
};
- manager.AddCommandHandler("comp1", "trait1.command1", base::Bind(handler, 1));
- manager.AddCommandHandler("comp2", "trait1.command1", base::Bind(handler, 2));
- manager.AddCommandHandler("comp2", "trait2.command2", base::Bind(handler, 3));
+ manager_.AddCommandHandler("comp1", "trait1.command1",
+ base::Bind(handler, 1));
+ manager_.AddCommandHandler("comp2", "trait1.command1",
+ base::Bind(handler, 2));
+ manager_.AddCommandHandler("comp2", "trait2.command2",
+ base::Bind(handler, 3));
EXPECT_TRUE(last_tags.empty());
const char kCommand1[] = R"({
@@ -786,10 +771,10 @@
"component": "comp1"
})";
auto command1 = CreateDictionaryValue(kCommand1);
- auto command_instance = manager.ParseCommandInstance(
+ auto command_instance = manager_.ParseCommandInstance(
*command1, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
ASSERT_NE(nullptr, command_instance.get());
- manager.AddCommand(std::move(command_instance));
+ manager_.AddCommand(std::move(command_instance));
EXPECT_EQ("1", last_tags);
last_tags.clear();
@@ -798,10 +783,10 @@
"component": "comp2"
})";
auto command2 = CreateDictionaryValue(kCommand2);
- command_instance = manager.ParseCommandInstance(
+ command_instance = manager_.ParseCommandInstance(
*command2, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
ASSERT_NE(nullptr, command_instance.get());
- manager.AddCommand(std::move(command_instance));
+ manager_.AddCommand(std::move(command_instance));
EXPECT_EQ("2", last_tags);
last_tags.clear();
@@ -811,16 +796,15 @@
"parameters": {}
})";
auto command3 = CreateDictionaryValue(kCommand3);
- command_instance = manager.ParseCommandInstance(
+ command_instance = manager_.ParseCommandInstance(
*command3, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
ASSERT_NE(nullptr, command_instance.get());
- manager.AddCommand(std::move(command_instance));
+ manager_.AddCommand(std::move(command_instance));
EXPECT_EQ("3", last_tags);
last_tags.clear();
}
-TEST(ComponentManager, AddDefaultCommandHandler) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddDefaultCommandHandler) {
const char kTraits[] = R"({
"trait1": {
"commands": {
@@ -834,15 +818,15 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp", {"trait1", "trait2"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp", {"trait1", "trait2"}, nullptr));
int count = 0;
auto handler = [&count](int tag, const std::weak_ptr<Command>& command) {
count++;
};
- manager.AddCommandHandler("", "", base::Bind(handler, 1));
+ manager_.AddCommandHandler("", "", base::Bind(handler, 1));
EXPECT_EQ(0, count);
const char kCommand1[] = R"({
@@ -850,10 +834,10 @@
"component": "comp"
})";
auto command1 = CreateDictionaryValue(kCommand1);
- auto command_instance = manager.ParseCommandInstance(
+ auto command_instance = manager_.ParseCommandInstance(
*command1, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
ASSERT_NE(nullptr, command_instance.get());
- manager.AddCommand(std::move(command_instance));
+ manager_.AddCommand(std::move(command_instance));
EXPECT_EQ(1, count);
const char kCommand2[] = R"({
@@ -861,20 +845,19 @@
"component": "comp"
})";
auto command2 = CreateDictionaryValue(kCommand2);
- command_instance = manager.ParseCommandInstance(
+ command_instance = manager_.ParseCommandInstance(
*command2, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
ASSERT_NE(nullptr, command_instance.get());
- manager.AddCommand(std::move(command_instance));
+ manager_.AddCommand(std::move(command_instance));
EXPECT_EQ(2, count);
}
-TEST(ComponentManager, SetStateProperties) {
- ComponentManagerImpl manager;
- CreateTestComponentTree(&manager);
+TEST_F(ComponentManagerTest, SetStateProperties) {
+ CreateTestComponentTree(&manager_);
const char kState1[] = R"({"t1": {"p1": 0, "p2": "foo"}})";
auto state1 = CreateDictionaryValue(kState1);
- ASSERT_TRUE(manager.SetStateProperties("comp1", *state1, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperties("comp1", *state1, nullptr));
const char kExpected1[] = R"({
"comp1": {
"traits": [ "t1" ],
@@ -901,11 +884,11 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected1, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected1, manager_.GetComponents());
const char kState2[] = R"({"t1": {"p1": {"bar": "baz"}}})";
auto state2 = CreateDictionaryValue(kState2);
- ASSERT_TRUE(manager.SetStateProperties("comp1", *state2, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperties("comp1", *state2, nullptr));
const char kExpected2[] = R"({
"comp1": {
@@ -933,12 +916,12 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected2, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected2, manager_.GetComponents());
const char kState3[] = R"({"t5": {"p1": 1}})";
auto state3 = CreateDictionaryValue(kState3);
- ASSERT_TRUE(manager.SetStateProperties("comp1.comp2[1].comp3.comp4", *state3,
- nullptr));
+ ASSERT_TRUE(manager_.SetStateProperties("comp1.comp2[1].comp3.comp4", *state3,
+ nullptr));
const char kExpected3[] = R"({
"comp1": {
@@ -967,14 +950,13 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected3, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected3, manager_.GetComponents());
}
-TEST(ComponentManager, SetStatePropertiesFromJson) {
- ComponentManagerImpl manager;
- CreateTestComponentTree(&manager);
+TEST_F(ComponentManagerTest, SetStatePropertiesFromJson) {
+ CreateTestComponentTree(&manager_);
- ASSERT_TRUE(manager.SetStatePropertiesFromJson(
+ ASSERT_TRUE(manager_.SetStatePropertiesFromJson(
"comp1.comp2[1].comp3.comp4", R"({"t5": {"p1": 3}, "t6": {"p2": 5}})",
nullptr));
@@ -1007,11 +989,10 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
}
-TEST(ComponentManager, SetGetStateProperty) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, SetGetStateProperty) {
const char kTraits[] = R"({
"trait1": {
"state": {
@@ -1027,11 +1008,12 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(
+ manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
base::StringValue p1("foo");
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
const char kExpected1[] = R"({
"comp1": {
@@ -1041,10 +1023,10 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected1, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected1, manager_.GetComponents());
base::FundamentalValue p2(2);
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait2.prop3", p2, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait2.prop3", p2, nullptr));
const char kExpected2[] = R"({
"comp1": {
@@ -1055,29 +1037,27 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected2, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpected2, manager_.GetComponents());
// Just the package name without property:
- EXPECT_FALSE(manager.SetStateProperty("comp1", "trait2", p2, nullptr));
+ EXPECT_FALSE(manager_.SetStateProperty("comp1", "trait2", p2, nullptr));
- const base::Value* value = manager.GetStateProperty("comp1", "trait1.prop1",
- nullptr);
+ const base::Value* value =
+ manager_.GetStateProperty("comp1", "trait1.prop1", nullptr);
ASSERT_NE(nullptr, value);
EXPECT_TRUE(p1.Equals(value));
- value = manager.GetStateProperty("comp1", "trait2.prop3", nullptr);
+ value = manager_.GetStateProperty("comp1", "trait2.prop3", nullptr);
ASSERT_NE(nullptr, value);
EXPECT_TRUE(p2.Equals(value));
// Non-existing property:
- EXPECT_EQ(nullptr, manager.GetStateProperty("comp1", "trait2.p", nullptr));
+ EXPECT_EQ(nullptr, manager_.GetStateProperty("comp1", "trait2.p", nullptr));
// Non-existing component
- EXPECT_EQ(nullptr, manager.GetStateProperty("comp2", "trait.prop", nullptr));
+ EXPECT_EQ(nullptr, manager_.GetStateProperty("comp2", "trait.prop", nullptr));
// Just the package name without property:
- EXPECT_EQ(nullptr, manager.GetStateProperty("comp1", "trait2", nullptr));
+ EXPECT_EQ(nullptr, manager_.GetStateProperty("comp1", "trait2", nullptr));
}
-TEST(ComponentManager, AddStateChangedCallback) {
- SimpleTestClock clock;
- ComponentManagerImpl manager{&clock};
+TEST_F(ComponentManagerTest, AddStateChangedCallback) {
const char kTraits[] = R"({
"trait1": {
"state": {
@@ -1087,38 +1067,36 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
int count = 0;
int count2 = 0;
- manager.AddStateChangedCallback(base::Bind([&count]() { count++; }));
- manager.AddStateChangedCallback(base::Bind([&count2]() { count2++; }));
+ manager_.AddStateChangedCallback(base::Bind([&count]() { count++; }));
+ manager_.AddStateChangedCallback(base::Bind([&count2]() { count2++; }));
EXPECT_EQ(1, count);
EXPECT_EQ(1, count2);
- EXPECT_EQ(0, manager.GetLastStateChangeId());
+ EXPECT_EQ(0, manager_.GetLastStateChangeId());
base::StringValue p1("foo");
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
EXPECT_EQ(2, count);
EXPECT_EQ(2, count2);
- EXPECT_EQ(1, manager.GetLastStateChangeId());
+ EXPECT_EQ(1, manager_.GetLastStateChangeId());
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop2", p1, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop2", p1, nullptr));
EXPECT_EQ(3, count);
EXPECT_EQ(3, count2);
- EXPECT_EQ(2, manager.GetLastStateChangeId());
+ EXPECT_EQ(2, manager_.GetLastStateChangeId());
// Fail - no component.
- ASSERT_FALSE(manager.SetStateProperty("comp2", "trait1.prop2", p1, nullptr));
+ ASSERT_FALSE(manager_.SetStateProperty("comp2", "trait1.prop2", p1, nullptr));
EXPECT_EQ(3, count);
EXPECT_EQ(3, count2);
- EXPECT_EQ(2, manager.GetLastStateChangeId());
+ EXPECT_EQ(2, manager_.GetLastStateChangeId());
}
-TEST(ComponentManager, ComponentStateUpdates) {
- SimpleTestClock clock;
- ComponentManagerImpl manager{&clock};
+TEST_F(ComponentManagerTest, ComponentStateUpdates) {
const char kTraits[] = R"({
"trait1": {
"state": {
@@ -1134,48 +1112,50 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(
+ manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+ ASSERT_TRUE(
+ manager_.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
std::vector<ComponentManager::UpdateID> updates1;
auto callback1 = [&updates1](ComponentManager::UpdateID id) {
updates1.push_back(id);
};
// State change queue is empty, callback should be called immediately.
- auto token1 = manager.AddServerStateUpdatedCallback(base::Bind(callback1));
+ auto token1 = manager_.AddServerStateUpdatedCallback(base::Bind(callback1));
ASSERT_EQ(1u, updates1.size());
- EXPECT_EQ(manager.GetLastStateChangeId(), updates1.front());
+ EXPECT_EQ(manager_.GetLastStateChangeId(), updates1.front());
updates1.clear();
base::StringValue foo("foo");
base::Time time1 = base::Time::Now();
- clock.SetNow(time1);
+ EXPECT_CALL(clock_, Now()).WillRepeatedly(Return(time1));
// These three updates should be grouped into two separate state change queue
// items, since they all happen at the same time, but for two different
// components.
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", foo, nullptr));
- ASSERT_TRUE(manager.SetStateProperty("comp2", "trait2.prop3", foo, nullptr));
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop2", foo, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", foo, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp2", "trait2.prop3", foo, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop2", foo, nullptr));
std::vector<ComponentManager::UpdateID> updates2;
auto callback2 = [&updates2](ComponentManager::UpdateID id) {
updates2.push_back(id);
};
// State change queue is not empty, so callback will be called later.
- auto token2 = manager.AddServerStateUpdatedCallback(base::Bind(callback2));
+ auto token2 = manager_.AddServerStateUpdatedCallback(base::Bind(callback2));
EXPECT_TRUE(updates2.empty());
base::StringValue bar("bar");
base::Time time2 = time1 + base::TimeDelta::FromSeconds(1);
- clock.SetNow(time2);
+ EXPECT_CALL(clock_, Now()).WillRepeatedly(Return(time2));
// Two more update events (as above) but at |time2|.
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", bar, nullptr));
- ASSERT_TRUE(manager.SetStateProperty("comp2", "trait2.prop3", bar, nullptr));
- ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop2", bar, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", bar, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp2", "trait2.prop3", bar, nullptr));
+ ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop2", bar, nullptr));
- auto snapshot = manager.GetAndClearRecordedStateChanges();
- EXPECT_EQ(manager.GetLastStateChangeId(), snapshot.update_id);
+ auto snapshot = manager_.GetAndClearRecordedStateChanges();
+ EXPECT_EQ(manager_.GetLastStateChangeId(), snapshot.update_id);
ASSERT_EQ(4u, snapshot.state_changes.size());
EXPECT_EQ("comp1", snapshot.state_changes[0].component);
@@ -1199,38 +1179,37 @@
*snapshot.state_changes[3].changed_properties);
// Make sure previous GetAndClearRecordedStateChanges() clears the queue.
- auto snapshot2 = manager.GetAndClearRecordedStateChanges();
- EXPECT_EQ(manager.GetLastStateChangeId(), snapshot2.update_id);
+ auto snapshot2 = manager_.GetAndClearRecordedStateChanges();
+ EXPECT_EQ(manager_.GetLastStateChangeId(), snapshot2.update_id);
EXPECT_TRUE(snapshot2.state_changes.empty());
// Now indicate that we have update the changes on the server.
- manager.NotifyStateUpdatedOnServer(snapshot.update_id);
+ manager_.NotifyStateUpdatedOnServer(snapshot.update_id);
ASSERT_EQ(1u, updates1.size());
EXPECT_EQ(snapshot.update_id, updates1.front());
ASSERT_EQ(1u, updates2.size());
EXPECT_EQ(snapshot.update_id, updates2.front());
}
-TEST(ComponentManager, FindComponentWithTrait) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, FindComponentWithTrait) {
const char kTraits[] = R"({
"trait1": {},
"trait2": {},
"trait3": {}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait3"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(
+ manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp2", {"trait3"}, nullptr));
- EXPECT_EQ("comp1", manager.FindComponentWithTrait("trait1"));
- EXPECT_EQ("comp1", manager.FindComponentWithTrait("trait2"));
- EXPECT_EQ("comp2", manager.FindComponentWithTrait("trait3"));
- EXPECT_EQ("", manager.FindComponentWithTrait("trait4"));
+ EXPECT_EQ("comp1", manager_.FindComponentWithTrait("trait1"));
+ EXPECT_EQ("comp1", manager_.FindComponentWithTrait("trait2"));
+ EXPECT_EQ("comp2", manager_.FindComponentWithTrait("trait3"));
+ EXPECT_EQ("", manager_.FindComponentWithTrait("trait4"));
}
-TEST(ComponentManager, AddLegacyCommandAndStateDefinitions) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddLegacyCommandAndStateDefinitions) {
const char kCommandDefs1[] = R"({
"package1": {
"command1": {
@@ -1248,7 +1227,7 @@
}
})";
auto json = CreateDictionaryValue(kCommandDefs1);
- EXPECT_TRUE(manager.AddLegacyCommandDefinitions(*json, nullptr));
+ EXPECT_TRUE(manager_.AddLegacyCommandDefinitions(*json, nullptr));
const char kExpected1[] = R"({
"package1": {
"commands": {
@@ -1269,11 +1248,11 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected1, manager.GetTraits());
+ EXPECT_JSON_EQ(kExpected1, manager_.GetTraits());
const char kExpectedComponents1[] = R"({
"__weave__": { "traits": ["package1", "package2"] }
})";
- EXPECT_JSON_EQ(kExpectedComponents1, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpectedComponents1, manager_.GetComponents());
const char kCommandDefs2[] = R"({
"package2": {
@@ -1285,7 +1264,7 @@
}
})";
json = CreateDictionaryValue(kCommandDefs2);
- EXPECT_TRUE(manager.AddLegacyCommandDefinitions(*json, nullptr));
+ EXPECT_TRUE(manager_.AddLegacyCommandDefinitions(*json, nullptr));
const char kExpected2[] = R"({
"package1": {
"commands": {
@@ -1313,14 +1292,14 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected2, manager.GetTraits());
+ EXPECT_JSON_EQ(kExpected2, manager_.GetTraits());
const char kExpectedComponents2[] = R"({
"__weave__": { "traits": ["package1", "package2", "package3"] }
})";
- EXPECT_JSON_EQ(kExpectedComponents2, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpectedComponents2, manager_.GetComponents());
// Redefining existing commands.
- EXPECT_FALSE(manager.AddLegacyCommandDefinitions(*json, nullptr));
+ EXPECT_FALSE(manager_.AddLegacyCommandDefinitions(*json, nullptr));
const char kStateDefs1[] = R"({
"package1": {
@@ -1333,11 +1312,11 @@
}
})";
json = CreateDictionaryValue(kStateDefs1);
- EXPECT_TRUE(manager.AddLegacyStateDefinitions(*json, nullptr));
+ EXPECT_TRUE(manager_.AddLegacyStateDefinitions(*json, nullptr));
const char kExpectedComponents3[] = R"({
"__weave__": { "traits": ["package1", "package2", "package3", "package4"] }
})";
- EXPECT_JSON_EQ(kExpectedComponents3, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpectedComponents3, manager_.GetComponents());
const char kExpected3[] = R"({
"package1": {
@@ -1376,14 +1355,14 @@
}
}
})";
- EXPECT_JSON_EQ(kExpected3, manager.GetTraits());
+ EXPECT_JSON_EQ(kExpected3, manager_.GetTraits());
const char kExpectedComponents4[] = R"({
"__weave__": { "traits": ["package1", "package2", "package3", "package4"] }
})";
- EXPECT_JSON_EQ(kExpectedComponents4, manager.GetComponents());
+ EXPECT_JSON_EQ(kExpectedComponents4, manager_.GetComponents());
// Redefining existing commands.
- EXPECT_FALSE(manager.AddLegacyStateDefinitions(*json, nullptr));
+ EXPECT_FALSE(manager_.AddLegacyStateDefinitions(*json, nullptr));
const char kExpected4[] = R"({
"package1": {
@@ -1406,11 +1385,10 @@
"command2": { "minimalRole": "owner" }
}
})";
- EXPECT_JSON_EQ(kExpected4, manager.GetLegacyCommandDefinitions());
+ EXPECT_JSON_EQ(kExpected4, manager_.GetLegacyCommandDefinitions());
}
-TEST(ComponentManager, GetLegacyState) {
- ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, GetLegacyState) {
const char kTraits[] = R"({
"trait1": {
"state": {
@@ -1426,13 +1404,13 @@
}
})";
auto traits = CreateDictionaryValue(kTraits);
- ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
- ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait2"}, nullptr));
+ ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
+ ASSERT_TRUE(manager_.AddComponent("", "comp2", {"trait2"}, nullptr));
- ASSERT_TRUE(manager.SetStatePropertiesFromJson(
+ ASSERT_TRUE(manager_.SetStatePropertiesFromJson(
"comp1", R"({"trait1": {"prop1": "foo", "prop2": "bar"}})", nullptr));
- ASSERT_TRUE(manager.SetStatePropertiesFromJson(
+ ASSERT_TRUE(manager_.SetStatePropertiesFromJson(
"comp2", R"({"trait2": {"prop3": "baz", "prop4": "quux"}})", nullptr));
const char kExpected[] = R"({
@@ -1445,10 +1423,10 @@
"prop4": "quux"
}
})";
- EXPECT_JSON_EQ(kExpected, manager.GetLegacyState());
+ EXPECT_JSON_EQ(kExpected, manager_.GetLegacyState());
}
-TEST(ComponentManager, TestMockComponentManager) {
+TEST_F(ComponentManagerTest, TestMockComponentManager) {
// Check that all the virtual methods are mocked out.
MockComponentManager mock;
}
diff --git a/src/test/mock_clock.h b/src/test/mock_clock.h
new file mode 100644
index 0000000..f1a2260
--- /dev/null
+++ b/src/test/mock_clock.h
@@ -0,0 +1,22 @@
+// Copyright 2015 The Weave Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_SRC_TEST_MOCK_CLOCK_H_
+#define LIBWEAVE_SRC_TEST_MOCK_CLOCK_H_
+
+#include <base/time/clock.h>
+#include <gmock/gmock.h>
+
+namespace weave {
+namespace test {
+
+class MockClock : public base::Clock {
+ public:
+ MOCK_METHOD0(Now, base::Time());
+};
+
+} // namespace test
+} // namespace weave
+
+#endif // LIBWEAVE_SRC_TEST_MOCK_CLOCK_H_
