OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
| 5 #include "components/sync/device_info/local_device_info_provider_impl.h" |
| 6 |
5 #include "base/bind.h" | 7 #include "base/bind.h" |
6 #include "base/message_loop/message_loop.h" | 8 #include "base/message_loop/message_loop.h" |
7 #include "base/run_loop.h" | 9 #include "base/run_loop.h" |
8 #include "components/sync/base/get_session_name.h" | 10 #include "components/sync/base/get_session_name.h" |
9 #include "components/sync/device_info/local_device_info_provider_impl.h" | |
10 #include "components/version_info/version_info.h" | |
11 #include "testing/gtest/include/gtest/gtest.h" | 11 #include "testing/gtest/include/gtest/gtest.h" |
12 | 12 |
13 namespace syncer { | 13 namespace syncer { |
14 | 14 |
15 const char kLocalDeviceGuid[] = "foo"; | 15 const char kLocalDeviceGuid[] = "foo"; |
16 const char kSigninScopedDeviceId[] = "device_id"; | 16 const char kSigninScopedDeviceId[] = "device_id"; |
17 | 17 |
18 class LocalDeviceInfoProviderTest : public testing::Test { | 18 class LocalDeviceInfoProviderImplTest : public testing::Test { |
19 public: | 19 public: |
20 LocalDeviceInfoProviderTest() : called_back_(false) {} | 20 LocalDeviceInfoProviderImplTest() : called_back_(false) {} |
21 ~LocalDeviceInfoProviderTest() override {} | 21 ~LocalDeviceInfoProviderImplTest() override {} |
22 | 22 |
23 void SetUp() override { | 23 void SetUp() override { |
24 provider_.reset(new LocalDeviceInfoProviderImpl( | 24 provider_.reset(new LocalDeviceInfoProviderImpl( |
25 version_info::Channel::UNKNOWN, | 25 version_info::Channel::UNKNOWN, |
26 version_info::GetVersionStringWithModifier("UNKNOWN"), false)); | 26 version_info::GetVersionStringWithModifier("UNKNOWN"), false)); |
27 } | 27 } |
28 | 28 |
29 void TearDown() override { | 29 void TearDown() override { |
30 provider_.reset(); | 30 provider_.reset(); |
31 called_back_ = false; | 31 called_back_ = false; |
32 } | 32 } |
33 | 33 |
34 protected: | 34 protected: |
35 void StartInitializeProvider() { StartInitializeProvider(kLocalDeviceGuid); } | 35 void StartInitializeProvider() { StartInitializeProvider(kLocalDeviceGuid); } |
36 | 36 |
37 void StartInitializeProvider(const std::string& guid) { | 37 void StartInitializeProvider(const std::string& guid) { |
38 provider_->Initialize(guid, kSigninScopedDeviceId, | 38 provider_->Initialize(guid, kSigninScopedDeviceId, |
39 message_loop_.task_runner()); | 39 message_loop_.task_runner()); |
40 } | 40 } |
41 | 41 |
42 void FinishInitializeProvider() { | 42 void FinishInitializeProvider() { |
43 // Subscribe to the notification and wait until the callback | 43 // Subscribe to the notification and wait until the callback |
44 // is called. The callback will quit the loop. | 44 // is called. The callback will quit the loop. |
45 base::RunLoop run_loop; | 45 base::RunLoop run_loop; |
46 std::unique_ptr<LocalDeviceInfoProvider::Subscription> subscription = | 46 std::unique_ptr<LocalDeviceInfoProvider::Subscription> subscription = |
47 provider_->RegisterOnInitializedCallback( | 47 provider_->RegisterOnInitializedCallback( |
48 base::Bind(&LocalDeviceInfoProviderTest::QuitLoopOnInitialized, | 48 base::Bind(&LocalDeviceInfoProviderImplTest::QuitLoopOnInitialized, |
49 base::Unretained(this), &run_loop)); | 49 base::Unretained(this), &run_loop)); |
50 run_loop.Run(); | 50 run_loop.Run(); |
51 } | 51 } |
52 | 52 |
53 void InitializeProvider() { | 53 void InitializeProvider() { |
54 StartInitializeProvider(); | 54 StartInitializeProvider(); |
55 FinishInitializeProvider(); | 55 FinishInitializeProvider(); |
56 } | 56 } |
57 | 57 |
58 void QuitLoopOnInitialized(base::RunLoop* loop) { | 58 void QuitLoopOnInitialized(base::RunLoop* loop) { |
59 called_back_ = true; | 59 called_back_ = true; |
60 loop->Quit(); | 60 loop->Quit(); |
61 } | 61 } |
62 | 62 |
63 std::unique_ptr<LocalDeviceInfoProviderImpl> provider_; | 63 std::unique_ptr<LocalDeviceInfoProviderImpl> provider_; |
64 | 64 |
65 bool called_back_; | 65 bool called_back_; |
66 | 66 |
67 private: | 67 private: |
68 base::MessageLoop message_loop_; | 68 base::MessageLoop message_loop_; |
69 }; | 69 }; |
70 | 70 |
71 TEST_F(LocalDeviceInfoProviderTest, OnInitializedCallback) { | 71 TEST_F(LocalDeviceInfoProviderImplTest, OnInitializedCallback) { |
72 ASSERT_FALSE(called_back_); | 72 ASSERT_FALSE(called_back_); |
73 StartInitializeProvider(); | 73 StartInitializeProvider(); |
74 ASSERT_FALSE(called_back_); | 74 ASSERT_FALSE(called_back_); |
75 FinishInitializeProvider(); | 75 FinishInitializeProvider(); |
76 EXPECT_TRUE(called_back_); | 76 EXPECT_TRUE(called_back_); |
77 } | 77 } |
78 | 78 |
79 TEST_F(LocalDeviceInfoProviderTest, GetLocalDeviceInfo) { | 79 TEST_F(LocalDeviceInfoProviderImplTest, GetLocalDeviceInfo) { |
80 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); | 80 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); |
81 StartInitializeProvider(); | 81 StartInitializeProvider(); |
82 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); | 82 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); |
83 FinishInitializeProvider(); | 83 FinishInitializeProvider(); |
84 | 84 |
85 const DeviceInfo* local_device_info = provider_->GetLocalDeviceInfo(); | 85 const DeviceInfo* local_device_info = provider_->GetLocalDeviceInfo(); |
86 ASSERT_NE(nullptr, local_device_info); | 86 ASSERT_NE(nullptr, local_device_info); |
87 EXPECT_EQ(std::string(kLocalDeviceGuid), local_device_info->guid()); | 87 EXPECT_EQ(std::string(kLocalDeviceGuid), local_device_info->guid()); |
88 EXPECT_EQ(std::string(kSigninScopedDeviceId), | 88 EXPECT_EQ(std::string(kSigninScopedDeviceId), |
89 local_device_info->signin_scoped_device_id()); | 89 local_device_info->signin_scoped_device_id()); |
90 EXPECT_EQ(GetSessionNameSynchronouslyForTesting(), | 90 EXPECT_EQ(GetSessionNameSynchronouslyForTesting(), |
91 local_device_info->client_name()); | 91 local_device_info->client_name()); |
92 | 92 |
93 EXPECT_EQ(provider_->GetSyncUserAgent(), | 93 EXPECT_EQ(provider_->GetSyncUserAgent(), |
94 local_device_info->sync_user_agent()); | 94 local_device_info->sync_user_agent()); |
95 | 95 |
96 provider_->Clear(); | 96 provider_->Clear(); |
97 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); | 97 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); |
98 } | 98 } |
99 | 99 |
100 TEST_F(LocalDeviceInfoProviderTest, GetLocalSyncCacheGUID) { | 100 TEST_F(LocalDeviceInfoProviderImplTest, GetLocalSyncCacheGUID) { |
101 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); | 101 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); |
102 | 102 |
103 StartInitializeProvider(); | 103 StartInitializeProvider(); |
104 EXPECT_EQ(std::string(kLocalDeviceGuid), provider_->GetLocalSyncCacheGUID()); | 104 EXPECT_EQ(std::string(kLocalDeviceGuid), provider_->GetLocalSyncCacheGUID()); |
105 | 105 |
106 FinishInitializeProvider(); | 106 FinishInitializeProvider(); |
107 EXPECT_EQ(std::string(kLocalDeviceGuid), provider_->GetLocalSyncCacheGUID()); | 107 EXPECT_EQ(std::string(kLocalDeviceGuid), provider_->GetLocalSyncCacheGUID()); |
108 | 108 |
109 provider_->Clear(); | 109 provider_->Clear(); |
110 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); | 110 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); |
111 } | 111 } |
112 | 112 |
113 TEST_F(LocalDeviceInfoProviderTest, InitClearRace) { | 113 TEST_F(LocalDeviceInfoProviderImplTest, InitClearRace) { |
114 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); | 114 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); |
115 StartInitializeProvider(); | 115 StartInitializeProvider(); |
116 | 116 |
117 provider_->Clear(); | 117 provider_->Clear(); |
118 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); | 118 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); |
119 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); | 119 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); |
120 | 120 |
121 base::RunLoop().RunUntilIdle(); | 121 base::RunLoop().RunUntilIdle(); |
122 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); | 122 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); |
123 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); | 123 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); |
124 } | 124 } |
125 | 125 |
126 TEST_F(LocalDeviceInfoProviderTest, InitClearInitRace) { | 126 TEST_F(LocalDeviceInfoProviderImplTest, InitClearInitRace) { |
127 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); | 127 EXPECT_TRUE(provider_->GetLocalSyncCacheGUID().empty()); |
128 StartInitializeProvider(); | 128 StartInitializeProvider(); |
129 provider_->Clear(); | 129 provider_->Clear(); |
130 | 130 |
131 const std::string guid2 = "guid2"; | 131 const std::string guid2 = "guid2"; |
132 StartInitializeProvider(guid2); | 132 StartInitializeProvider(guid2); |
133 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); | 133 ASSERT_EQ(nullptr, provider_->GetLocalDeviceInfo()); |
134 EXPECT_EQ(guid2, provider_->GetLocalSyncCacheGUID()); | 134 EXPECT_EQ(guid2, provider_->GetLocalSyncCacheGUID()); |
135 | 135 |
136 FinishInitializeProvider(); | 136 FinishInitializeProvider(); |
137 const DeviceInfo* local_device_info = provider_->GetLocalDeviceInfo(); | 137 const DeviceInfo* local_device_info = provider_->GetLocalDeviceInfo(); |
138 ASSERT_NE(nullptr, local_device_info); | 138 ASSERT_NE(nullptr, local_device_info); |
139 EXPECT_EQ(guid2, local_device_info->guid()); | 139 EXPECT_EQ(guid2, local_device_info->guid()); |
140 EXPECT_EQ(guid2, provider_->GetLocalSyncCacheGUID()); | 140 EXPECT_EQ(guid2, provider_->GetLocalSyncCacheGUID()); |
141 } | 141 } |
142 | 142 |
143 } // namespace syncer | 143 } // namespace syncer |
OLD | NEW |