Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(142)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: goopdate/app_bundle_unittest.cc

Issue 624713003: Keep only base/extractor.[cc|h]. (Closed) Base URL: https://chromium.googlesource.com/external/omaha.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « goopdate/app_bundle_state_stopped.cc ('k') | goopdate/app_command.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2009-2010 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 // ========================================================================
15
16 #include <atlsecurity.h>
17 #include "omaha/base/app_util.h"
18 #include "omaha/base/error.h"
19 #include "omaha/base/reg_key.h"
20 #include "omaha/base/scoped_ptr_address.h"
21 #include "omaha/base/thread_pool.h"
22 #include "omaha/base/utils.h"
23 #include "omaha/common/lang.h"
24 #include "omaha/goopdate/app_bundle_state_busy.h"
25 #include "omaha/goopdate/app_bundle_state_initialized.h"
26 #include "omaha/goopdate/app_bundle_state_paused.h"
27 #include "omaha/goopdate/app_bundle_state_ready.h"
28 #include "omaha/goopdate/app_bundle_state_stopped.h"
29 #include "omaha/goopdate/app_manager.h"
30 #include "omaha/goopdate/model.h"
31 #include "omaha/goopdate/resource_manager.h"
32 #include "omaha/goopdate/worker.h"
33 #include "omaha/goopdate/worker_mock.h"
34 #include "omaha/testing/unit_test.h"
35
36 namespace omaha {
37
38 const int kKnownError = 0x87658765;
39
40 const TCHAR* const kDefaultAppName = _T("Google Application");
41
42 const uint32 kInitialInstallTimeDiff = static_cast<uint32>(-1 * kSecondsPerDay);
43
44 // TODO(omaha): there is a problem with this unit test. The model is built
45 // bottom up. This makes it impossible to set the references to parents. Will
46 // have to fix the code, eventually using Builder DP to create a bunch of
47 // models containing bundles, apps, and such.
48
49
50 // Helper functions.
51 // TODO(omaha): helper functions need to go into their own compilation unit to
52 // avoid dependencies between unit test modules.
53
54 void ValidateFreshInstallDefaultValues(const App& app) {
55 EXPECT_FALSE(::IsEqualGUID(GUID_NULL, app.app_guid()));
56 EXPECT_TRUE(app.language().IsEmpty());
57 EXPECT_TRUE(app.ap().IsEmpty());
58 EXPECT_TRUE(app.tt_token().IsEmpty());
59 EXPECT_TRUE(::IsEqualGUID(GUID_NULL, app.iid()));
60 EXPECT_TRUE(app.brand_code().IsEmpty());
61 EXPECT_TRUE(app.client_id().IsEmpty());
62 EXPECT_TRUE(app.GetExperimentLabels().IsEmpty());
63 EXPECT_TRUE(app.referral_id().IsEmpty());
64 EXPECT_EQ(kInitialInstallTimeDiff, app.install_time_diff_sec());
65 EXPECT_FALSE(app.is_eula_accepted());
66 EXPECT_TRUE(app.display_name().IsEmpty());
67 EXPECT_EQ(BROWSER_UNKNOWN, app.browser_type());
68 EXPECT_TRUE(app.server_install_data_index().IsEmpty());
69 EXPECT_EQ(TRISTATE_NONE, app.usage_stats_enable());
70 EXPECT_TRUE(app.client_install_data().IsEmpty());
71 EXPECT_TRUE(app.server_install_data().IsEmpty());
72 EXPECT_EQ(ACTIVE_UNKNOWN, app.did_run());
73 EXPECT_EQ(0, app.days_since_last_active_ping());
74 EXPECT_EQ(0, app.days_since_last_roll_call());
75
76 EXPECT_TRUE(app.current_version()->version().IsEmpty());
77 EXPECT_TRUE(app.next_version()->version().IsEmpty());
78 // TODO(omaha3): Add all the new values (state_, etc.).
79 }
80
81 void PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(
82 bool is_machine,
83 App* expected_app0,
84 App* expected_app1,
85 App* expected_app2,
86 App* opposite_hive_app1,
87 App* opposite_hive_app2);
88
89 void SetDisplayName(const CString& name, App* app);
90
91 void ValidateExpectedValues(const App& expected, const App& actual) {
92 EXPECT_STREQ(GuidToString(expected.app_guid()),
93 GuidToString(actual.app_guid()));
94 EXPECT_STREQ(expected.language(), actual.language());
95 EXPECT_STREQ(expected.ap(), actual.ap());
96 EXPECT_STREQ(expected.tt_token(), actual.tt_token());
97 EXPECT_STREQ(GuidToString(expected.iid()), GuidToString(actual.iid()));
98 EXPECT_STREQ(expected.brand_code(), actual.brand_code());
99 EXPECT_STREQ(expected.client_id(), actual.client_id());
100 EXPECT_STREQ(expected.GetExperimentLabels(), actual.GetExperimentLabels());
101 EXPECT_STREQ(expected.referral_id(), actual.referral_id());
102 EXPECT_EQ(expected.install_time_diff_sec(), actual.install_time_diff_sec());
103 EXPECT_EQ(expected.is_eula_accepted(), actual.is_eula_accepted());
104 EXPECT_STREQ(expected.display_name(), actual.display_name());
105 EXPECT_EQ(expected.browser_type(), actual.browser_type());
106 EXPECT_STREQ(expected.server_install_data_index(),
107 actual.server_install_data_index());
108 EXPECT_EQ(expected.usage_stats_enable(), actual.usage_stats_enable());
109 EXPECT_STREQ(expected.client_install_data(), actual.client_install_data());
110 EXPECT_STREQ(expected.server_install_data(), actual.server_install_data());
111 EXPECT_EQ(expected.did_run(), actual.did_run());
112
113 EXPECT_STREQ(expected.current_version()->version(),
114 actual.current_version()->version());
115 EXPECT_STREQ(expected.next_version()->version(),
116 actual.next_version()->version());
117
118 // TODO(omaha3): Add all the new values (state(), etc.)?
119 }
120
121 using ::testing::_;
122 using ::testing::Return;
123
124 namespace {
125
126 // TODO(omaha): At least some of these and where they are used have to be kept
127 // in sync with app_manager_unittest.cc because the constants are hard-coded in
128 // functions used by these tests. Break this coupling.
129 const TCHAR* const kGuid1 = _T("{21CD0965-0B0E-47cf-B421-2D191C16C0E2}");
130 const TCHAR* const kGuid2 = _T("{A979ACBD-1F55-4b12-A35F-4DBCA5A7CCB8}");
131 const TCHAR* const kGuid3 = _T("{661045C5-4429-4140-BC48-8CEA241D1DEF}");
132 const TCHAR* const kGuid4 = _T("{AAFA1CF9-E94F-42e6-A899-4CD27F37D5A7}");
133 const TCHAR* const kGuid5 = _T("{3B1A3CCA-0525-4418-93E6-A0DB3398EC9B}");
134 const TCHAR* const kGuid6 = _T("{F3F2CFD4-5F98-4bf0-ABB0-BEEEA46C62B4}");
135 const TCHAR* const kGuid7 = _T("{6FD2272F-8583-4bbd-895A-E65F8003FC7B}");
136
137
138 class DummyUserWorkItem : public UserWorkItem {
139 private:
140 virtual void DoProcess() {}
141 };
142
143 ACTION_P(SetWorkItem, work_item) {
144 UNREFERENCED_ACTION_PARAMETERS;
145 arg0->set_user_work_item(work_item);
146 return 0;
147 }
148
149 } // namespace
150
151 class AppBundleNoBundleTest : public testing::Test {
152 protected:
153 explicit AppBundleNoBundleTest(bool is_machine)
154 : is_machine_(is_machine) {}
155
156 virtual void SetUp() {
157 EXPECT_SUCCEEDED(AppManager::CreateInstance(is_machine_));
158
159 // By default, no Worker methods should be called, so use StrictMock.
160 // Override this behavior for specific methods in the individual test cases.
161 worker_.reset(new testing::StrictMock<MockWorker>);
162 model_.reset(new Model(worker_.get()));
163
164 EXPECT_CALL(*worker_, Lock()).WillRepeatedly(Return(2));
165 EXPECT_CALL(*worker_, Unlock()).WillRepeatedly(Return(1));
166 }
167
168 virtual void TearDown() {
169 AppManager::DeleteInstance();
170 }
171
172 const bool is_machine_;
173 scoped_ptr<MockWorker> worker_;
174 scoped_ptr<Model> model_;
175
176 private:
177 DISALLOW_IMPLICIT_CONSTRUCTORS(AppBundleNoBundleTest);
178 };
179
180 class AppBundleTest : public AppBundleNoBundleTest {
181 protected:
182 explicit AppBundleTest(bool is_machine) : AppBundleNoBundleTest(is_machine) {}
183
184 static void SetUpTestCase() {
185 EXPECT_EQ(STATE_INIT, fsm::AppBundleState::STATE_INIT);
186 EXPECT_EQ(STATE_INITIALIZED, fsm::AppBundleState::STATE_INITIALIZED);
187 EXPECT_EQ(STATE_BUSY, fsm::AppBundleState::STATE_BUSY);
188 EXPECT_EQ(STATE_READY, fsm::AppBundleState::STATE_READY);
189 EXPECT_EQ(STATE_PAUSED, fsm::AppBundleState::STATE_PAUSED);
190 EXPECT_EQ(STATE_STOPPED, fsm::AppBundleState::STATE_STOPPED);
191 }
192
193 virtual void SetUp() {
194 AppBundleNoBundleTest::SetUp();
195 app_bundle_ = model_->CreateAppBundle(is_machine_);
196 ASSERT_TRUE(app_bundle_.get());
197 }
198
199 virtual void TearDown() {
200 app_bundle_.reset();
201 AppBundleNoBundleTest::TearDown();
202 }
203
204 void TestPropertyReflexiveness() {
205 EXPECT_SUCCEEDED(app_bundle_->put_displayName(CComBSTR(_T("My Apps"))));
206 CComBSTR name(_T(""));
207 EXPECT_SUCCEEDED(app_bundle_->get_displayName(&name));
208 EXPECT_STREQ(_T("My Apps"), name);
209
210 EXPECT_SUCCEEDED(app_bundle_->put_displayLanguage(CComBSTR(_T("en"))));
211 CComBSTR lang(_T(""));
212 EXPECT_SUCCEEDED(app_bundle_->get_displayLanguage(&lang));
213 EXPECT_STREQ(_T("en"), lang);
214
215 EXPECT_SUCCEEDED(app_bundle_->put_installSource(CComBSTR(_T("unittest"))));
216 CComBSTR source(_T(""));
217 EXPECT_SUCCEEDED(app_bundle_->get_installSource(&source));
218 EXPECT_STREQ(_T("unittest"), source);
219
220 EXPECT_SUCCEEDED(app_bundle_->put_priority(INSTALL_PRIORITY_LOW));
221 long priority = INSTALL_PRIORITY_HIGH; // NOLINT
222 EXPECT_SUCCEEDED(app_bundle_->get_priority(&priority));
223 EXPECT_EQ(INSTALL_PRIORITY_LOW, priority);
224 }
225
226 // A copy of the protected enum in AppBundleState, allowing the individual
227 // tests to use these values.
228 enum BundleState {
229 STATE_INIT,
230 STATE_INITIALIZED,
231 STATE_BUSY,
232 STATE_READY,
233 STATE_PAUSED,
234 STATE_STOPPED,
235 };
236
237 BundleState GetBundleState() {
238 return static_cast<BundleState>(app_bundle_->app_bundle_state_->state_);
239 }
240
241 shared_ptr<AppBundle> app_bundle_;
242
243 private:
244 DISALLOW_IMPLICIT_CONSTRUCTORS(AppBundleTest);
245 };
246
247 class AppBundleUninitializedTest : public AppBundleTest {
248 protected:
249 explicit AppBundleUninitializedTest(bool is_machine)
250 : AppBundleTest(is_machine) {}
251
252 void TestPropertyDefaults() {
253 CComBSTR name;
254 EXPECT_SUCCEEDED(app_bundle_->get_displayName(&name));
255 EXPECT_STREQ(_T(""), name);
256
257 CComBSTR lang;
258 EXPECT_SUCCEEDED(app_bundle_->get_displayLanguage(&lang));
259 EXPECT_STREQ(lang::GetDefaultLanguage(is_machine_), lang);
260
261 CComBSTR install_source;
262 EXPECT_SUCCEEDED(app_bundle_->get_installSource(&install_source));
263 EXPECT_STREQ(_T("unknown"), install_source);
264
265 CComBSTR offline_dir;
266 EXPECT_SUCCEEDED(app_bundle_->get_offlineDirectory(&offline_dir));
267 EXPECT_STREQ(_T(""), offline_dir);
268
269 long priority; // NOLINT
270 EXPECT_SUCCEEDED(app_bundle_->get_priority(&priority));
271 EXPECT_EQ(INSTALL_PRIORITY_HIGH, priority);
272 }
273 };
274
275 class AppBundleUninitializedMachineTest : public AppBundleUninitializedTest {
276 protected:
277 AppBundleUninitializedMachineTest() : AppBundleUninitializedTest(true) {}
278 };
279
280 class AppBundleUninitializedUserTest : public AppBundleUninitializedTest {
281 protected:
282 AppBundleUninitializedUserTest() : AppBundleUninitializedTest(false) {}
283 };
284
285 TEST_F(AppBundleUninitializedMachineTest, Properties) {
286 TestPropertyDefaults();
287 TestPropertyReflexiveness();
288 }
289
290 TEST_F(AppBundleUninitializedUserTest, Properties) {
291 TestPropertyDefaults();
292 TestPropertyReflexiveness();
293 }
294
295 class AppBundleInitializedTest : public AppBundleTest {
296 protected:
297 explicit AppBundleInitializedTest(bool is_machine)
298 : AppBundleTest(is_machine) {}
299
300 virtual void SetUp() {
301 AppBundleTest::SetUp();
302 // TODO(omaha): UserRights::GetCallerToken() fails with ERROR_NO_TOKEN
303 // when initialize() is called for a machine bundle during these tests.
304 // It might make sense to move theimpersonation stuff to the COM wrapper,
305 // but I am not sure how this would work with the AppBundleStates.
306 // If we can do something about this, call initialize() in all cases.
307 if (is_machine_) {
308 SetAppBundleStateForUnitTest(app_bundle_.get(),
309 new fsm::AppBundleStateInitialized);
310 } else {
311 EXPECT_SUCCEEDED(app_bundle_->put_displayName(CComBSTR(_T("My Bundle"))));
312 EXPECT_SUCCEEDED(app_bundle_->put_displayLanguage(CComBSTR(_T("en"))));
313 EXPECT_SUCCEEDED(app_bundle_->initialize());
314 }
315 }
316 };
317
318 class AppBundleNoBundleMachineTest : public AppBundleNoBundleTest {
319 protected:
320 AppBundleNoBundleMachineTest() : AppBundleNoBundleTest(true) {}
321 };
322
323 class AppBundleNoBundleUserTest : public AppBundleNoBundleTest {
324 protected:
325 AppBundleNoBundleUserTest() : AppBundleNoBundleTest(false) {}
326 };
327
328 class AppBundleInitializedMachineTest : public AppBundleInitializedTest {
329 protected:
330 AppBundleInitializedMachineTest() : AppBundleInitializedTest(true) {}
331 };
332
333 class AppBundleInitializedUserTest : public AppBundleInitializedTest {
334 protected:
335 AppBundleInitializedUserTest() : AppBundleInitializedTest(false) {}
336 };
337
338
339 // The creation of an app bundle inserts it in the model and increments
340 // the server module count.
341 TEST_F(AppBundleNoBundleUserTest, ConstructorAndDestructor) {
342 EXPECT_CALL(*worker_, Lock()).WillOnce(Return(2));
343 EXPECT_CALL(*worker_, Unlock()).WillOnce(Return(1));
344
345 shared_ptr<AppBundle> app_bundle(model_->CreateAppBundle(is_machine_));
346 EXPECT_TRUE(app_bundle.get());
347 EXPECT_EQ(1, model_->GetNumberOfAppBundles());
348 EXPECT_EQ(app_bundle.get(), model_->GetAppBundle(0).get());
349 app_bundle.reset();
350 EXPECT_EQ(0, model_->GetNumberOfAppBundles());
351 }
352
353 TEST_F(AppBundleNoBundleMachineTest, ConstructorAndDestructor) {
354 EXPECT_CALL(*worker_, Lock()).WillOnce(Return(2));
355 EXPECT_CALL(*worker_, Unlock()).WillOnce(Return(1));
356
357 shared_ptr<AppBundle> app_bundle(model_->CreateAppBundle(is_machine_));
358 EXPECT_TRUE(app_bundle.get());
359 EXPECT_EQ(1, model_->GetNumberOfAppBundles());
360 EXPECT_EQ(app_bundle.get(), model_->GetAppBundle(0).get());
361 app_bundle.reset();
362 EXPECT_EQ(0, model_->GetNumberOfAppBundles());
363 }
364
365 class AppBundlePopulatedRegistryTest : public AppBundleInitializedTest {
366 protected:
367 explicit AppBundlePopulatedRegistryTest(bool is_machine)
368 : AppBundleInitializedTest(is_machine),
369 hive_override_key_name_(kRegistryHiveOverrideRoot) {}
370
371 virtual void SetUp() {
372 AppBundleInitializedTest::SetUp();
373
374 RegKey::DeleteKey(hive_override_key_name_);
375 OverrideRegistryHives(hive_override_key_name_);
376
377 EXPECT_SUCCEEDED(ResourceManager::Create(
378 is_machine_, app_util::GetCurrentModuleDirectory(), _T("en")));
379
380 dummy_app_bundle_for_expected_apps_ = model_->CreateAppBundle(is_machine_);
381 ASSERT_TRUE(dummy_app_bundle_for_expected_apps_.get());
382 // TODO(omaha): Address with the TODO in AppBundleInitializedTest::SetUp.
383 if (is_machine_) {
384 SetAppBundleStateForUnitTest(dummy_app_bundle_for_expected_apps_.get(),
385 new fsm::AppBundleStateInitialized);
386 } else {
387 EXPECT_SUCCEEDED(dummy_app_bundle_for_expected_apps_->put_displayName(
388 CComBSTR(_T("My Bundle"))));
389 EXPECT_SUCCEEDED(dummy_app_bundle_for_expected_apps_->put_displayLanguage(
390 CComBSTR(_T("en"))));
391 EXPECT_SUCCEEDED(dummy_app_bundle_for_expected_apps_->initialize());
392 }
393 }
394
395 virtual void TearDown() {
396 dummy_app_bundle_for_expected_apps_.reset();
397
398 ResourceManager::Delete();
399
400 RestoreRegistryHives();
401 RegKey::DeleteKey(hive_override_key_name_);
402
403 AppBundleInitializedTest::TearDown();
404 }
405
406 // App will be cleaned up when bundle is destroyed.
407 // This is a hack for creating registry data. Would be nice to have a
408 // different mechanism.
409 App* CreateExpectedApp(const TCHAR* app_id) {
410 App* app = NULL;
411 EXPECT_SUCCEEDED(
412 dummy_app_bundle_for_expected_apps_->createApp(CComBSTR(app_id), &app));
413 ASSERT1(app);
414 return app;
415 }
416
417 void PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(
418 App** expected_app0,
419 App** expected_app1,
420 App** expected_app2) {
421 *expected_app0 = CreateExpectedApp(kGuid1);
422 *expected_app1 = CreateExpectedApp(kGuid2);
423 *expected_app2 = CreateExpectedApp(kGuid3);
424 App* opposite_hive_app1 = CreateExpectedApp(kGuid6);
425 App* opposite_hive_app2 = CreateExpectedApp(kGuid7);
426 omaha::PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(
427 is_machine_,
428 *expected_app0,
429 *expected_app1,
430 *expected_app2,
431 opposite_hive_app1,
432 opposite_hive_app2);
433
434 // Reload install age since registry has been changed.
435 AppManager::Instance()->ReadAppInstallTimeDiff(*expected_app0);
436 AppManager::Instance()->ReadAppInstallTimeDiff(*expected_app1);
437 AppManager::Instance()->ReadAppInstallTimeDiff(*expected_app2);
438 AppManager::Instance()->ReadAppInstallTimeDiff(opposite_hive_app1);
439 AppManager::Instance()->ReadAppInstallTimeDiff(opposite_hive_app2);
440 }
441
442 CString hive_override_key_name_;
443 shared_ptr<AppBundle> dummy_app_bundle_for_expected_apps_;
444 LLock lock_;
445
446 DISALLOW_IMPLICIT_CONSTRUCTORS(AppBundlePopulatedRegistryTest);
447 };
448
449 class AppBundlePopulatedRegistryMachineTest
450 : public AppBundlePopulatedRegistryTest {
451 protected:
452 AppBundlePopulatedRegistryMachineTest()
453 : AppBundlePopulatedRegistryTest(true) {}
454 };
455
456 class AppBundlePopulatedRegistryUserTest
457 : public AppBundlePopulatedRegistryTest {
458 protected:
459 AppBundlePopulatedRegistryUserTest()
460 : AppBundlePopulatedRegistryTest(false) {}
461 };
462
463 TEST_F(AppBundleInitializedUserTest, CountAndItem_NoApps) {
464 EXPECT_EQ(0, app_bundle_->GetNumberOfApps());
465 long num_apps = 0; // NOLINT
466 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
467 EXPECT_EQ(0, num_apps);
468
469 {
470 ExpectAsserts expect_asserts;
471 EXPECT_FALSE(app_bundle_->GetApp(0));
472 }
473 App* app0_obtained = NULL;
474 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
475 app_bundle_->get_Item(0, &app0_obtained));
476 EXPECT_FALSE(app0_obtained);
477
478 {
479 ExpectAsserts expect_asserts;
480 EXPECT_FALSE(app_bundle_->GetApp(1));
481 }
482 App* app1_obtained = NULL;
483 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
484 app_bundle_->get_Item(1, &app1_obtained));
485 EXPECT_FALSE(app1_obtained);
486 }
487
488 TEST_F(AppBundleInitializedUserTest, CountAndItem_OneApp) {
489 App* app0_created = NULL;
490 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
491
492 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
493 long num_apps = 0; // NOLINT
494 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
495 EXPECT_EQ(1, num_apps);
496
497 EXPECT_TRUE(app_bundle_->GetApp(0));
498 App* app0_obtained = NULL;
499 EXPECT_SUCCEEDED(app_bundle_->get_Item(0, &app0_obtained));
500 EXPECT_TRUE(app0_obtained);
501
502 {
503 ExpectAsserts expect_asserts;
504 EXPECT_FALSE(app_bundle_->GetApp(1));
505 }
506 App* app1_obtained = NULL;
507 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
508 app_bundle_->get_Item(1, &app1_obtained));
509 EXPECT_FALSE(app1_obtained);
510 }
511
512 TEST_F(AppBundleInitializedUserTest, CountAndItem_TwoApp) {
513 App* app0_created = NULL;
514 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
515 App* app1_created = NULL;
516 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid2), &app1_created));
517
518 EXPECT_EQ(2, app_bundle_->GetNumberOfApps());
519 long num_apps = 0; // NOLINT
520 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
521 EXPECT_EQ(2, num_apps);
522
523 EXPECT_TRUE(app_bundle_->GetApp(0));
524 App* app0_obtained = NULL;
525 EXPECT_SUCCEEDED(app_bundle_->get_Item(0, &app0_obtained));
526 EXPECT_TRUE(app0_obtained);
527 EXPECT_EQ(app0_created, app0_obtained);
528
529 EXPECT_TRUE(app_bundle_->GetApp(1));
530 App* app1_obtained = NULL;
531 EXPECT_SUCCEEDED(app_bundle_->get_Item(1, &app1_obtained));
532 EXPECT_TRUE(app1_obtained);
533
534 {
535 ExpectAsserts expect_asserts;
536 EXPECT_FALSE(app_bundle_->GetApp(2));
537 }
538 App* app2_obtained = NULL;
539 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
540 app_bundle_->get_Item(2, &app2_obtained));
541 EXPECT_FALSE(app2_obtained);
542 }
543
544 TEST_F(AppBundleInitializedUserTest, createApp) {
545 App* app0_created = NULL;
546 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
547 EXPECT_TRUE(app0_created);
548 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
549
550 App* app0 = app_bundle_->GetApp(0);
551 EXPECT_EQ(app0_created, app0);
552
553 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
554 ValidateFreshInstallDefaultValues(*app0);
555 }
556
557 TEST_F(AppBundleInitializedUserTest, createApp_TwoApps) {
558 App* app0_created = NULL;
559 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
560 EXPECT_TRUE(app0_created);
561 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
562
563 App* app0 = app_bundle_->GetApp(0);
564 EXPECT_EQ(app0_created, app0);
565
566 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
567 ValidateFreshInstallDefaultValues(*app0);
568
569 // Add a second app to the bundle.
570
571 App* app1_created = NULL;
572 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid2), &app1_created));
573 EXPECT_TRUE(app1_created);
574 EXPECT_EQ(2, app_bundle_->GetNumberOfApps());
575
576 App* app1 = app_bundle_->GetApp(1);
577 EXPECT_EQ(app1_created, app1);
578
579 EXPECT_STREQ(CString(kGuid2).MakeUpper(), app1->app_guid_string());
580 ValidateFreshInstallDefaultValues(*app1);
581 }
582
583 TEST_F(AppBundleInitializedUserTest, createApp_SameAppTwice) {
584 App* app0_created = NULL;
585 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
586 EXPECT_TRUE(app0_created);
587 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
588
589 App* app0 = app_bundle_->GetApp(0);
590 EXPECT_EQ(app0_created, app0);
591
592 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
593 ValidateFreshInstallDefaultValues(*app0);
594
595 // Attempt to add the same app to the bundle again.
596
597 App* app1_created = NULL;
598 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
599 app_bundle_->createApp(CComBSTR(kGuid1), &app1_created));
600 EXPECT_FALSE(app1_created);
601 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
602 }
603
604 TEST_F(AppBundleInitializedUserTest, createApp_AfterUpdateCheck) {
605 DummyUserWorkItem dummy_work_item;
606 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
607 .WillOnce(SetWorkItem(&dummy_work_item));
608
609 App* app0_created = NULL;
610 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
611 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
612
613 App* app1_created = NULL;
614 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
615 app_bundle_->createApp(CComBSTR(kGuid2), &app1_created));
616
617 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
618 }
619
620 TEST_F(AppBundleInitializedMachineTest, createApp) {
621 App* app0_created = NULL;
622 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
623 EXPECT_TRUE(app0_created);
624 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
625
626 App* app0 = app_bundle_->GetApp(0);
627 EXPECT_EQ(app0_created, app0);
628
629 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
630 ValidateFreshInstallDefaultValues(*app0);
631 }
632
633 TEST_F(AppBundleInitializedUserTest, checkForUpdate_NoApps) {
634 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
635 }
636
637 // Does not verify the update check occurs.
638 TEST_F(AppBundleInitializedUserTest, checkForUpdate_OneApp) {
639 DummyUserWorkItem dummy_work_item;
640 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
641 .WillOnce(SetWorkItem(&dummy_work_item));
642
643 App* app = NULL;
644 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
645
646 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
647
648 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
649 }
650
651 // Does not verify the update check occurs.
652 TEST_F(AppBundleInitializedUserTest, checkForUpdate_TwoApps) {
653 DummyUserWorkItem dummy_work_item;
654 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
655 .WillOnce(SetWorkItem(&dummy_work_item));
656
657 App* app0 = NULL;
658 App* app1 = NULL;
659 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0));
660 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid2), &app1));
661
662 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
663
664 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
665 }
666
667 TEST_F(AppBundleInitializedUserTest, checkForUpdate_Twice) {
668 DummyUserWorkItem dummy_work_item;
669 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
670 .WillOnce(SetWorkItem(&dummy_work_item));
671
672 App* app = NULL;
673 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
674
675 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
676 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
677
678 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
679 }
680
681 TEST_F(AppBundleInitializedUserTest, checkForUpdate_WhileBundleIsBusy) {
682 DummyUserWorkItem dummy_work_item;
683 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
684 .WillOnce(SetWorkItem(&dummy_work_item));
685
686 App* app = NULL;
687 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
688
689 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
690 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
691
692 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
693 }
694
695 // Does not verify the update check occurs.
696 TEST_F(AppBundleInitializedMachineTest, checkForUpdate_OneApp) {
697 DummyUserWorkItem dummy_work_item;
698 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
699 .WillOnce(SetWorkItem(&dummy_work_item));
700
701 App* app = NULL;
702 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
703
704 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
705
706 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
707 }
708
709 TEST_F(AppBundleInitializedUserTest, download_WithoutUpdateCheck) {
710 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->download());
711 }
712
713 // The AppBundle does not prevent this, but the apps may enter the error state.
714 TEST_F(AppBundleInitializedUserTest, download_AfterInstall) {
715 DummyUserWorkItem dummy_work_item;
716 {
717 ::testing::InSequence dummy;
718 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
719 .WillOnce(SetWorkItem(&dummy_work_item));
720 EXPECT_CALL(*worker_, DownloadAndInstallAsync(_))
721 .WillOnce(SetWorkItem(&dummy_work_item));
722 EXPECT_CALL(*worker_, DownloadAsync(_))
723 .WillOnce(SetWorkItem(&dummy_work_item));
724 }
725
726 App* app = NULL;
727 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
728
729 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
730 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
731 EXPECT_SUCCEEDED(app_bundle_->install());
732 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
733
734 EXPECT_SUCCEEDED(app_bundle_->download());
735
736 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
737 }
738
739 // The AppBundle does not prevent this, but the apps may enter the error state.
740 TEST_F(AppBundleInitializedUserTest, download_Twice) {
741 DummyUserWorkItem dummy_work_item;
742 {
743 ::testing::InSequence dummy;
744 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
745 .WillOnce(SetWorkItem(&dummy_work_item));
746 EXPECT_CALL(*worker_, DownloadAsync(_))
747 .Times(2)
748 .WillRepeatedly(SetWorkItem(&dummy_work_item));
749 }
750
751 App* app = NULL;
752 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
753
754 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
755 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
756 EXPECT_SUCCEEDED(app_bundle_->download());
757 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
758
759 EXPECT_SUCCEEDED(app_bundle_->download());
760
761 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
762 }
763
764 // Simulates the update check still in progress when download() is called.
765 TEST_F(AppBundleInitializedUserTest, download_WhileBundleIsBusy) {
766 DummyUserWorkItem dummy_work_item;
767 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
768 .WillOnce(SetWorkItem(&dummy_work_item));
769
770 App* app = NULL;
771 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
772
773 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
774
775 EXPECT_EQ(GOOPDATE_E_NON_BLOCKING_CALL_PENDING, app_bundle_->download());
776
777 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
778 }
779
780 // The AppBundle does not prevent this, but the apps may enter the error state.
781 TEST_F(AppBundleInitializedMachineTest, download_Twice) {
782 DummyUserWorkItem dummy_work_item;
783 {
784 ::testing::InSequence dummy;
785 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
786 .WillOnce(SetWorkItem(&dummy_work_item));
787 EXPECT_CALL(*worker_, DownloadAsync(_))
788 .Times(2)
789 .WillRepeatedly(SetWorkItem(&dummy_work_item));
790 }
791
792 App* app = NULL;
793 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
794
795 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
796 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
797 EXPECT_SUCCEEDED(app_bundle_->download());
798 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
799
800 EXPECT_SUCCEEDED(app_bundle_->download());
801
802 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
803 }
804
805 TEST_F(AppBundleInitializedUserTest, install_WithoutUpdateCheck) {
806 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->install());
807 }
808
809 TEST_F(AppBundleInitializedUserTest, install_WithoutDownload) {
810 DummyUserWorkItem dummy_work_item;
811 {
812 ::testing::InSequence dummy;
813 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
814 .WillOnce(SetWorkItem(&dummy_work_item));
815 EXPECT_CALL(*worker_, DownloadAndInstallAsync(_))
816 .WillOnce(SetWorkItem(&dummy_work_item));
817 }
818
819 App* app = NULL;
820 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
821
822 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
823 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
824
825 EXPECT_SUCCEEDED(app_bundle_->install());
826
827 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
828 }
829
830 TEST_F(AppBundleInitializedUserTest, install_AfterDownload) {
831 DummyUserWorkItem dummy_work_item;
832 {
833 ::testing::InSequence dummy;
834 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
835 .WillOnce(SetWorkItem(&dummy_work_item));
836 EXPECT_CALL(*worker_, DownloadAsync(_))
837 .WillOnce(SetWorkItem(&dummy_work_item));
838 EXPECT_CALL(*worker_, DownloadAndInstallAsync(_))
839 .WillOnce(SetWorkItem(&dummy_work_item));
840 }
841
842 App* app = NULL;
843 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
844
845 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
846 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
847 EXPECT_SUCCEEDED(app_bundle_->download());
848 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
849
850 EXPECT_SUCCEEDED(app_bundle_->install());
851
852 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
853 }
854
855 // The AppBundle does not prevent this, but the apps may enter the error state.
856 TEST_F(AppBundleInitializedUserTest, install_Twice) {
857 DummyUserWorkItem dummy_work_item;
858 {
859 ::testing::InSequence dummy;
860 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
861 .WillOnce(SetWorkItem(&dummy_work_item));
862 EXPECT_CALL(*worker_, DownloadAndInstallAsync(_))
863 .Times(2)
864 .WillRepeatedly(SetWorkItem(&dummy_work_item));
865 }
866
867 App* app = NULL;
868 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
869
870 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
871 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
872 EXPECT_SUCCEEDED(app_bundle_->install());
873 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
874
875 EXPECT_SUCCEEDED(app_bundle_->install());
876
877 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
878 }
879
880 // TODO(omaha): These tests are disabled because CaptureCallerPrimaryToken()
881 // fails. We could move this to AppBundleWrapper, but we would need to expose
882 // some functions to AppBundleWrapper.
883 TEST_F(AppBundleInitializedMachineTest, DISABLED_install_WithoutDownload) {
884 DummyUserWorkItem dummy_work_item;
885 {
886 ::testing::InSequence dummy;
887 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
888 .WillOnce(SetWorkItem(&dummy_work_item));
889 EXPECT_CALL(*worker_, DownloadAndInstallAsync(_))
890 .WillOnce(SetWorkItem(&dummy_work_item));
891 }
892
893 App* app = NULL;
894 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
895
896 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
897 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
898
899 EXPECT_SUCCEEDED(app_bundle_->install());
900
901 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
902 }
903
904 TEST_F(AppBundleInitializedMachineTest, DISABLED_install_AfterDownload) {
905 DummyUserWorkItem dummy_work_item;
906 {
907 ::testing::InSequence dummy;
908 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
909 .WillOnce(SetWorkItem(&dummy_work_item));
910 EXPECT_CALL(*worker_, DownloadAsync(_))
911 .WillOnce(SetWorkItem(&dummy_work_item));
912 EXPECT_CALL(*worker_, DownloadAndInstallAsync(_))
913 .WillOnce(SetWorkItem(&dummy_work_item));
914 }
915
916 App* app = NULL;
917 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
918
919 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
920 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
921 EXPECT_SUCCEEDED(app_bundle_->download());
922 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
923
924 EXPECT_SUCCEEDED(app_bundle_->install());
925
926 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
927 }
928
929 // Simulates the update check still in progress when install is called.
930 TEST_F(AppBundleInitializedUserTest, install_WhileBundleIsBusy) {
931 DummyUserWorkItem dummy_work_item;
932 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
933 .WillOnce(SetWorkItem(&dummy_work_item));
934
935 App* app = NULL;
936 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
937
938 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
939 EXPECT_EQ(GOOPDATE_E_NON_BLOCKING_CALL_PENDING, app_bundle_->install());
940
941 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
942 }
943
944 // Also tests adding another app via the same method.
945 TEST_F(AppBundlePopulatedRegistryUserTest, createInstalledApp_Present_TwoApps) {
946 App *expected_app0, *expected_app1, *expected_app2;
947 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
948 &expected_app1,
949 &expected_app2);
950
951 App* app0_created = NULL;
952 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1),
953 &app0_created));
954 EXPECT_TRUE(app0_created);
955 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
956
957 App* app0 = app_bundle_->GetApp(0);
958 EXPECT_EQ(app0_created, app0);
959 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
960 EXPECT_SUCCEEDED(expected_app0->put_isEulaAccepted(VARIANT_TRUE));
961 ValidateExpectedValues(*expected_app0, *app0);
962
963 // Add a second app to the bundle.
964
965 App* app1_created = NULL;
966 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid2),
967 &app1_created));
968 EXPECT_TRUE(app1_created);
969 EXPECT_EQ(2, app_bundle_->GetNumberOfApps());
970
971 long num_apps = 0; // NOLINT
972 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
973 EXPECT_EQ(2, num_apps);
974
975 App* app1 = app_bundle_->GetApp(1);
976 EXPECT_EQ(app1_created, app1);
977 EXPECT_STREQ(CString(kGuid2).MakeUpper(), app1->app_guid_string());
978 SetDisplayName(kDefaultAppName, expected_app1);
979 EXPECT_SUCCEEDED(expected_app1->put_isEulaAccepted(VARIANT_TRUE));
980 ValidateExpectedValues(*expected_app1, *app1);
981
982 // Verify COM methods return the same values as the C++ methods used above.
983 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
984 EXPECT_EQ(2, num_apps);
985 App* app0_obtained = NULL;
986 EXPECT_SUCCEEDED(app_bundle_->get_Item(0, &app0_obtained));
987 EXPECT_EQ(app0, app0_obtained);
988 App* app1_obtained = NULL;
989 EXPECT_SUCCEEDED(app_bundle_->get_Item(1, &app1_obtained));
990 EXPECT_EQ(app1, app1_obtained);
991 }
992
993 TEST_F(AppBundlePopulatedRegistryMachineTest, createInstalledApp_Present) {
994 App *expected_app0, *expected_app1, *expected_app2;
995 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
996 &expected_app1,
997 &expected_app2);
998
999 App* app0_created = NULL;
1000 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1),
1001 &app0_created));
1002 EXPECT_TRUE(app0_created);
1003 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
1004
1005 App* app0 = app_bundle_->GetApp(0);
1006 EXPECT_EQ(app0_created, app0);
1007 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
1008 EXPECT_SUCCEEDED(expected_app0->put_isEulaAccepted(VARIANT_TRUE));
1009 ValidateExpectedValues(*expected_app0, *app0);
1010
1011 long num_apps = 0; // NOLINT
1012 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
1013 EXPECT_EQ(1, num_apps);
1014 }
1015
1016 // TODO(omaha3): Test that the same app can be added to different bundles for
1017 // each of the create methods.
1018 TEST_F(AppBundlePopulatedRegistryUserTest, createInstalledApp_SameAppTwice) {
1019 App *expected_app0, *expected_app1, *expected_app2;
1020 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1021 &expected_app1,
1022 &expected_app2);
1023
1024 App* app0_created = NULL;
1025 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1),
1026 &app0_created));
1027 EXPECT_TRUE(app0_created);
1028 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
1029
1030 App* app0 = app_bundle_->GetApp(0);
1031 EXPECT_EQ(app0_created, app0);
1032 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
1033 EXPECT_SUCCEEDED(expected_app0->put_isEulaAccepted(VARIANT_TRUE));
1034 ValidateExpectedValues(*expected_app0, *app0);
1035
1036 // Attempt to add the same app to the bundle again.
1037
1038 App* app1_created = NULL;
1039 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1040 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app1_created));
1041 EXPECT_FALSE(app1_created);
1042 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
1043 }
1044
1045 TEST_F(AppBundlePopulatedRegistryUserTest, createInstalledApp_NotPresent) {
1046 App *expected_app0, *expected_app1, *expected_app2;
1047 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1048 &expected_app1,
1049 &expected_app2);
1050
1051 App* app0_created = NULL;
1052 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1053 app_bundle_->createInstalledApp(
1054 CComBSTR(_T("{2D5F8E16-B56B-496a-BA8B-3A0B5EC17F4F}")),
1055 &app0_created));
1056 EXPECT_FALSE(app0_created);
1057 EXPECT_EQ(0, app_bundle_->GetNumberOfApps());
1058 }
1059
1060 TEST_F(AppBundlePopulatedRegistryUserTest,
1061 createInstalledApp_NoAppsRegistered) {
1062 App* app0_created = NULL;
1063 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1064 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app0_created));
1065 EXPECT_FALSE(app0_created);
1066 EXPECT_EQ(0, app_bundle_->GetNumberOfApps());
1067 }
1068
1069 TEST_F(AppBundlePopulatedRegistryUserTest,
1070 createInstalledApp_AfterUpdateCheck) {
1071 App *expected_app0, *expected_app1, *expected_app2;
1072 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1073 &expected_app1,
1074 &expected_app2);
1075
1076 DummyUserWorkItem dummy_work_item;
1077 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
1078 .WillOnce(SetWorkItem(&dummy_work_item));
1079
1080 App* app0_created = NULL;
1081 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1),
1082 &app0_created));
1083
1084 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
1085 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
1086
1087 App* app1_created = NULL;
1088 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1089 app_bundle_->createInstalledApp(CComBSTR(kGuid2), &app1_created));
1090 }
1091
1092 TEST_F(AppBundlePopulatedRegistryUserTest, createAllInstalledApps) {
1093 App *expected_app0, *expected_app1, *expected_app2;
1094 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1095 &expected_app1,
1096 &expected_app2);
1097 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1098 AppendRegKeyPath(USER_REG_CLIENT_STATE, kGuid4))); // Avoid assert.
1099
1100 // See comment in machine createAllInstalledApps test.
1101 const CString incomplete_clients_key =
1102 AppendRegKeyPath(USER_REG_CLIENTS, kGuid4);
1103 EXPECT_TRUE(RegKey::HasKey(incomplete_clients_key));
1104 EXPECT_FALSE(RegKey::HasValue(incomplete_clients_key,
1105 kRegValueProductVersion));
1106
1107 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1108 EXPECT_EQ(2, app_bundle_->GetNumberOfApps());
1109
1110 App* app0 = app_bundle_->GetApp(0);
1111 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
1112 EXPECT_SUCCEEDED(expected_app0->put_isEulaAccepted(VARIANT_TRUE));
1113 ValidateExpectedValues(*expected_app0, *app0);
1114
1115 App* app1 = app_bundle_->GetApp(1);
1116 EXPECT_STREQ(CString(kGuid2).MakeUpper(), app1->app_guid_string());
1117 SetDisplayName(kDefaultAppName, expected_app1);
1118 EXPECT_SUCCEEDED(expected_app1->put_isEulaAccepted(VARIANT_TRUE));
1119 ValidateExpectedValues(*expected_app1, *app1);
1120
1121 // Verify COM methods return the same values as the C++ methods used above.
1122 long num_registered_apps = 0; // NOLINT
1123 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_registered_apps));
1124 EXPECT_EQ(2, num_registered_apps);
1125 App* app0_obtained = NULL;
1126 EXPECT_SUCCEEDED(app_bundle_->get_Item(0, &app0_obtained));
1127 EXPECT_EQ(app0, app0_obtained);
1128 App* app1_obtained = NULL;
1129 EXPECT_SUCCEEDED(app_bundle_->get_Item(1, &app1_obtained));
1130 EXPECT_EQ(app1, app1_obtained);
1131 }
1132
1133 TEST_F(AppBundlePopulatedRegistryMachineTest, createAllInstalledApps) {
1134 App *expected_app0, *expected_app1, *expected_app2;
1135 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1136 &expected_app1,
1137 &expected_app2);
1138 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1139 AppendRegKeyPath(MACHINE_REG_CLIENT_STATE, kGuid4))); // Avoid assert.
1140
1141 // An important part of this test is that processing continues and
1142 // even though there is a key for an app that is not properly
1143 // registered (e.g. it does not have a pv value or has an invalid pv value).
1144 // Since this is so important, explicitly check registry was set up correctly.
1145 // Invalid pv value type is checked in a separate test since it causes an
1146 // assert.
1147 // An app without a pv is not added to the bundle.
1148 const CString incomplete_clients_key =
1149 AppendRegKeyPath(MACHINE_REG_CLIENTS, kGuid4);
1150 EXPECT_TRUE(RegKey::HasKey(incomplete_clients_key));
1151 EXPECT_FALSE(RegKey::HasValue(incomplete_clients_key,
1152 kRegValueProductVersion));
1153
1154 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1155 EXPECT_EQ(2, app_bundle_->GetNumberOfApps());
1156
1157 App* app0 = app_bundle_->GetApp(0);
1158 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
1159 EXPECT_SUCCEEDED(expected_app0->put_isEulaAccepted(VARIANT_TRUE));
1160 ValidateExpectedValues(*expected_app0, *app0);
1161
1162 App* app1 = app_bundle_->GetApp(1);
1163 EXPECT_STREQ(CString(kGuid2).MakeUpper(), app1->app_guid_string());
1164 SetDisplayName(kDefaultAppName, expected_app1);
1165 EXPECT_SUCCEEDED(expected_app1->put_isEulaAccepted(VARIANT_TRUE));
1166 ValidateExpectedValues(*expected_app1, *app1);
1167
1168 // Verify COM methods return the same values as the C++ methods used above.
1169 long num_registered_apps = 0; // NOLINT
1170 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_registered_apps));
1171 EXPECT_EQ(2, num_registered_apps);
1172 App* app0_obtained = NULL;
1173 EXPECT_SUCCEEDED(app_bundle_->get_Item(0, &app0_obtained));
1174 EXPECT_EQ(app0, app0_obtained);
1175 App* app1_obtained = NULL;
1176 EXPECT_SUCCEEDED(app_bundle_->get_Item(1, &app1_obtained));
1177 EXPECT_EQ(app1, app1_obtained);
1178 }
1179
1180 TEST_F(AppBundlePopulatedRegistryUserTest,
1181 createAllInstalledApps_InvalidPvValueType) {
1182 App *expected_app0, *expected_app1, *expected_app2;
1183 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1184 &expected_app1,
1185 &expected_app2);
1186
1187 // Incorrect data type for pv. See comment in machine createAllInstalledApps
1188 // test.
1189 // It is important that this value is alphabetically before the other AppIds.
1190 // This allows us to test that processing continues despite the bad pv.
1191 const TCHAR* const kInvalidPvTypeAppId =
1192 _T("{0150B619-867C-4985-B193-ED309A23EE36}");
1193 const CString invalid_pv_type_clients_key =
1194 AppendRegKeyPath(USER_REG_CLIENTS, kInvalidPvTypeAppId);
1195 const DWORD kInvalidPvDword = 0x3039;
1196 const TCHAR* const kInvalidPvDwordAsString = _T("\x3039");
1197 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(invalid_pv_type_clients_key,
1198 kRegValueProductVersion,
1199 kInvalidPvDword));
1200 EXPECT_TRUE(RegKey::HasValue(invalid_pv_type_clients_key,
1201 kRegValueProductVersion));
1202 DWORD value_type = REG_SZ;
1203 EXPECT_SUCCEEDED(RegKey::GetValueType(invalid_pv_type_clients_key,
1204 kRegValueProductVersion,
1205 &value_type));
1206 EXPECT_NE(REG_SZ, value_type);
1207 App* invalid_pv_app = CreateExpectedApp(kInvalidPvTypeAppId);
1208 invalid_pv_app->current_version()->set_version(kInvalidPvDwordAsString);
1209 invalid_pv_app->set_days_since_last_active_ping(-1);
1210 invalid_pv_app->set_days_since_last_roll_call(-1);
1211 SetDisplayName(kDefaultAppName, invalid_pv_app);
1212
1213 {
1214 // An assert occurs when reading the wrong value type.
1215 ExpectAsserts expect_asserts;
1216 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1217 }
1218
1219 EXPECT_EQ(3, app_bundle_->GetNumberOfApps());
1220
1221 // The invalid pv app is added to the bundle with an unreadable pv.
1222 App* app0 = app_bundle_->GetApp(0);
1223 EXPECT_STREQ(kInvalidPvTypeAppId, app0->app_guid_string());
1224 EXPECT_STREQ(kInvalidPvDwordAsString, app0->current_version()->version());
1225 EXPECT_SUCCEEDED(invalid_pv_app->put_isEulaAccepted(VARIANT_TRUE));
1226 ValidateExpectedValues(*invalid_pv_app, *app0);
1227
1228 App* app1 = app_bundle_->GetApp(1);
1229 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app1->app_guid_string());
1230 EXPECT_SUCCEEDED(expected_app0->put_isEulaAccepted(VARIANT_TRUE));
1231 ValidateExpectedValues(*expected_app0, *app1);
1232
1233 App* app2 = app_bundle_->GetApp(2);
1234 EXPECT_STREQ(CString(kGuid2).MakeUpper(), app2->app_guid_string());
1235 SetDisplayName(kDefaultAppName, expected_app1);
1236 EXPECT_SUCCEEDED(expected_app1->put_isEulaAccepted(VARIANT_TRUE));
1237 ValidateExpectedValues(*expected_app1, *app2);
1238 }
1239
1240 TEST_F(AppBundlePopulatedRegistryUserTest,
1241 createAllInstalledApps_NoAppsRegistered) {
1242 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1243 app_bundle_->createAllInstalledApps());
1244 EXPECT_EQ(0, app_bundle_->GetNumberOfApps());
1245
1246 {
1247 ExpectAsserts expect_asserts;
1248 EXPECT_FALSE(app_bundle_->GetApp(0));
1249 }
1250 }
1251
1252 TEST_F(AppBundlePopulatedRegistryUserTest,
1253 createAllInstalledApps_OneAppRegistered) {
1254 CString clients_key_name = AppendRegKeyPath(USER_REG_CLIENTS, kGuid1);
1255 EXPECT_SUCCEEDED(RegKey::SetValue(clients_key_name,
1256 kRegValueProductVersion,
1257 _T("1.0.0.0")));
1258 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1259 AppendRegKeyPath(USER_REG_CLIENT_STATE, kGuid1))); // Avoid assert.
1260
1261 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1262 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
1263
1264 App* app0 = app_bundle_->GetApp(0);
1265 EXPECT_STREQ(CString(kGuid1).MakeUpper(), app0->app_guid_string());
1266 }
1267
1268 TEST_F(AppBundlePopulatedRegistryUserTest,
1269 createAllInstalledApps_AfterUpdateCheck) {
1270 App *expected_app0, *expected_app1, *expected_app2;
1271 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1272 &expected_app1,
1273 &expected_app2);
1274 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1275 AppendRegKeyPath(USER_REG_CLIENT_STATE, kGuid4))); // Avoid assert.
1276
1277 DummyUserWorkItem dummy_work_item;
1278 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
1279 .WillOnce(SetWorkItem(&dummy_work_item));
1280
1281 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1282
1283 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
1284 app_bundle_->CompleteAsyncCall(); // Simulate thread completion.
1285
1286 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->createAllInstalledApps());
1287 }
1288
1289 TEST_F(AppBundlePopulatedRegistryUserTest, createApp_After_createInstalledApp) {
1290 App *expected_app0, *expected_app1, *expected_app2;
1291 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1292 &expected_app1,
1293 &expected_app2);
1294
1295 App* app0_created = NULL;
1296 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1),
1297 &app0_created));
1298
1299 App* app1_created = NULL;
1300 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1301 app_bundle_->createApp(CComBSTR(kGuid2), &app1_created));
1302 }
1303
1304 TEST_F(AppBundlePopulatedRegistryUserTest, createApp_createAllInstalledApps) {
1305 App *expected_app0, *expected_app1, *expected_app2;
1306 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1307 &expected_app1,
1308 &expected_app2);
1309 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1310 AppendRegKeyPath(USER_REG_CLIENT_STATE, kGuid4))); // Avoid assert.
1311
1312 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1313
1314 App* app0_created = NULL;
1315 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1316 app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
1317 }
1318
1319 TEST_F(AppBundleInitializedUserTest, createInstalledApp_After_createApp) {
1320 App* app0_created = NULL;
1321 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
1322
1323 App* app1_created = NULL;
1324 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1325 app_bundle_->createInstalledApp(CComBSTR(kGuid2), &app1_created));
1326 }
1327
1328 TEST_F(AppBundlePopulatedRegistryUserTest,
1329 createInstalledApp_After_createAllInstalledApps) {
1330 App *expected_app0, *expected_app1, *expected_app2;
1331 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1332 &expected_app1,
1333 &expected_app2);
1334 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1335 AppendRegKeyPath(USER_REG_CLIENT_STATE, kGuid4))); // Avoid assert.
1336
1337 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1338
1339 App* app0_created = NULL;
1340 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1341 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app0_created));
1342 }
1343
1344 TEST_F(AppBundleInitializedUserTest, createAllInstalledApps_After_createApp) {
1345 App* app0_created = NULL;
1346 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app0_created));
1347
1348 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->createAllInstalledApps());
1349 }
1350
1351 TEST_F(AppBundlePopulatedRegistryUserTest,
1352 createAllInstalledApps_After_createInstalledApp) {
1353 App *expected_app0, *expected_app1, *expected_app2;
1354 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1355 &expected_app1,
1356 &expected_app2);
1357
1358 App* app0_created = NULL;
1359 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1),
1360 &app0_created));
1361
1362 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->createAllInstalledApps());
1363 }
1364
1365 TEST_F(AppBundlePopulatedRegistryUserTest,
1366 createAllInstalledApps_Twice) {
1367 App *expected_app0, *expected_app1, *expected_app2;
1368 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1369 &expected_app1,
1370 &expected_app2);
1371
1372 App* app0_created = NULL;
1373 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1),
1374 &app0_created));
1375
1376 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->createAllInstalledApps());
1377 }
1378
1379 // TODO(omaha): Enable if we end up needing such a function.
1380 #if 0
1381 TEST_F(AppBundlePopulatedRegistryMachineTest, createUninstalledApps) {
1382 App *expected_app0, *expected_app1, *expected_app2;
1383 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1384 &expected_app1,
1385 &expected_app2);
1386
1387 EXPECT_SUCCEEDED(app_bundle_->createUninstalledApps());
1388 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
1389
1390 App* app0 = app_bundle_->GetApp(0);
1391 EXPECT_STREQ(kGuid3, app0->app_guid_string());
1392 ValidateExpectedValues(*expected_app2, *app0);
1393 }
1394
1395 TEST_F(AppBundlePopulatedRegistryUserTest, createUninstalledApps) {
1396 App *expected_app0, *expected_app1, *expected_app2;
1397 PopulateDataAndRegistryForRegisteredAndUnInstalledAppsTests(&expected_app0,
1398 &expected_app1,
1399 &expected_app2);
1400
1401 EXPECT_SUCCEEDED(app_bundle_->createUninstalledApps());
1402 EXPECT_EQ(1, app_bundle_->GetNumberOfApps());
1403
1404 App* app0 = app_bundle_->GetApp(0);
1405 EXPECT_STREQ(kGuid3, app0->app_guid_string());
1406 ValidateExpectedValues(*expected_app2, *app0);
1407 }
1408 #endif
1409
1410 //
1411 // State tests.
1412 //
1413
1414 class AppBundleStateUserTest : public AppBundleTest {
1415 protected:
1416 AppBundleStateUserTest()
1417 : AppBundleTest(false),
1418 hive_override_key_name_(kRegistryHiveOverrideRoot) {}
1419
1420 virtual void SetUp() {
1421 AppBundleTest::SetUp();
1422
1423 RegKey::DeleteKey(hive_override_key_name_);
1424 OverrideRegistryHives(hive_override_key_name_);
1425 }
1426
1427 virtual void TearDown() {
1428 RestoreRegistryHives();
1429 RegKey::DeleteKey(hive_override_key_name_);
1430
1431 AppBundleTest::TearDown();
1432 }
1433
1434 // Writing name avoids needing to create the ResourceManager.
1435 void CreateClientsKeyForApp1() {
1436 CString clients_key = AppendRegKeyPath(USER_REG_CLIENTS, kGuid1);
1437 EXPECT_SUCCEEDED(RegKey::SetValue(clients_key,
1438 kRegValueProductVersion,
1439 _T("1.2.3.4")));
1440 EXPECT_SUCCEEDED(RegKey::SetValue(clients_key,
1441 kRegValueAppName,
1442 _T("Test App")));
1443 }
1444
1445 CString hive_override_key_name_;
1446 };
1447
1448
1449 class AppBundleStateInitUserTest : public AppBundleStateUserTest {
1450 protected:
1451 AppBundleStateInitUserTest() : AppBundleStateUserTest() {}
1452
1453 virtual void SetUp() {
1454 AppBundleStateUserTest::SetUp();
1455
1456 // Nothing to do since the budle starts in this state.
1457 }
1458 };
1459
1460 class AppBundleStateInitializedUserTest : public AppBundleStateUserTest {
1461 protected:
1462 AppBundleStateInitializedUserTest() : AppBundleStateUserTest() {}
1463
1464 virtual void SetUp() {
1465 AppBundleStateUserTest::SetUp();
1466 EXPECT_SUCCEEDED(app_bundle_->put_displayName(CComBSTR(_T("My Bundle"))));
1467 EXPECT_SUCCEEDED(app_bundle_->put_displayLanguage(CComBSTR(_T("en"))));
1468 EXPECT_SUCCEEDED(app_bundle_->initialize());
1469 }
1470 };
1471
1472 class AppBundleStateBusyUserTest : public AppBundleStateUserTest {
1473 protected:
1474 AppBundleStateBusyUserTest() : AppBundleStateUserTest() {}
1475
1476 virtual void SetUp() {
1477 AppBundleStateUserTest::SetUp();
1478
1479 DummyUserWorkItem dummy_work_item;
1480 app_bundle_->set_user_work_item(&dummy_work_item);
1481
1482 SetAppBundleStateForUnitTest(app_bundle_.get(),
1483 new fsm::AppBundleStateBusy);
1484 }
1485 };
1486
1487 class AppBundleStateReadyUserTest : public AppBundleStateUserTest {
1488 protected:
1489 AppBundleStateReadyUserTest() : AppBundleStateUserTest() {}
1490
1491 virtual void SetUp() {
1492 AppBundleStateUserTest::SetUp();
1493 EXPECT_SUCCEEDED(app_bundle_->put_displayName(CComBSTR(_T("My Bundle"))));
1494 EXPECT_SUCCEEDED(app_bundle_->put_displayLanguage(CComBSTR(_T("en"))));
1495 EXPECT_SUCCEEDED(app_bundle_->initialize());
1496
1497 // In all cases, the bundle should have at least one app.
1498 // The downloadPackage test needs an installed app.
1499 CreateClientsKeyForApp1();
1500 App* app = NULL;
1501 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
1502
1503 SetAppBundleStateForUnitTest(app_bundle_.get(),
1504 new fsm::AppBundleStateReady);
1505 }
1506 };
1507
1508 class AppBundleStatePausedUserTest : public AppBundleStateUserTest {
1509 protected:
1510 AppBundleStatePausedUserTest() : AppBundleStateUserTest() {}
1511
1512 virtual void SetUp() {
1513 AppBundleStateUserTest::SetUp();
1514 SetAppBundleStateForUnitTest(app_bundle_.get(),
1515 new fsm::AppBundleStatePaused);
1516 }
1517 };
1518
1519 class AppBundleStateStoppedUserTest : public AppBundleStateUserTest {
1520 protected:
1521 AppBundleStateStoppedUserTest() : AppBundleStateUserTest() {}
1522
1523 virtual void SetUp() {
1524 AppBundleStateUserTest::SetUp();
1525 SetAppBundleStateForUnitTest(app_bundle_.get(),
1526 new fsm::AppBundleStateStopped);
1527 }
1528 };
1529
1530 // Init.
1531
1532 TEST_F(AppBundleStateInitUserTest, Properties) {
1533 TestPropertyReflexiveness();
1534 EXPECT_EQ(STATE_INIT, GetBundleState());
1535 }
1536
1537 TEST_F(AppBundleStateInitUserTest, CountAndItem) {
1538 long num_apps = 0; // NOLINT
1539 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
1540 EXPECT_EQ(0, num_apps);
1541
1542 App* app0_obtained = NULL;
1543 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
1544 app_bundle_->get_Item(0, &app0_obtained));
1545 EXPECT_FALSE(app0_obtained);
1546
1547 EXPECT_EQ(STATE_INIT, GetBundleState());
1548 }
1549
1550 TEST_F(AppBundleStateInitUserTest, put_altTokens) {
1551 CAccessToken access_token;
1552 access_token.GetProcessToken(TOKEN_DUPLICATE);
1553 ULONG_PTR process_token =
1554 reinterpret_cast<ULONG_PTR>(access_token.GetHandle());
1555 EXPECT_SUCCEEDED(app_bundle_->put_altTokens(process_token,
1556 process_token,
1557 ::GetCurrentProcessId()));
1558 EXPECT_EQ(STATE_INIT, GetBundleState());
1559 }
1560
1561 TEST_F(AppBundleStateInitUserTest, initialize) {
1562 EXPECT_SUCCEEDED(app_bundle_->put_displayName(CComBSTR(_T("My Bundle"))));
1563 EXPECT_SUCCEEDED(app_bundle_->put_displayLanguage(CComBSTR(_T("en"))));
1564 EXPECT_SUCCEEDED(app_bundle_->initialize());
1565 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1566 }
1567
1568 TEST_F(AppBundleStateInitUserTest, createApp) {
1569 App* app = NULL;
1570 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1571 app_bundle_->createApp(CComBSTR(kGuid1), &app));
1572 EXPECT_EQ(STATE_INIT, GetBundleState());
1573 }
1574
1575 TEST_F(AppBundleStateInitUserTest, createInstalledApp) {
1576 CreateClientsKeyForApp1();
1577
1578 App* app = NULL;
1579 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1580 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
1581 EXPECT_EQ(STATE_INIT, GetBundleState());
1582 }
1583
1584 TEST_F(AppBundleStateInitUserTest, createAllInstalledApps) {
1585 CreateClientsKeyForApp1();
1586
1587 App* app = NULL;
1588 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1589 app_bundle_->createAllInstalledApps());
1590 EXPECT_EQ(STATE_INIT, GetBundleState());
1591 }
1592
1593 TEST_F(AppBundleStateInitUserTest, checkForUpdate) {
1594 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
1595 EXPECT_EQ(STATE_INIT, GetBundleState());
1596 }
1597
1598 TEST_F(AppBundleStateInitUserTest, download) {
1599 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->download());
1600 EXPECT_EQ(STATE_INIT, GetBundleState());
1601 }
1602
1603 TEST_F(AppBundleStateInitUserTest, install) {
1604 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->install());
1605 EXPECT_EQ(STATE_INIT, GetBundleState());
1606 }
1607
1608 TEST_F(AppBundleStateInitUserTest, updateAllApps) {
1609 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->updateAllApps());
1610 EXPECT_EQ(STATE_INIT, GetBundleState());
1611 }
1612
1613 TEST_F(AppBundleStateInitUserTest, stop) {
1614 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->stop());
1615 EXPECT_EQ(STATE_INIT, GetBundleState());
1616 }
1617
1618 TEST_F(AppBundleStateInitUserTest, pause) {
1619 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->pause());
1620 EXPECT_EQ(STATE_INIT, GetBundleState());
1621 }
1622
1623 TEST_F(AppBundleStateInitUserTest, resume) {
1624 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->resume());
1625 EXPECT_EQ(STATE_INIT, GetBundleState());
1626 }
1627
1628 TEST_F(AppBundleStateInitUserTest, isBusy) {
1629 VARIANT_BOOL is_busy = VARIANT_TRUE;
1630 EXPECT_SUCCEEDED(app_bundle_->isBusy(&is_busy));
1631 EXPECT_EQ(VARIANT_FALSE, is_busy);
1632 EXPECT_EQ(STATE_INIT, GetBundleState());
1633 }
1634
1635 TEST_F(AppBundleStateInitUserTest, downloadPackage) {
1636 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1637 app_bundle_->downloadPackage(CComBSTR(kGuid1),
1638 CComBSTR(_T("package"))));
1639 EXPECT_EQ(STATE_INIT, GetBundleState());
1640 }
1641
1642 // TODO(omaha): Check the state or remove this function.
1643 TEST_F(AppBundleStateInitUserTest, get_currentState) {
1644 VARIANT current_state;
1645 ExpectAsserts expect_asserts; // Not yet implemented.
1646 EXPECT_EQ(E_NOTIMPL, app_bundle_->get_currentState(&current_state));
1647 EXPECT_EQ(STATE_INIT, GetBundleState());
1648 }
1649
1650 TEST_F(AppBundleStateInitUserTest, CompleteAsyncCall) {
1651 {
1652 ExpectAsserts expect_asserts;
1653 app_bundle_->CompleteAsyncCall();
1654 }
1655
1656 EXPECT_EQ(STATE_INIT, GetBundleState());
1657 }
1658
1659 // Initialized.
1660
1661 TEST_F(AppBundleStateInitializedUserTest, Properties) {
1662 TestPropertyReflexiveness();
1663 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1664 }
1665
1666 TEST_F(AppBundleStateInitializedUserTest, CountAndItem) {
1667 long num_apps = 0; // NOLINT
1668 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
1669 EXPECT_EQ(0, num_apps);
1670
1671 App* app0_obtained = NULL;
1672 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
1673 app_bundle_->get_Item(0, &app0_obtained));
1674 EXPECT_FALSE(app0_obtained);
1675
1676 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1677 }
1678
1679 TEST_F(AppBundleStateInitializedUserTest, put_altTokens) {
1680 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->put_altTokens(1, 2, 3));
1681 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1682 }
1683
1684 TEST_F(AppBundleStateInitializedUserTest, initialize) {
1685 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->initialize());
1686 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1687 }
1688
1689 TEST_F(AppBundleStateInitializedUserTest, createApp) {
1690 App* app = NULL;
1691 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
1692 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1693 }
1694
1695 TEST_F(AppBundleStateInitializedUserTest, createInstalledApp) {
1696 CreateClientsKeyForApp1();
1697
1698 App* app = NULL;
1699 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
1700 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1701 }
1702
1703 TEST_F(AppBundleStateInitializedUserTest, createAllInstalledApps) {
1704 CreateClientsKeyForApp1();
1705 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1706 AppendRegKeyPath(USER_REG_CLIENT_STATE, kGuid1))); // Avoid assert.
1707
1708 App* app = NULL;
1709 EXPECT_SUCCEEDED(app_bundle_->createAllInstalledApps());
1710 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1711 }
1712
1713 TEST_F(AppBundleStateInitializedUserTest, checkForUpdate) {
1714 App* app = NULL;
1715 EXPECT_SUCCEEDED(app_bundle_->createApp(CComBSTR(kGuid1), &app));
1716 DummyUserWorkItem dummy_work_item;
1717 EXPECT_CALL(*worker_, CheckForUpdateAsync(_))
1718 .WillOnce(SetWorkItem(&dummy_work_item));
1719
1720 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate());
1721 EXPECT_EQ(STATE_BUSY, GetBundleState());
1722
1723 EXPECT_FALSE(app_bundle_->is_auto_update());
1724 }
1725
1726 TEST_F(AppBundleStateInitializedUserTest, download) {
1727 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->download());
1728 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1729 }
1730
1731 TEST_F(AppBundleStateInitializedUserTest, install) {
1732 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->install());
1733 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1734 }
1735
1736 TEST_F(AppBundleStateInitializedUserTest, updateAllApps) {
1737 CreateClientsKeyForApp1();
1738 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(
1739 AppendRegKeyPath(USER_REG_CLIENT_STATE, kGuid1))); // Avoid assert.
1740
1741 DummyUserWorkItem dummy_work_item;
1742 EXPECT_CALL(*worker_, UpdateAllAppsAsync(_))
1743 .WillOnce(SetWorkItem(&dummy_work_item));
1744
1745 EXPECT_SUCCEEDED(app_bundle_->updateAllApps());
1746 EXPECT_EQ(STATE_BUSY, GetBundleState());
1747
1748 EXPECT_TRUE(app_bundle_->is_auto_update());
1749 }
1750
1751 TEST_F(AppBundleStateInitializedUserTest, stop) {
1752 EXPECT_SUCCEEDED(app_bundle_->stop());
1753 EXPECT_EQ(STATE_STOPPED, GetBundleState());
1754 }
1755
1756 TEST_F(AppBundleStateInitializedUserTest, pause) {
1757 EXPECT_SUCCEEDED(app_bundle_->pause());
1758 EXPECT_EQ(STATE_PAUSED, GetBundleState());
1759 }
1760
1761 TEST_F(AppBundleStateInitializedUserTest, resume) {
1762 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->resume());
1763 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1764 }
1765
1766 TEST_F(AppBundleStateInitializedUserTest, isBusy) {
1767 VARIANT_BOOL is_busy = VARIANT_TRUE;
1768 EXPECT_SUCCEEDED(app_bundle_->isBusy(&is_busy));
1769 EXPECT_EQ(VARIANT_FALSE, is_busy);
1770 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1771 }
1772
1773 // downloadPackage() returns E_INVALIDARG because the app has no packages.
1774 // TODO(omaha): Add the package so downloadPackage can succeed.
1775 TEST_F(AppBundleStateInitializedUserTest, downloadPackage) {
1776 CreateClientsKeyForApp1();
1777 App* app = NULL;
1778 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
1779
1780 EXPECT_EQ(
1781 E_INVALIDARG,
1782 app_bundle_->downloadPackage(CComBSTR(kGuid1), CComBSTR(_T("package"))));
1783 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1784
1785 EXPECT_FALSE(app_bundle_->is_auto_update());
1786 }
1787
1788 TEST_F(AppBundleStateInitializedUserTest, get_currentState) {
1789 VARIANT current_state;
1790 ExpectAsserts expect_asserts; // Not yet implemented.
1791 EXPECT_EQ(E_NOTIMPL, app_bundle_->get_currentState(&current_state));
1792 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1793 }
1794
1795 TEST_F(AppBundleStateInitializedUserTest, CompleteAsyncCall) {
1796 {
1797 ExpectAsserts expect_asserts;
1798 app_bundle_->CompleteAsyncCall();
1799 }
1800
1801 EXPECT_EQ(STATE_INITIALIZED, GetBundleState());
1802 }
1803
1804 // Busy.
1805
1806 TEST_F(AppBundleStateBusyUserTest, Properties) {
1807 TestPropertyReflexiveness();
1808 EXPECT_EQ(STATE_BUSY, GetBundleState());
1809 }
1810
1811 TEST_F(AppBundleStateBusyUserTest, CountAndItem) {
1812 long num_apps = 0; // NOLINT
1813 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
1814 EXPECT_EQ(0, num_apps);
1815
1816 App* app0_obtained = NULL;
1817 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
1818 app_bundle_->get_Item(0, &app0_obtained));
1819 EXPECT_FALSE(app0_obtained);
1820
1821 EXPECT_EQ(STATE_BUSY, GetBundleState());
1822 }
1823
1824 TEST_F(AppBundleStateBusyUserTest, put_altTokens) {
1825 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->put_altTokens(1, 2, 3));
1826 EXPECT_EQ(STATE_BUSY, GetBundleState());
1827 }
1828
1829 TEST_F(AppBundleStateBusyUserTest, initialize) {
1830 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->initialize());
1831 EXPECT_EQ(STATE_BUSY, GetBundleState());
1832 }
1833
1834 TEST_F(AppBundleStateBusyUserTest, createApp) {
1835 App* app = NULL;
1836 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1837 app_bundle_->createApp(CComBSTR(kGuid1), &app));
1838 EXPECT_EQ(STATE_BUSY, GetBundleState());
1839 }
1840
1841 TEST_F(AppBundleStateBusyUserTest, createInstalledApp) {
1842 CreateClientsKeyForApp1();
1843
1844 App* app = NULL;
1845 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1846 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
1847 EXPECT_EQ(STATE_BUSY, GetBundleState());
1848 }
1849
1850 TEST_F(AppBundleStateBusyUserTest, createAllInstalledApps) {
1851 CreateClientsKeyForApp1();
1852
1853 App* app = NULL;
1854 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1855 app_bundle_->createAllInstalledApps());
1856 EXPECT_EQ(STATE_BUSY, GetBundleState());
1857 }
1858
1859 TEST_F(AppBundleStateBusyUserTest, checkForUpdate) {
1860 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
1861 EXPECT_EQ(STATE_BUSY, GetBundleState());
1862 }
1863
1864 TEST_F(AppBundleStateBusyUserTest, download) {
1865 EXPECT_EQ(GOOPDATE_E_NON_BLOCKING_CALL_PENDING, app_bundle_->download());
1866 EXPECT_EQ(STATE_BUSY, GetBundleState());
1867 }
1868
1869 TEST_F(AppBundleStateBusyUserTest, install) {
1870 EXPECT_EQ(GOOPDATE_E_NON_BLOCKING_CALL_PENDING, app_bundle_->install());
1871 EXPECT_EQ(STATE_BUSY, GetBundleState());
1872 }
1873
1874 TEST_F(AppBundleStateBusyUserTest, updateAllApps) {
1875 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->updateAllApps());
1876 EXPECT_EQ(STATE_BUSY, GetBundleState());
1877 }
1878
1879 TEST_F(AppBundleStateBusyUserTest, stop_Succeeds) {
1880 EXPECT_CALL(*worker_, Stop(app_bundle_.get()))
1881 .WillOnce(Return(S_OK));
1882
1883 EXPECT_SUCCEEDED(app_bundle_->stop());
1884 EXPECT_EQ(STATE_STOPPED, GetBundleState());
1885 }
1886
1887 TEST_F(AppBundleStateBusyUserTest, stop_Fails) {
1888 EXPECT_CALL(*worker_, Stop(app_bundle_.get()))
1889 .WillOnce(Return(kKnownError));
1890
1891 EXPECT_EQ(kKnownError, app_bundle_->stop());
1892 EXPECT_EQ(STATE_BUSY, GetBundleState());
1893 }
1894
1895 TEST_F(AppBundleStateBusyUserTest, pause_Succeeds) {
1896 EXPECT_CALL(*worker_, Pause(app_bundle_.get()))
1897 .WillOnce(Return(S_OK));
1898
1899 EXPECT_EQ(S_OK, app_bundle_->pause());
1900 EXPECT_EQ(STATE_PAUSED, GetBundleState());
1901 }
1902
1903 TEST_F(AppBundleStateBusyUserTest, pause_Fails) {
1904 EXPECT_CALL(*worker_, Pause(_))
1905 .WillOnce(Return(kKnownError));
1906
1907 EXPECT_EQ(kKnownError, app_bundle_->pause());
1908 EXPECT_EQ(STATE_BUSY, GetBundleState());
1909 }
1910
1911 TEST_F(AppBundleStateBusyUserTest, resume) {
1912 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->resume());
1913 EXPECT_EQ(STATE_BUSY, GetBundleState());
1914 }
1915
1916 TEST_F(AppBundleStateBusyUserTest, isBusy) {
1917 VARIANT_BOOL is_busy = VARIANT_TRUE;
1918 EXPECT_SUCCEEDED(app_bundle_->isBusy(&is_busy));
1919 EXPECT_EQ(VARIANT_TRUE, is_busy);
1920 EXPECT_EQ(STATE_BUSY, GetBundleState());
1921 }
1922
1923 TEST_F(AppBundleStateBusyUserTest, downloadPackage) {
1924 EXPECT_EQ(GOOPDATE_E_NON_BLOCKING_CALL_PENDING,
1925 app_bundle_->downloadPackage(CComBSTR(kGuid1),
1926 CComBSTR(_T("package"))));
1927 EXPECT_EQ(STATE_BUSY, GetBundleState());
1928 }
1929
1930 TEST_F(AppBundleStateBusyUserTest, get_currentState) {
1931 VARIANT current_state;
1932 ExpectAsserts expect_asserts; // Not yet implemented.
1933 EXPECT_EQ(E_NOTIMPL, app_bundle_->get_currentState(&current_state));
1934 EXPECT_EQ(STATE_BUSY, GetBundleState());
1935 }
1936
1937 TEST_F(AppBundleStateBusyUserTest, CompleteAsyncCall) {
1938 app_bundle_->CompleteAsyncCall();
1939
1940 EXPECT_EQ(STATE_READY, GetBundleState());
1941 }
1942
1943 // Ready.
1944
1945 TEST_F(AppBundleStateReadyUserTest, Properties) {
1946 TestPropertyReflexiveness();
1947 EXPECT_EQ(STATE_READY, GetBundleState());
1948 }
1949
1950 TEST_F(AppBundleStateReadyUserTest, CountAndItem) {
1951 long num_apps = 0; // NOLINT
1952 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
1953 EXPECT_EQ(1, num_apps);
1954
1955 App* app0_obtained = NULL;
1956 EXPECT_SUCCEEDED(app_bundle_->get_Item(0, &app0_obtained));
1957 EXPECT_TRUE(app0_obtained);
1958
1959 EXPECT_EQ(STATE_READY, GetBundleState());
1960 }
1961
1962 TEST_F(AppBundleStateReadyUserTest, put_altTokens) {
1963 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->put_altTokens(1, 2, 3));
1964 EXPECT_EQ(STATE_READY, GetBundleState());
1965 }
1966
1967 TEST_F(AppBundleStateReadyUserTest, initialize) {
1968 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->initialize());
1969 EXPECT_EQ(STATE_READY, GetBundleState());
1970 }
1971
1972 TEST_F(AppBundleStateReadyUserTest, createApp) {
1973 App* app = NULL;
1974 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1975 app_bundle_->createApp(CComBSTR(kGuid1), &app));
1976 EXPECT_EQ(STATE_READY, GetBundleState());
1977 }
1978
1979 TEST_F(AppBundleStateReadyUserTest, createInstalledApp) {
1980 CreateClientsKeyForApp1();
1981
1982 App* app = NULL;
1983 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1984 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
1985 EXPECT_EQ(STATE_READY, GetBundleState());
1986 }
1987
1988 TEST_F(AppBundleStateReadyUserTest, createAllInstalledApps) {
1989 CreateClientsKeyForApp1();
1990
1991 App* app = NULL;
1992 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
1993 app_bundle_->createAllInstalledApps());
1994 EXPECT_EQ(STATE_READY, GetBundleState());
1995 }
1996
1997 TEST_F(AppBundleStateReadyUserTest, checkForUpdate) {
1998 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
1999 EXPECT_EQ(STATE_READY, GetBundleState());
2000 }
2001
2002 TEST_F(AppBundleStateReadyUserTest, download) {
2003 DummyUserWorkItem dummy_work_item;
2004 EXPECT_CALL(*worker_, DownloadAsync(_))
2005 .WillOnce(SetWorkItem(&dummy_work_item));
2006
2007 EXPECT_SUCCEEDED(app_bundle_->download());
2008 EXPECT_EQ(STATE_BUSY, GetBundleState());
2009
2010 EXPECT_FALSE(app_bundle_->is_auto_update());
2011 }
2012
2013 TEST_F(AppBundleStateReadyUserTest, install) {
2014 DummyUserWorkItem dummy_work_item;
2015 EXPECT_CALL(*worker_, DownloadAndInstallAsync(_))
2016 .WillOnce(SetWorkItem(&dummy_work_item));
2017
2018 EXPECT_SUCCEEDED(app_bundle_->install());
2019 EXPECT_EQ(STATE_BUSY, GetBundleState());
2020
2021 EXPECT_FALSE(app_bundle_->is_auto_update());
2022 }
2023
2024 TEST_F(AppBundleStateReadyUserTest, updateAllApps) {
2025 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->updateAllApps());
2026 EXPECT_EQ(STATE_READY, GetBundleState());
2027 }
2028
2029 TEST_F(AppBundleStateReadyUserTest, stop) {
2030 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->stop());
2031 EXPECT_EQ(STATE_READY, GetBundleState());
2032 }
2033
2034 TEST_F(AppBundleStateReadyUserTest, pause) {
2035 EXPECT_SUCCEEDED(app_bundle_->pause());
2036 EXPECT_EQ(STATE_READY, GetBundleState());
2037 }
2038
2039 TEST_F(AppBundleStateReadyUserTest, resume) {
2040 EXPECT_SUCCEEDED(app_bundle_->resume());
2041 EXPECT_EQ(STATE_READY, GetBundleState());
2042 }
2043
2044 TEST_F(AppBundleStateReadyUserTest, isBusy) {
2045 VARIANT_BOOL is_busy = VARIANT_TRUE;
2046 EXPECT_SUCCEEDED(app_bundle_->isBusy(&is_busy));
2047 EXPECT_EQ(VARIANT_FALSE, is_busy);
2048 EXPECT_EQ(STATE_READY, GetBundleState());
2049 }
2050
2051 // downloadPackage() returns E_INVALIDARG because the app has no packages.
2052 // TODO(omaha): Add the package so downloadPackage can succeed.
2053 TEST_F(AppBundleStateReadyUserTest, downloadPackage) {
2054 EXPECT_EQ(
2055 E_INVALIDARG,
2056 app_bundle_->downloadPackage(CComBSTR(kGuid1), CComBSTR(_T("package"))));
2057 EXPECT_EQ(STATE_READY, GetBundleState());
2058 }
2059
2060 TEST_F(AppBundleStateReadyUserTest, get_currentState) {
2061 VARIANT current_state;
2062 ExpectAsserts expect_asserts; // Not yet implemented.
2063 EXPECT_EQ(E_NOTIMPL, app_bundle_->get_currentState(&current_state));
2064 EXPECT_EQ(STATE_READY, GetBundleState());
2065 }
2066
2067 TEST_F(AppBundleStateReadyUserTest, CompleteAsyncCall) {
2068 {
2069 ExpectAsserts expect_asserts;
2070 app_bundle_->CompleteAsyncCall();
2071 }
2072
2073 EXPECT_EQ(STATE_READY, GetBundleState());
2074 }
2075
2076 // Paused.
2077
2078 TEST_F(AppBundleStatePausedUserTest, Properties) {
2079 TestPropertyReflexiveness();
2080 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2081 }
2082
2083 TEST_F(AppBundleStatePausedUserTest, CountAndItem) {
2084 long num_apps = 0; // NOLINT
2085 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
2086 EXPECT_EQ(0, num_apps);
2087
2088 App* app0_obtained = NULL;
2089 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
2090 app_bundle_->get_Item(0, &app0_obtained));
2091 EXPECT_FALSE(app0_obtained);
2092
2093 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2094 }
2095
2096 TEST_F(AppBundleStatePausedUserTest, put_altTokens) {
2097 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->put_altTokens(1, 2, 3));
2098 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2099 }
2100
2101 TEST_F(AppBundleStatePausedUserTest, initialize) {
2102 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->initialize());
2103 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2104 }
2105
2106 TEST_F(AppBundleStatePausedUserTest, createApp) {
2107 App* app = NULL;
2108 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2109 app_bundle_->createApp(CComBSTR(kGuid1), &app));
2110 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2111 }
2112
2113 TEST_F(AppBundleStatePausedUserTest, createInstalledApp) {
2114 CreateClientsKeyForApp1();
2115
2116 App* app = NULL;
2117 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2118 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
2119 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2120 }
2121
2122 TEST_F(AppBundleStatePausedUserTest, createAllInstalledApps) {
2123 CreateClientsKeyForApp1();
2124
2125 App* app = NULL;
2126 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2127 app_bundle_->createAllInstalledApps());
2128 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2129 }
2130
2131 TEST_F(AppBundleStatePausedUserTest, checkForUpdate) {
2132 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
2133 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2134 }
2135
2136 TEST_F(AppBundleStatePausedUserTest, download) {
2137 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->download());
2138 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2139 }
2140
2141 TEST_F(AppBundleStatePausedUserTest, install) {
2142 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->install());
2143 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2144 }
2145
2146 TEST_F(AppBundleStatePausedUserTest, updateAllApps) {
2147 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->updateAllApps());
2148 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2149 }
2150
2151 // This may change when implemented.
2152 TEST_F(AppBundleStatePausedUserTest, stop) {
2153 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->stop());
2154 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2155 }
2156
2157 TEST_F(AppBundleStatePausedUserTest, pause) {
2158 EXPECT_SUCCEEDED(app_bundle_->pause());
2159 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2160 }
2161
2162 TEST_F(AppBundleStatePausedUserTest, resume_Succeeds_AsyncCallNotCompleted) {
2163 EXPECT_CALL(*worker_, Resume(app_bundle_.get()))
2164 .WillOnce(Return(S_OK));
2165
2166 EXPECT_SUCCEEDED(app_bundle_->resume());
2167 EXPECT_EQ(STATE_BUSY, GetBundleState());
2168 }
2169
2170 TEST_F(AppBundleStatePausedUserTest, resume_Succeeds_AsyncCallCompleted) {
2171 DummyUserWorkItem dummy_work_item;
2172 app_bundle_->set_user_work_item(&dummy_work_item);
2173 app_bundle_->CompleteAsyncCall();
2174
2175 EXPECT_CALL(*worker_, Resume(app_bundle_.get()))
2176 .WillOnce(Return(S_OK));
2177
2178 EXPECT_SUCCEEDED(app_bundle_->resume());
2179 EXPECT_EQ(STATE_READY, GetBundleState());
2180 }
2181
2182 TEST_F(AppBundleStatePausedUserTest, resume_Fails_AsyncCallNotCompleted) {
2183 EXPECT_CALL(*worker_, Resume(app_bundle_.get()))
2184 .WillOnce(Return(kKnownError));
2185
2186 EXPECT_EQ(kKnownError, app_bundle_->resume());
2187 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2188 }
2189
2190 TEST_F(AppBundleStatePausedUserTest, resume_Fails_AsyncCallCompleted) {
2191 DummyUserWorkItem dummy_work_item;
2192 app_bundle_->set_user_work_item(&dummy_work_item);
2193 app_bundle_->CompleteAsyncCall();
2194
2195 EXPECT_CALL(*worker_, Resume(app_bundle_.get()))
2196 .WillOnce(Return(kKnownError));
2197
2198 EXPECT_EQ(kKnownError, app_bundle_->resume());
2199 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2200 }
2201
2202 TEST_F(AppBundleStatePausedUserTest, isBusy) {
2203 VARIANT_BOOL is_busy = VARIANT_TRUE;
2204 EXPECT_SUCCEEDED(app_bundle_->isBusy(&is_busy));
2205 EXPECT_EQ(VARIANT_FALSE, is_busy);
2206 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2207 }
2208
2209 TEST_F(AppBundleStatePausedUserTest, downloadPackage) {
2210 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2211 app_bundle_->downloadPackage(CComBSTR(kGuid1),
2212 CComBSTR(_T("package"))));
2213 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2214 }
2215
2216 TEST_F(AppBundleStatePausedUserTest, get_currentState) {
2217 VARIANT current_state;
2218 ExpectAsserts expect_asserts; // Not yet implemented.
2219 EXPECT_EQ(E_NOTIMPL, app_bundle_->get_currentState(&current_state));
2220 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2221 }
2222
2223 // Remains Paused until resumed.
2224 TEST_F(AppBundleStatePausedUserTest, CompleteAsyncCall) {
2225 DummyUserWorkItem dummy_work_item;
2226 app_bundle_->set_user_work_item(&dummy_work_item);
2227 SetAppBundleStateForUnitTest(app_bundle_.get(),
2228 new fsm::AppBundleStatePaused);
2229
2230 app_bundle_->CompleteAsyncCall();
2231
2232 EXPECT_EQ(STATE_PAUSED, GetBundleState());
2233 }
2234
2235 // Stopped.
2236
2237 TEST_F(AppBundleStateStoppedUserTest, Properties) {
2238 TestPropertyReflexiveness();
2239 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2240 }
2241
2242 TEST_F(AppBundleStateStoppedUserTest, CountAndItem) {
2243 long num_apps = 0; // NOLINT
2244 EXPECT_SUCCEEDED(app_bundle_->get_Count(&num_apps));
2245 EXPECT_EQ(0, num_apps);
2246
2247 App* app0_obtained = NULL;
2248 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_INVALID_INDEX),
2249 app_bundle_->get_Item(0, &app0_obtained));
2250 EXPECT_FALSE(app0_obtained);
2251
2252 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2253 }
2254
2255 TEST_F(AppBundleStateStoppedUserTest, put_altTokens) {
2256 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->put_altTokens(1, 2, 3));
2257 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2258 }
2259
2260 TEST_F(AppBundleStateStoppedUserTest, initialize) {
2261 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->initialize());
2262 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2263 }
2264
2265 TEST_F(AppBundleStateStoppedUserTest, createApp) {
2266 App* app = NULL;
2267 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2268 app_bundle_->createApp(CComBSTR(kGuid1), &app));
2269
2270 EXPECT_EQ(S_OK, app_bundle_->stop());
2271 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2272 }
2273
2274 TEST_F(AppBundleStateStoppedUserTest, createInstalledApp) {
2275 CreateClientsKeyForApp1();
2276
2277 App* app = NULL;
2278 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2279 app_bundle_->createInstalledApp(CComBSTR(kGuid1), &app));
2280 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2281 }
2282
2283 TEST_F(AppBundleStateStoppedUserTest, createAllInstalledApps) {
2284 CreateClientsKeyForApp1();
2285
2286 App* app = NULL;
2287 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2288 app_bundle_->createAllInstalledApps());
2289 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2290 }
2291
2292 TEST_F(AppBundleStateStoppedUserTest, checkForUpdate) {
2293 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->checkForUpdate());
2294 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2295 }
2296
2297 TEST_F(AppBundleStateStoppedUserTest, download) {
2298 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->download());
2299 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2300 }
2301
2302 TEST_F(AppBundleStateStoppedUserTest, install) {
2303 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->install());
2304 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2305 }
2306
2307 TEST_F(AppBundleStateStoppedUserTest, updateAllApps) {
2308 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->updateAllApps());
2309 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2310 }
2311
2312 TEST_F(AppBundleStateStoppedUserTest, stop) {
2313 EXPECT_EQ(S_OK, app_bundle_->stop());
2314 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2315 }
2316
2317 TEST_F(AppBundleStateStoppedUserTest, pause) {
2318 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->pause());
2319 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2320 }
2321
2322 TEST_F(AppBundleStateStoppedUserTest, resume) {
2323 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED, app_bundle_->resume());
2324 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2325 }
2326
2327 TEST_F(AppBundleStateStoppedUserTest, isBusy) {
2328 VARIANT_BOOL is_busy = VARIANT_TRUE;
2329 EXPECT_SUCCEEDED(app_bundle_->isBusy(&is_busy));
2330 EXPECT_EQ(VARIANT_FALSE, is_busy);
2331 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2332 }
2333
2334 TEST_F(AppBundleStateStoppedUserTest, downloadPackage) {
2335 EXPECT_EQ(GOOPDATE_E_CALL_UNEXPECTED,
2336 app_bundle_->downloadPackage(CComBSTR(kGuid1),
2337 CComBSTR(_T("package"))));
2338 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2339 }
2340
2341 TEST_F(AppBundleStateStoppedUserTest, get_currentState) {
2342 VARIANT current_state;
2343 ExpectAsserts expect_asserts; // Not yet implemented.
2344 EXPECT_EQ(E_NOTIMPL, app_bundle_->get_currentState(&current_state));
2345 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2346 }
2347
2348 TEST_F(AppBundleStateStoppedUserTest, CompleteAsyncCall) {
2349 DummyUserWorkItem dummy_work_item;
2350 app_bundle_->set_user_work_item(&dummy_work_item);
2351
2352 app_bundle_->CompleteAsyncCall();
2353
2354 EXPECT_EQ(STATE_STOPPED, GetBundleState());
2355 }
2356
2357 } // namespace omaha
OLDNEW
« no previous file with comments | « goopdate/app_bundle_state_stopped.cc ('k') | goopdate/app_command.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698