1 //
2 // Copyright (C) 2013 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include "shill/pending_activation_store.h"
18 
19 #include <base/files/scoped_temp_dir.h>
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22 
23 #include "shill/mock_store.h"
24 #include "shill/store_factory.h"
25 
26 using ::testing::_;
27 using ::testing::DoAll;
28 using ::testing::Mock;
29 using ::testing::Return;
30 using ::testing::SetArgumentPointee;
31 
32 namespace shill {
33 
34 class PendingActivationStoreTest : public ::testing::Test {
35  public:
PendingActivationStoreTest()36   PendingActivationStoreTest() : mock_store_(new MockStore()) {
37   }
38 
39  protected:
SetMockStore()40   void SetMockStore() {
41     store_.storage_.reset(mock_store_.release());
42   }
43 
44   std::unique_ptr<MockStore> mock_store_;
45   PendingActivationStore store_;
46 };
47 
TEST_F(PendingActivationStoreTest,FileInteractions)48 TEST_F(PendingActivationStoreTest, FileInteractions) {
49   const char kEntry1[] = "1234";
50   const char kEntry2[] = "4321";
51 
52   base::ScopedTempDir temp_dir;
53   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
54 
55   EXPECT_TRUE(store_.InitStorage(temp_dir.path()));
56 
57   EXPECT_EQ(PendingActivationStore::kStateUnknown,
58             store_.GetActivationState(
59                 PendingActivationStore::kIdentifierICCID, kEntry1));
60   EXPECT_EQ(PendingActivationStore::kStateUnknown,
61             store_.GetActivationState(
62                 PendingActivationStore::kIdentifierICCID, kEntry2));
63   EXPECT_EQ(PendingActivationStore::kStateUnknown,
64             store_.GetActivationState(
65                 PendingActivationStore::kIdentifierMEID, kEntry1));
66   EXPECT_EQ(PendingActivationStore::kStateUnknown,
67             store_.GetActivationState(
68                 PendingActivationStore::kIdentifierMEID, kEntry2));
69 
70   EXPECT_TRUE(store_.SetActivationState(
71       PendingActivationStore::kIdentifierICCID,
72       kEntry1,
73       PendingActivationStore::kStatePending));
74   EXPECT_TRUE(store_.SetActivationState(
75       PendingActivationStore::kIdentifierICCID,
76       kEntry2,
77       PendingActivationStore::kStateActivated));
78 
79   EXPECT_EQ(PendingActivationStore::kStatePending,
80             store_.GetActivationState(
81                 PendingActivationStore::kIdentifierICCID, kEntry1));
82   EXPECT_EQ(PendingActivationStore::kStateActivated,
83             store_.GetActivationState(
84                 PendingActivationStore::kIdentifierICCID, kEntry2));
85   EXPECT_EQ(PendingActivationStore::kStateUnknown,
86             store_.GetActivationState(
87                 PendingActivationStore::kIdentifierMEID, kEntry1));
88   EXPECT_EQ(PendingActivationStore::kStateUnknown,
89             store_.GetActivationState(
90                 PendingActivationStore::kIdentifierMEID, kEntry2));
91 
92   EXPECT_TRUE(store_.SetActivationState(
93       PendingActivationStore::kIdentifierMEID,
94       kEntry1,
95       PendingActivationStore::kStateActivated));
96 
97   EXPECT_EQ(PendingActivationStore::kStatePending,
98             store_.GetActivationState(
99                 PendingActivationStore::kIdentifierICCID, kEntry1));
100   EXPECT_EQ(PendingActivationStore::kStateActivated,
101             store_.GetActivationState(
102                 PendingActivationStore::kIdentifierICCID, kEntry2));
103   EXPECT_EQ(PendingActivationStore::kStateActivated,
104             store_.GetActivationState(
105                 PendingActivationStore::kIdentifierMEID, kEntry1));
106 
107   EXPECT_TRUE(store_.SetActivationState(
108       PendingActivationStore::kIdentifierICCID,
109       kEntry1,
110       PendingActivationStore::kStateActivated));
111   EXPECT_TRUE(store_.SetActivationState(
112       PendingActivationStore::kIdentifierICCID,
113       kEntry2,
114       PendingActivationStore::kStatePending));
115 
116   EXPECT_EQ(PendingActivationStore::kStateActivated,
117             store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
118                                       kEntry1));
119   EXPECT_EQ(PendingActivationStore::kStatePending,
120             store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
121                                       kEntry2));
122 
123   // Close and reopen the file to verify that the entries persisted.
124   EXPECT_TRUE(store_.InitStorage(temp_dir.path()));
125 
126   EXPECT_EQ(PendingActivationStore::kStateActivated,
127             store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
128                                       kEntry1));
129   EXPECT_EQ(PendingActivationStore::kStatePending,
130             store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
131                                       kEntry2));
132   EXPECT_EQ(PendingActivationStore::kStateActivated,
133             store_.GetActivationState(
134                 PendingActivationStore::kIdentifierMEID, kEntry1));
135 
136   EXPECT_TRUE(store_.RemoveEntry(
137       PendingActivationStore::kIdentifierMEID, kEntry1));
138   EXPECT_TRUE(store_.RemoveEntry(
139       PendingActivationStore::kIdentifierICCID, kEntry2));
140 
141   EXPECT_EQ(PendingActivationStore::kStateUnknown,
142             store_.GetActivationState(
143                 PendingActivationStore::kIdentifierMEID, kEntry1));
144   EXPECT_EQ(PendingActivationStore::kStateUnknown,
145             store_.GetActivationState(
146                 PendingActivationStore::kIdentifierICCID, kEntry2));
147   EXPECT_EQ(PendingActivationStore::kStateActivated,
148             store_.GetActivationState(
149                 PendingActivationStore::kIdentifierICCID, kEntry1));
150 
151   EXPECT_TRUE(store_.RemoveEntry(
152       PendingActivationStore::kIdentifierICCID, kEntry1));
153   EXPECT_TRUE(store_.RemoveEntry(
154       PendingActivationStore::kIdentifierMEID, kEntry2));
155   EXPECT_EQ(PendingActivationStore::kStateUnknown,
156             store_.GetActivationState(
157                 PendingActivationStore::kIdentifierICCID, kEntry1));
158   EXPECT_EQ(PendingActivationStore::kStateUnknown,
159             store_.GetActivationState(
160                 PendingActivationStore::kIdentifierMEID, kEntry2));
161 
162   EXPECT_TRUE(store_.InitStorage(temp_dir.path()));
163 
164   EXPECT_EQ(PendingActivationStore::kStateUnknown,
165             store_.GetActivationState(
166                 PendingActivationStore::kIdentifierMEID, kEntry1));
167   EXPECT_EQ(PendingActivationStore::kStateUnknown,
168             store_.GetActivationState(
169                 PendingActivationStore::kIdentifierICCID, kEntry2));
170   EXPECT_EQ(PendingActivationStore::kStateUnknown,
171             store_.GetActivationState(
172                 PendingActivationStore::kIdentifierICCID, kEntry1));
173   EXPECT_EQ(PendingActivationStore::kStateUnknown,
174             store_.GetActivationState(
175                 PendingActivationStore::kIdentifierMEID, kEntry2));
176 }
177 
TEST_F(PendingActivationStoreTest,GetActivationState)178 TEST_F(PendingActivationStoreTest, GetActivationState) {
179   MockStore* mock_store = mock_store_.get();
180   SetMockStore();
181 
182   const char kEntry[] = "12345689";
183 
184   // Value not found
185   EXPECT_CALL(*mock_store, GetInt(PendingActivationStore::kIccidGroupId,
186                                   kEntry,
187                                   _))
188       .WillOnce(Return(false));
189   EXPECT_EQ(PendingActivationStore::kStateUnknown,
190             store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
191                                       kEntry));
192 
193   // File contains invalid entry
194   EXPECT_CALL(*mock_store,
195               GetInt(PendingActivationStore::kMeidGroupId, kEntry, _))
196       .WillOnce(DoAll(
197           SetArgumentPointee<2>(
198               static_cast<int>(PendingActivationStore::kStateMax)),
199           Return(true)));
200   EXPECT_EQ(PendingActivationStore::kStateUnknown,
201             store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
202                                       kEntry));
203   EXPECT_CALL(*mock_store,
204               GetInt(PendingActivationStore::kMeidGroupId, kEntry, _))
205       .WillOnce(DoAll(SetArgumentPointee<2>(0), Return(true)));
206   EXPECT_EQ(PendingActivationStore::kStateUnknown,
207             store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
208                                       kEntry));
209   Mock::VerifyAndClearExpectations(mock_store);
210 
211   // All enum values
212   EXPECT_CALL(*mock_store,
213               GetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
214       .WillOnce(DoAll(SetArgumentPointee<2>(1), Return(true)));
215   EXPECT_EQ(PendingActivationStore::kStatePending,
216             store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
217                                       kEntry));
218   EXPECT_CALL(*mock_store,
219               GetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
220       .WillOnce(DoAll(SetArgumentPointee<2>(2), Return(true)));
221   EXPECT_EQ(PendingActivationStore::kStateActivated,
222             store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
223                                       kEntry));
224   Mock::VerifyAndClearExpectations(mock_store);
225 }
226 
TEST_F(PendingActivationStoreTest,SetActivationState)227 TEST_F(PendingActivationStoreTest, SetActivationState) {
228   MockStore* mock_store = mock_store_.get();
229   SetMockStore();
230 
231   const char kEntry[] = "12345689";
232 
233   EXPECT_CALL(*mock_store, Flush()).WillRepeatedly(Return(true));
234   EXPECT_CALL(*mock_store,
235               SetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
236       .WillOnce(Return(false));
237   EXPECT_FALSE(store_.SetActivationState(
238       PendingActivationStore::kIdentifierICCID,
239       kEntry,
240       PendingActivationStore::kStateUnknown));
241   EXPECT_FALSE(store_.SetActivationState(
242       PendingActivationStore::kIdentifierICCID,
243       kEntry,
244       PendingActivationStore::kStateUnknown));
245   EXPECT_FALSE(store_.SetActivationState(
246       PendingActivationStore::kIdentifierICCID,
247       kEntry,
248       PendingActivationStore::kStatePending));
249 
250   EXPECT_CALL(*mock_store,
251               SetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
252       .WillRepeatedly(Return(true));
253   EXPECT_FALSE(store_.SetActivationState(
254       PendingActivationStore::kIdentifierICCID,
255       kEntry, static_cast<PendingActivationStore::State>(-1)));
256   EXPECT_FALSE(store_.SetActivationState(
257       PendingActivationStore::kIdentifierICCID,
258       kEntry, PendingActivationStore::kStateMax));
259   EXPECT_FALSE(store_.SetActivationState(
260       PendingActivationStore::kIdentifierICCID,
261       kEntry, PendingActivationStore::kStateUnknown));
262   EXPECT_TRUE(store_.SetActivationState(
263       PendingActivationStore::kIdentifierICCID,
264       kEntry,
265       PendingActivationStore::kStatePending));
266   EXPECT_TRUE(store_.SetActivationState(
267       PendingActivationStore::kIdentifierICCID,
268       kEntry,
269       PendingActivationStore::kStateActivated));
270 }
271 
TEST_F(PendingActivationStoreTest,RemoveEntry)272 TEST_F(PendingActivationStoreTest, RemoveEntry) {
273   MockStore* mock_store = mock_store_.get();
274   SetMockStore();
275 
276   const char kEntry[] = "12345689";
277 
278   EXPECT_CALL(*mock_store, Flush()).WillRepeatedly(Return(true));
279   EXPECT_CALL(*mock_store, DeleteKey(PendingActivationStore::kIccidGroupId,
280                                      kEntry))
281       .WillOnce(Return(false));
282   EXPECT_FALSE(store_.RemoveEntry(PendingActivationStore::kIdentifierICCID,
283                                   kEntry));
284   EXPECT_CALL(*mock_store, DeleteKey(PendingActivationStore::kIccidGroupId,
285                                      kEntry))
286       .WillOnce(Return(true));
287   EXPECT_TRUE(store_.RemoveEntry(PendingActivationStore::kIdentifierICCID,
288                                  kEntry));
289 }
290 
291 }  // namespace shill
292