Skip to content

GitLab

T
tangled
Commit de7d9e81 authored by Maksim Moskvitin's avatar Maksim Moskvitin Committed by Chromium LUCI CQ
Browse files
Options

[Invalidation] Put test templates into invalidation namespace 

This CL puts content of invalidation_service_test_template into
invalidation namespace (before global and "internal" namespace were
used. It allows to avoid multiple "invalidation::" occurencies.

Although test templates are not linked into prod code, it seems safe to
keep them in invalidation namespace (and safer than keeping them in
global namespace as before this CL).

Bug: 1031125
Change-Id: I93543c33919b7f16a76ff33a3f1afce9690eb620
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2627860Reviewed-by: default avatarMarc Treib <treib@chromium.org>
Commit-Queue: Maksim Moskvitin <mmoskvitin@google.com>
Cr-Commit-Position: refs/heads/master@{#844051}
parent 632f18ce
Hide whitespace changes
Inline Side-by-side
Showing with 95 additions and 147 deletions
components/invalidation/impl/invalidation_service_test_template.cc
View file @ de7d9e81
......@@ -4,24 +4,23 @@
#include "components/invalidation/impl/invalidation_service_test_template.h"
namespace internal {
namespace invalidation {
BoundFakeInvalidationHandler::BoundFakeInvalidationHandler(
const invalidation::InvalidationService& invalidator)
const InvalidationService& invalidator)
: invalidator_(invalidator),
last_retrieved_state_(invalidation::DEFAULT_INVALIDATION_ERROR) {}
last_retrieved_state_(DEFAULT_INVALIDATION_ERROR) {}
BoundFakeInvalidationHandler::~BoundFakeInvalidationHandler() = default;
invalidation::InvalidatorState
BoundFakeInvalidationHandler::GetLastRetrievedState() const {
InvalidatorState BoundFakeInvalidationHandler::GetLastRetrievedState() const {
return last_retrieved_state_;
}
void BoundFakeInvalidationHandler::OnInvalidatorStateChange(
invalidation::InvalidatorState state) {
InvalidatorState state) {
FakeInvalidationHandler::OnInvalidatorStateChange(state);
last_retrieved_state_ = invalidator_.GetInvalidatorState();
}
} // namespace internal
} // namespace invalidation
components/invalidation/impl/invalidation_service_test_template.h
View file @ de7d9e81
......@@ -82,28 +82,24 @@
#include "components/invalidation/public/topic_invalidation_map.h"
#include "testing/gtest/include/gtest/gtest.h"
// TODO(crbug.com/1031125): consider moving this file content under invalidation
// namespace, instead of specifying it everywhere (invalidation::internal if
// polluting invalidation namespace is a concern, though it already pollutes
// global namespace).
namespace invalidation {
template <typename InvalidatorTestDelegate>
class InvalidationServiceTest : public testing::Test {
protected:
InvalidationServiceTest() = default;
invalidation::InvalidationService*
CreateAndInitializeInvalidationService() {
InvalidationService* CreateAndInitializeInvalidationService() {
this->delegate_.CreateInvalidationService();
return this->delegate_.GetInvalidationService();
}
InvalidatorTestDelegate delegate_;
const invalidation::Topic topic1 = "BOOKMARK";
const invalidation::Topic topic2 = "PREFERENCE";
const invalidation::Topic topic3 = "AUTOFILL";
const invalidation::Topic topic4 = "PUSH_MESSAGE";
const Topic topic1 = "BOOKMARK";
const Topic topic2 = "PREFERENCE";
const Topic topic3 = "AUTOFILL";
const Topic topic4 = "PUSH_MESSAGE";
};
TYPED_TEST_SUITE_P(InvalidationServiceTest);
......@@ -113,39 +109,33 @@ TYPED_TEST_SUITE_P(InvalidationServiceTest);
// between. The handler should only see invalidations when its registered and
// its IDs are registered.
TYPED_TEST_P(InvalidationServiceTest, Basic) {
invalidation::InvalidationService* const invalidator =
InvalidationService* const invalidator =
this->CreateAndInitializeInvalidationService();
invalidation::FakeInvalidationHandler handler;
FakeInvalidationHandler handler;
invalidator->RegisterInvalidationHandler(&handler);
invalidation::TopicInvalidationMap invalidation_map;
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic1, 1, "1"));
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic2, 2, "2"));
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic3, 3, "3"));
TopicInvalidationMap invalidation_map;
invalidation_map.Insert(Invalidation::Init(this->topic1, 1, "1"));
invalidation_map.Insert(Invalidation::Init(this->topic2, 2, "2"));
invalidation_map.Insert(Invalidation::Init(this->topic3, 3, "3"));
// Should be ignored since no IDs are registered to |handler|.
this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
EXPECT_EQ(0, handler.GetInvalidationCount());
invalidation::TopicSet topics;
TopicSet topics;
topics.insert(this->topic1);
topics.insert(this->topic2);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler, topics));
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::INVALIDATIONS_ENABLED);
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
invalidation::TopicInvalidationMap expected_invalidations;
expected_invalidations.Insert(
invalidation::Invalidation::Init(this->topic1, 1, "1"));
expected_invalidations.Insert(
invalidation::Invalidation::Init(this->topic2, 2, "2"));
TopicInvalidationMap expected_invalidations;
expected_invalidations.Insert(Invalidation::Init(this->topic1, 1, "1"));
expected_invalidations.Insert(Invalidation::Init(this->topic2, 2, "2"));
this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
EXPECT_EQ(1, handler.GetInvalidationCount());
......@@ -155,25 +145,20 @@ TYPED_TEST_P(InvalidationServiceTest, Basic) {
topics.insert(this->topic3);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler, topics));
expected_invalidations = invalidation::TopicInvalidationMap();
expected_invalidations.Insert(
invalidation::Invalidation::Init(this->topic2, 2, "2"));
expected_invalidations.Insert(
invalidation::Invalidation::Init(this->topic3, 3, "3"));
expected_invalidations = TopicInvalidationMap();
expected_invalidations.Insert(Invalidation::Init(this->topic2, 2, "2"));
expected_invalidations.Insert(Invalidation::Init(this->topic3, 3, "3"));
// Removed Topics should not be notified, newly-added ones should.
this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
EXPECT_EQ(2, handler.GetInvalidationCount());
EXPECT_THAT(expected_invalidations, Eq(handler.GetLastInvalidationMap()));
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::INVALIDATIONS_ENABLED);
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
invalidator->UnregisterInvalidationHandler(&handler);
......@@ -188,13 +173,13 @@ TYPED_TEST_P(InvalidationServiceTest, Basic) {
// registered should get invalidations, and the ones that have registered
// topics should receive invalidations for those topics.
TYPED_TEST_P(InvalidationServiceTest, MultipleHandlers) {
invalidation::InvalidationService* const invalidator =
InvalidationService* const invalidator =
this->CreateAndInitializeInvalidationService();
invalidation::FakeInvalidationHandler handler1;
invalidation::FakeInvalidationHandler handler2;
invalidation::FakeInvalidationHandler handler3;
invalidation::FakeInvalidationHandler handler4;
FakeInvalidationHandler handler1;
FakeInvalidationHandler handler2;
FakeInvalidationHandler handler3;
FakeInvalidationHandler handler4;
invalidator->RegisterInvalidationHandler(&handler1);
invalidator->RegisterInvalidationHandler(&handler2);
......@@ -202,14 +187,14 @@ TYPED_TEST_P(InvalidationServiceTest, MultipleHandlers) {
invalidator->RegisterInvalidationHandler(&handler4);
{
invalidation::TopicSet topics;
TopicSet topics;
topics.insert(this->topic1);
topics.insert(this->topic2);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler1, topics));
}
{
invalidation::TopicSet topics;
TopicSet topics;
topics.insert(this->topic3);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler2, topics));
}
......@@ -217,48 +202,36 @@ TYPED_TEST_P(InvalidationServiceTest, MultipleHandlers) {
// Don't register any topics for handler3.
{
invalidation::TopicSet topics;
TopicSet topics;
topics.insert(this->topic4);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler4, topics));
}
invalidator->UnregisterInvalidationHandler(&handler4);
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::INVALIDATIONS_ENABLED);
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED,
handler1.GetInvalidatorState());
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED,
handler2.GetInvalidatorState());
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED,
handler3.GetInvalidatorState());
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler4.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
EXPECT_EQ(INVALIDATIONS_ENABLED, handler1.GetInvalidatorState());
EXPECT_EQ(INVALIDATIONS_ENABLED, handler2.GetInvalidatorState());
EXPECT_EQ(INVALIDATIONS_ENABLED, handler3.GetInvalidatorState());
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler4.GetInvalidatorState());
{
invalidation::TopicInvalidationMap invalidation_map;
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic1, 1, "1"));
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic2, 2, "2"));
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic3, 3, "3"));
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic4, 4, "4"));
TopicInvalidationMap invalidation_map;
invalidation_map.Insert(Invalidation::Init(this->topic1, 1, "1"));
invalidation_map.Insert(Invalidation::Init(this->topic2, 2, "2"));
invalidation_map.Insert(Invalidation::Init(this->topic3, 3, "3"));
invalidation_map.Insert(Invalidation::Init(this->topic4, 4, "4"));
this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
invalidation::TopicInvalidationMap expected_invalidations;
expected_invalidations.Insert(
invalidation::Invalidation::Init(this->topic1, 1, "1"));
expected_invalidations.Insert(
invalidation::Invalidation::Init(this->topic2, 2, "2"));
TopicInvalidationMap expected_invalidations;
expected_invalidations.Insert(Invalidation::Init(this->topic1, 1, "1"));
expected_invalidations.Insert(Invalidation::Init(this->topic2, 2, "2"));
EXPECT_EQ(1, handler1.GetInvalidationCount());
EXPECT_THAT(expected_invalidations, Eq(handler1.GetLastInvalidationMap()));
expected_invalidations = invalidation::TopicInvalidationMap();
expected_invalidations.Insert(
invalidation::Invalidation::Init(this->topic3, 3, "3"));
expected_invalidations = TopicInvalidationMap();
expected_invalidations.Insert(Invalidation::Init(this->topic3, 3, "3"));
EXPECT_EQ(1, handler2.GetInvalidationCount());
EXPECT_THAT(expected_invalidations, Eq(handler2.GetLastInvalidationMap()));
......@@ -267,16 +240,11 @@ TYPED_TEST_P(InvalidationServiceTest, MultipleHandlers) {
EXPECT_EQ(0, handler4.GetInvalidationCount());
}
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler1.GetInvalidatorState());
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler2.GetInvalidatorState());
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler3.GetInvalidatorState());
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler4.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler1.GetInvalidatorState());
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler2.GetInvalidatorState());
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler3.GetInvalidatorState());
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler4.GetInvalidatorState());
invalidator->UnregisterInvalidationHandler(&handler3);
invalidator->UnregisterInvalidationHandler(&handler2);
......@@ -286,18 +254,18 @@ TYPED_TEST_P(InvalidationServiceTest, MultipleHandlers) {
// Multiple registrations by different handlers on the same Topic should return
// false.
TYPED_TEST_P(InvalidationServiceTest, MultipleRegistrations) {
invalidation::InvalidationService* const invalidator =
InvalidationService* const invalidator =
this->CreateAndInitializeInvalidationService();
invalidation::FakeInvalidationHandler handler1;
invalidation::FakeInvalidationHandler handler2;
FakeInvalidationHandler handler1;
FakeInvalidationHandler handler2;
invalidator->RegisterInvalidationHandler(&handler1);
invalidator->RegisterInvalidationHandler(&handler2);
// Registering both handlers for the same topic. First call should succeed,
// second should fail.
invalidation::TopicSet topics;
TopicSet topics;
topics.insert(this->topic1);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler1, topics));
EXPECT_FALSE(invalidator->UpdateInterestedTopics(&handler2, topics));
......@@ -309,114 +277,93 @@ TYPED_TEST_P(InvalidationServiceTest, MultipleRegistrations) {
// Make sure that passing an empty set to UpdateInterestedTopics clears
// the corresponding entries for the handler.
TYPED_TEST_P(InvalidationServiceTest, EmptySetUnregisters) {
invalidation::InvalidationService* const invalidator =
InvalidationService* const invalidator =
this->CreateAndInitializeInvalidationService();
invalidation::FakeInvalidationHandler handler1;
FakeInvalidationHandler handler1;
// Control observer.
invalidation::FakeInvalidationHandler handler2;
FakeInvalidationHandler handler2;
invalidator->RegisterInvalidationHandler(&handler1);
invalidator->RegisterInvalidationHandler(&handler2);
{
invalidation::TopicSet topics;
TopicSet topics;
topics.insert(this->topic1);
topics.insert(this->topic2);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler1, topics));
}
{
invalidation::TopicSet topics;
TopicSet topics;
topics.insert(this->topic3);
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler2, topics));
}
// Unregister the topics for the first observer. It should not receive any
// further invalidations.
EXPECT_TRUE(
invalidator->UpdateInterestedTopics(&handler1, invalidation::TopicSet()));
EXPECT_TRUE(invalidator->UpdateInterestedTopics(&handler1, TopicSet()));
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::INVALIDATIONS_ENABLED);
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED,
handler1.GetInvalidatorState());
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED,
handler2.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
EXPECT_EQ(INVALIDATIONS_ENABLED, handler1.GetInvalidatorState());
EXPECT_EQ(INVALIDATIONS_ENABLED, handler2.GetInvalidatorState());
{
invalidation::TopicInvalidationMap invalidation_map;
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic1, 1, "1"));
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic2, 2, "2"));
invalidation_map.Insert(
invalidation::Invalidation::Init(this->topic3, 3, "3"));
TopicInvalidationMap invalidation_map;
invalidation_map.Insert(Invalidation::Init(this->topic1, 1, "1"));
invalidation_map.Insert(Invalidation::Init(this->topic2, 2, "2"));
invalidation_map.Insert(Invalidation::Init(this->topic3, 3, "3"));
this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
EXPECT_EQ(0, handler1.GetInvalidationCount());
EXPECT_EQ(1, handler2.GetInvalidationCount());
}
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler1.GetInvalidatorState());
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler2.GetInvalidatorState());
this->delegate_.TriggerOnInvalidatorStateChange(TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler1.GetInvalidatorState());
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler2.GetInvalidatorState());
invalidator->UnregisterInvalidationHandler(&handler2);
invalidator->UnregisterInvalidationHandler(&handler1);
}
namespace internal {
// A FakeInvalidationHandler that is "bound" to a specific
// InvalidationService. This is for cross-referencing state information with
// the bound InvalidationService.
class BoundFakeInvalidationHandler
: public invalidation::FakeInvalidationHandler {
class BoundFakeInvalidationHandler : public FakeInvalidationHandler {
public:
explicit BoundFakeInvalidationHandler(
const invalidation::InvalidationService& invalidator);
explicit BoundFakeInvalidationHandler(const InvalidationService& invalidator);
~BoundFakeInvalidationHandler() override;
// Returns the last return value of GetInvalidatorState() on the
// bound invalidator from the last time the invalidator state
// changed.
invalidation::InvalidatorState GetLastRetrievedState() const;
InvalidatorState GetLastRetrievedState() const;
// InvalidationHandler implementation.
void OnInvalidatorStateChange(invalidation::InvalidatorState state) override;
void OnInvalidatorStateChange(InvalidatorState state) override;
private:
const invalidation::InvalidationService& invalidator_;
invalidation::InvalidatorState last_retrieved_state_;
const InvalidationService& invalidator_;
InvalidatorState last_retrieved_state_;
DISALLOW_COPY_AND_ASSIGN(BoundFakeInvalidationHandler);
};
} // namespace internal
TYPED_TEST_P(InvalidationServiceTest, GetInvalidatorStateAlwaysCurrent) {
invalidation::InvalidationService* const invalidator =
InvalidationService* const invalidator =
this->CreateAndInitializeInvalidationService();
internal::BoundFakeInvalidationHandler handler(*invalidator);
BoundFakeInvalidationHandler handler(*invalidator);
invalidator->RegisterInvalidationHandler(&handler);
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::INVALIDATIONS_ENABLED);
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
EXPECT_EQ(invalidation::INVALIDATIONS_ENABLED,
handler.GetLastRetrievedState());
this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetLastRetrievedState());
this->delegate_.TriggerOnInvalidatorStateChange(
invalidation::TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler.GetInvalidatorState());
EXPECT_EQ(invalidation::TRANSIENT_INVALIDATION_ERROR,
handler.GetLastRetrievedState());
this->delegate_.TriggerOnInvalidatorStateChange(TRANSIENT_INVALIDATION_ERROR);
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler.GetInvalidatorState());
EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler.GetLastRetrievedState());
invalidator->UnregisterInvalidationHandler(&handler);
}
......@@ -428,4 +375,6 @@ REGISTER_TYPED_TEST_SUITE_P(InvalidationServiceTest,
EmptySetUnregisters,
GetInvalidatorStateAlwaysCurrent);
} // namespace invalidation
#endif // COMPONENTS_INVALIDATION_IMPL_INVALIDATION_SERVICE_TEST_TEMPLATE_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment