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