1 // Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
2 // Use of this source code is governed by an apache-2.0 license that can be
3 // found in the LICENSE file.
5 #include <boost/filesystem/operations.hpp>
6 #include <boost/filesystem/path.hpp>
7 #include <boost/range/iterator_range.hpp>
8 #include <boost/system/error_code.hpp>
9 #include <common/paths.h>
10 #include <common/pkgmgr_interface.h>
11 #include <common/pkgmgr_query.h>
12 #include <common/request.h>
13 #include <common/step/configuration/step_fail.h>
14 #include <common/tzip_interface.h>
15 #include <common/utils/subprocess.h>
16 #include <gtest/gtest.h>
17 #include <gtest/gtest-death-test.h>
18 #include <pkgmgr-info.h>
21 #include <tzplatform_config.h>
28 #include "hybrid/hybrid_installer.h"
29 #include "wgt/wgt_app_query_interface.h"
30 #include "wgt/wgt_installer.h"
32 #define SIZEOFARRAY(ARR) \
33 sizeof(ARR) / sizeof(ARR[0]) \
35 namespace bf = boost::filesystem;
36 namespace bs = boost::system;
37 namespace ci = common_installer;
41 const bf::path kSmokePackagesDirectory =
42 "/usr/share/wgt-backend-ut/test_samples/smoke/";
44 const char kApplicationDir[] = ".applications";
45 const char kApplicationDirBackup[] = ".applications.bck";
46 const char KUserAppsDir[] = "apps_rw";
47 const char KUserAppsDirBackup[] = "apps_rw.bck";
49 enum class RequestResult {
54 class ScopedTzipInterface {
56 explicit ScopedTzipInterface(const std::string& pkgid)
57 : pkg_path_(bf::path(ci::GetRootAppPath(false)) / pkgid),
58 interface_(ci::GetMountLocation(pkg_path_)) {
59 interface_.MountZip(ci::GetZipPackageLocation(pkg_path_, pkgid));
62 ~ScopedTzipInterface() {
63 interface_.UnmountZip();
68 ci::TzipInterface interface_;
71 class TestPkgmgrInstaller : public ci::PkgmgrInstallerInterface {
73 bool CreatePkgMgrInstaller(pkgmgr_installer** installer,
74 ci::InstallationMode* mode) {
75 *installer = pkgmgr_installer_offline_new();
78 *mode = ci::InstallationMode::ONLINE;
82 bool ShouldCreateSignal() const {
87 enum class PackageType {
92 bool TouchFile(const bf::path& path) {
93 FILE* f = fopen(path.c_str(), "w+");
100 void RemoveAllRecoveryFiles() {
101 bf::path root_path = ci::GetRootAppPath(false);
102 if (!bf::exists(root_path))
104 for (auto& dir_entry : boost::make_iterator_range(
105 bf::directory_iterator(root_path), bf::directory_iterator())) {
106 if (bf::is_regular_file(dir_entry)) {
107 if (dir_entry.path().string().find("/recovery") != std::string::npos) {
108 bs::error_code error;
109 bf::remove(dir_entry.path(), error);
115 bf::path FindRecoveryFile() {
116 bf::path root_path = ci::GetRootAppPath(false);
117 for (auto& dir_entry : boost::make_iterator_range(
118 bf::directory_iterator(root_path), bf::directory_iterator())) {
119 if (bf::is_regular_file(dir_entry)) {
120 if (dir_entry.path().string().find("/recovery") != std::string::npos) {
121 return dir_entry.path();
128 bool ValidateFileContentInPackage(const std::string& pkgid,
129 const std::string& relative,
130 const std::string& expected) {
131 bf::path root_path = ci::GetRootAppPath(false);
132 bf::path file_path = root_path / pkgid / relative;
133 if (!bf::exists(file_path)) {
134 LOG(ERROR) << file_path << " doesn't exist";
137 FILE* handle = fopen(file_path.c_str(), "r");
139 LOG(ERROR) << file_path << " cannot be open";
143 std::array<char, 200> buffer;
144 while (fgets(buffer.data(), buffer.size(), handle)) {
145 content += buffer.data();
148 return content == expected;
151 void ValidatePackageFS(const std::string& pkgid,
152 const std::vector<std::string>& appids) {
153 bf::path root_path = ci::GetRootAppPath(false);
154 bf::path package_path = root_path / pkgid;
155 bf::path data_path = package_path / "data";
156 bf::path shared_path = package_path / "shared";
157 bf::path cache_path = package_path / "cache";
158 ASSERT_TRUE(bf::exists(root_path));
159 ASSERT_TRUE(bf::exists(package_path));
160 ASSERT_TRUE(bf::exists(data_path));
161 ASSERT_TRUE(bf::exists(shared_path));
162 ASSERT_TRUE(bf::exists(cache_path));
164 bf::path manifest_path =
165 bf::path(getUserManifestPath(getuid(), false)) / (pkgid + ".xml");
166 ASSERT_TRUE(bf::exists(manifest_path));
168 for (auto& appid : appids) {
169 bf::path binary_path = package_path / "bin" / appid;
170 ASSERT_TRUE(bf::exists(binary_path));
172 bf::path(getIconPath(getuid(), false)) / (appid + ".png");
173 ASSERT_TRUE(bf::exists(icon_path));
174 bf::path icon_backup = ci::GetBackupPathForIconFile(icon_path);
175 ASSERT_FALSE(bf::exists(icon_backup));
178 bf::path widget_root_path = package_path / "res" / "wgt";
179 bf::path config_path = widget_root_path / "config.xml";
180 ASSERT_TRUE(bf::exists(widget_root_path));
181 ASSERT_TRUE(bf::exists(config_path));
183 bf::path private_tmp_path = package_path / "tmp";
184 ASSERT_TRUE(bf::exists(private_tmp_path));
186 // backups should not exist
187 bf::path package_backup = ci::GetBackupPathForPackagePath(package_path);
188 bf::path manifest_backup = ci::GetBackupPathForManifestFile(manifest_path);
189 ASSERT_FALSE(bf::exists(package_backup));
190 ASSERT_FALSE(bf::exists(manifest_backup));
193 void PackageCheckCleanup(const std::string& pkgid,
194 const std::vector<std::string>& appids) {
195 bf::path root_path = ci::GetRootAppPath(false);
196 bf::path package_path = root_path / pkgid;
197 ASSERT_FALSE(bf::exists(package_path));
199 bf::path manifest_path =
200 bf::path(getUserManifestPath(getuid(), false)) / (pkgid + ".xml");
201 ASSERT_FALSE(bf::exists(manifest_path));
203 for (auto& appid : appids) {
205 bf::path(getIconPath(getuid(), false)) / (appid + ".png");
206 ASSERT_FALSE(bf::exists(icon_path));
207 bf::path icon_backup = ci::GetBackupPathForIconFile(icon_path);
208 ASSERT_FALSE(bf::exists(icon_backup));
211 // backups should not exist
212 bf::path package_backup = ci::GetBackupPathForPackagePath(package_path);
213 bf::path manifest_backup = ci::GetBackupPathForManifestFile(manifest_path);
214 ASSERT_FALSE(bf::exists(package_backup));
215 ASSERT_FALSE(bf::exists(manifest_backup));
218 void ValidatePackage(const std::string& pkgid,
219 const std::vector<std::string>& appids) {
220 ASSERT_TRUE(ci::QueryIsPackageInstalled(pkgid, ci::GetRequestMode()));
221 ValidatePackageFS(pkgid, appids);
224 void CheckPackageNonExistance(const std::string& pkgid,
225 const std::vector<std::string>& appids) {
226 ASSERT_FALSE(ci::QueryIsPackageInstalled(pkgid, ci::GetRequestMode()));
227 PackageCheckCleanup(pkgid, appids);
230 std::unique_ptr<ci::AppQueryInterface> CreateQueryInterface() {
231 std::unique_ptr<ci::AppQueryInterface> query_interface(
232 new wgt::WgtAppQueryInterface());
233 return query_interface;
236 std::unique_ptr<ci::AppInstaller> CreateInstaller(ci::PkgMgrPtr pkgmgr,
239 case PackageType::WGT:
240 return std::unique_ptr<ci::AppInstaller>(new wgt::WgtInstaller(pkgmgr));
241 case PackageType::HYBRID:
242 return std::unique_ptr<ci::AppInstaller>(
243 new hybrid::HybridInstaller(pkgmgr));
245 LOG(ERROR) << "Unknown installer type";
250 ci::AppInstaller::Result RunInstallerWithPkgrmgr(ci::PkgMgrPtr pkgmgr,
252 RequestResult mode) {
253 std::unique_ptr<ci::AppInstaller> installer = CreateInstaller(pkgmgr, type);
255 case RequestResult::FAIL:
256 installer->AddStep<ci::configuration::StepFail>();
261 return installer->Run();
263 ci::AppInstaller::Result CallBackend(int argc,
266 RequestResult mode = RequestResult::NORMAL
268 TestPkgmgrInstaller pkgmgr_installer;
269 std::unique_ptr<ci::AppQueryInterface> query_interface =
270 CreateQueryInterface();
272 ci::PkgMgrInterface::Create(argc, const_cast<char**>(argv),
273 &pkgmgr_installer, query_interface.get());
275 LOG(ERROR) << "Failed to initialize pkgmgr interface";
276 return ci::AppInstaller::Result::UNKNOWN;
278 return RunInstallerWithPkgrmgr(pkgmgr, type, mode);
281 ci::AppInstaller::Result Install(const bf::path& path,
283 RequestResult mode = RequestResult::NORMAL) {
284 const char* argv[] = {"", "-i", path.c_str()};
285 return CallBackend(SIZEOFARRAY(argv), argv, type, mode);
288 ci::AppInstaller::Result Update(const bf::path& path_old,
289 const bf::path& path_new,
291 RequestResult mode = RequestResult::NORMAL) {
292 if (Install(path_old, type) != ci::AppInstaller::Result::OK) {
293 LOG(ERROR) << "Failed to install application. Cannot update";
294 return ci::AppInstaller::Result::UNKNOWN;
296 return Install(path_new, type, mode);
299 ci::AppInstaller::Result MountInstall(const bf::path& path,
300 PackageType type, RequestResult mode = RequestResult::NORMAL) {
301 const char* argv[] = {"", "-w", path.c_str()};
302 return CallBackend(SIZEOFARRAY(argv), argv, type, mode);
305 ci::AppInstaller::Result MountUpdate(const bf::path& path_old,
306 const bf::path& path_new, PackageType type,
307 RequestResult mode = RequestResult::NORMAL) {
308 if (MountInstall(path_old, type) != ci::AppInstaller::Result::OK) {
309 LOG(ERROR) << "Failed to mount-install application. Cannot mount-update";
310 return ci::AppInstaller::Result::UNKNOWN;
312 return MountInstall(path_new, type, mode);
315 ci::AppInstaller::Result Uninstall(const std::string& pkgid,
317 RequestResult mode = RequestResult::NORMAL) {
318 const char* argv[] = {"", "-d", pkgid.c_str()};
319 return CallBackend(SIZEOFARRAY(argv), argv, type, mode);
322 ci::AppInstaller::Result Reinstall(const bf::path& path,
323 const bf::path& delta_dir,
325 RequestResult mode = RequestResult::NORMAL) {
326 if (Install(path, type) != ci::AppInstaller::Result::OK) {
327 LOG(ERROR) << "Failed to install application. Cannot perform RDS";
328 return ci::AppInstaller::Result::UNKNOWN;
330 const char* argv[] = {"", "-r", delta_dir.c_str()};
331 return CallBackend(SIZEOFARRAY(argv), argv, type, mode);
334 ci::AppInstaller::Result DeltaInstall(const bf::path& path,
335 const bf::path& delta_package, PackageType type) {
336 if (Install(path, type) != ci::AppInstaller::Result::OK) {
337 LOG(ERROR) << "Failed to install application. Cannot perform delta update";
338 return ci::AppInstaller::Result::UNKNOWN;
340 return Install(delta_package, type);
343 ci::AppInstaller::Result Clear(const std::string& pkgid,
345 RequestResult mode = RequestResult::NORMAL) {
346 const char* argv[] = {"", "-c", pkgid.c_str()};
347 return CallBackend(SIZEOFARRAY(argv), argv, type, mode);
350 ci::AppInstaller::Result EnablePackage(const std::string& pkgid,
352 RequestResult mode = RequestResult::NORMAL) {
353 const char* argv[] = {"", "-A", pkgid.c_str()};
354 return CallBackend(SIZEOFARRAY(argv), argv, type, mode);
357 ci::AppInstaller::Result DisablePackage(const std::string& pkgid,
359 RequestResult mode = RequestResult::NORMAL) {
360 const char* argv[] = {"", "-D", pkgid.c_str()};
361 return CallBackend(SIZEOFARRAY(argv), argv, type, mode);
364 ci::AppInstaller::Result Recover(const bf::path& recovery_file,
366 RequestResult mode = RequestResult::NORMAL) {
367 const char* argv[] = {"", "-b", recovery_file.c_str()};
368 TestPkgmgrInstaller pkgmgr_installer;
369 std::unique_ptr<ci::AppQueryInterface> query_interface =
370 CreateQueryInterface();
372 ci::PkgMgrInterface::Create(SIZEOFARRAY(argv), const_cast<char**>(argv),
373 &pkgmgr_installer, query_interface.get());
375 LOG(ERROR) << "Failed to initialize pkgmgr interface";
376 return ci::AppInstaller::Result::UNKNOWN;
378 return RunInstallerWithPkgrmgr(pkgmgr, type, mode);
383 namespace common_installer {
385 class SmokeEnvironment : public testing::Environment {
387 explicit SmokeEnvironment(const bf::path& home) : home_(home) {
389 void SetUp() override {
390 bs::error_code error;
391 bf::remove_all(home_ / kApplicationDirBackup, error);
392 bf::remove_all(home_ / KUserAppsDirBackup, error);
393 if (bf::exists(home_ / KUserAppsDir)) {
394 bf::rename(home_ / KUserAppsDir, home_ / KUserAppsDirBackup, error);
396 LOG(ERROR) << "Failed to setup test environment. Does some previous"
397 << " test crashed? Directory: "
398 << (home_ / KUserAppsDirBackup) << " should not exist.";
401 if (bf::exists(home_ / kApplicationDir)) {
402 bf::rename(home_ / kApplicationDir, home_ / kApplicationDirBackup, error);
404 LOG(ERROR) << "Failed to setup test environment. Does some previous"
405 << " test crashed? Directory: "
406 << (home_ / kApplicationDirBackup) << " should not exist.";
410 void TearDown() override {
411 bs::error_code error;
412 bf::remove_all(home_ / kApplicationDir, error);
413 bf::remove_all(home_ / KUserAppsDir, error);
414 if (bf::exists(home_ / KUserAppsDirBackup))
415 bf::rename(home_ / KUserAppsDirBackup, home_ / KUserAppsDir, error);
416 if (bf::exists(home_ / kApplicationDirBackup))
417 bf::rename(home_ / kApplicationDirBackup, home_ / kApplicationDir, error);
424 class SmokeTest : public testing::Test {
427 TEST_F(SmokeTest, InstallationMode) {
428 bf::path path = kSmokePackagesDirectory / "InstallationMode.wgt";
429 std::string pkgid = "smokeapp03";
430 std::string appid = "smokeapp03.InstallationMode";
431 ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK);
432 ValidatePackage(pkgid, {appid});
435 TEST_F(SmokeTest, UpdateMode) {
436 bf::path path_old = kSmokePackagesDirectory / "UpdateMode.wgt";
437 bf::path path_new = kSmokePackagesDirectory / "UpdateMode_2.wgt";
438 std::string pkgid = "smokeapp04";
439 std::string appid = "smokeapp04.UpdateMode";
440 ASSERT_EQ(Update(path_old, path_new, PackageType::WGT),
441 ci::AppInstaller::Result::OK);
442 ValidatePackage(pkgid, {appid});
444 ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n"));
447 TEST_F(SmokeTest, DeinstallationMode) {
448 bf::path path = kSmokePackagesDirectory / "DeinstallationMode.wgt";
449 std::string pkgid = "smokeapp05";
450 std::string appid = "smokeapp05.DeinstallationMode";
451 ASSERT_EQ(Install(path, PackageType::WGT),
452 ci::AppInstaller::Result::OK);
453 ASSERT_EQ(Uninstall(pkgid, PackageType::WGT), ci::AppInstaller::Result::OK);
454 CheckPackageNonExistance(pkgid, {appid});
457 TEST_F(SmokeTest, RDSMode) {
458 bf::path path = kSmokePackagesDirectory / "RDSMode.wgt";
459 bf::path delta_directory = kSmokePackagesDirectory / "delta_dir/";
460 std::string pkgid = "smokeapp11";
461 std::string appid = "smokeapp11.RDSMode";
462 ASSERT_EQ(Reinstall(path, delta_directory, PackageType::WGT),
463 ci::AppInstaller::Result::OK);
464 ValidatePackage(pkgid, {appid});
466 // Check delta modifications
467 bf::path root_path = ci::GetRootAppPath(false);
468 ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "DELETED"));
469 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "ADDED"));
470 ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "2\n");
473 TEST_F(SmokeTest, EnablePkg) {
474 bf::path path = kSmokePackagesDirectory / "EnablePkg.wgt";
475 std::string pkgid = "smokeapp22";
476 ASSERT_EQ(Install(path, PackageType::WGT),
477 ci::AppInstaller::Result::OK);
478 ASSERT_EQ(DisablePackage(pkgid, PackageType::WGT),
479 ci::AppInstaller::Result::OK);
480 ASSERT_EQ(EnablePackage(pkgid, PackageType::WGT),
481 ci::AppInstaller::Result::OK);
483 ASSERT_TRUE(ci::QueryIsPackageInstalled(pkgid, ci::GetRequestMode()));
486 TEST_F(SmokeTest, DisablePkg) {
487 bf::path path = kSmokePackagesDirectory / "DisablePkg.wgt";
488 std::string pkgid = "smokeapp21";
489 std::string appid = "smokeapp21.DisablePkg";
490 ASSERT_EQ(Install(path, PackageType::WGT),
491 ci::AppInstaller::Result::OK);
492 ASSERT_EQ(DisablePackage(pkgid, PackageType::WGT),
493 ci::AppInstaller::Result::OK);
494 ASSERT_FALSE(ci::QueryIsPackageInstalled(pkgid, ci::GetRequestMode()));
495 ValidatePackageFS(pkgid, {appid});
498 TEST_F(SmokeTest, ClearMode) {
499 bf::path path = kSmokePackagesDirectory / "ClearMode.wgt";
500 std::string pkgid = "smokeapp20";
501 std::string appid = "smokeapp20.ClearMode";
502 ASSERT_EQ(Install(path, PackageType::WGT),
503 ci::AppInstaller::Result::OK);
504 bf::path root_path = ci::GetRootAppPath(false);
505 bs::error_code error;
506 bf::create_directory(root_path / pkgid / "data" / "dir", error);
508 ASSERT_TRUE(TouchFile(root_path / pkgid / "data" / "dir" / "file"));
509 ASSERT_TRUE(TouchFile(root_path / pkgid / "data" / "file"));
510 ASSERT_EQ(Clear(pkgid, PackageType::WGT), ci::AppInstaller::Result::OK);
511 ValidatePackage(pkgid, {appid});
512 ASSERT_FALSE(bf::exists(root_path / pkgid / "data" / "dir" / "file"));
513 ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "file"));
516 TEST_F(SmokeTest, DeltaMode) {
517 bf::path path = kSmokePackagesDirectory / "DeltaMode.wgt";
518 bf::path delta_package = kSmokePackagesDirectory / "DeltaMode.delta";
519 std::string pkgid = "smokeapp17";
520 std::string appid = "smokeapp17.DeltaMode";
521 ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::WGT),
522 ci::AppInstaller::Result::OK);
523 ValidatePackage(pkgid, {appid});
525 // Check delta modifications
526 bf::path root_path = ci::GetRootAppPath(false);
527 ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "DELETED"));
528 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "ADDED"));
529 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "css" / "style.css")); // NOLINT
530 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "images" / "tizen_32.png")); // NOLINT
531 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "js" / "main.js"));
532 ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "version 2\n");
535 TEST_F(SmokeTest, RecoveryMode_ForInstallation) {
536 bf::path path = kSmokePackagesDirectory / "RecoveryMode_ForInstallation.wgt";
537 Subprocess backend_crash("/usr/bin/wgt-backend-ut/smoke-test-helper");
538 backend_crash.Run("-i", path.string());
539 ASSERT_NE(backend_crash.Wait(), 0);
541 std::string pkgid = "smokeapp09";
542 std::string appid = "smokeapp09.RecoveryModeForInstallation";
543 bf::path recovery_file = FindRecoveryFile();
544 ASSERT_FALSE(recovery_file.empty());
545 ASSERT_EQ(Recover(recovery_file, PackageType::WGT),
546 ci::AppInstaller::Result::OK);
547 CheckPackageNonExistance(pkgid, {appid});
550 TEST_F(SmokeTest, RecoveryMode_ForUpdate) {
551 bf::path path_old = kSmokePackagesDirectory / "RecoveryMode_ForUpdate.wgt";
552 bf::path path_new = kSmokePackagesDirectory / "RecoveryMode_ForUpdate_2.wgt";
553 RemoveAllRecoveryFiles();
554 Subprocess backend_test("/usr/bin/wgt-backend");
555 backend_test.Run("-i", path_old.string());
556 ASSERT_EQ(backend_test.Wait(), 0);
557 Subprocess backend_crash("/usr/bin/wgt-backend-ut/smoke-test-helper");
558 backend_crash.Run("-i", path_new.string());
559 ASSERT_NE(backend_crash.Wait(), 0);
561 std::string pkgid = "smokeapp10";
562 std::string appid = "smokeapp10.RecoveryModeForUpdate";
563 bf::path recovery_file = FindRecoveryFile();
564 ASSERT_FALSE(recovery_file.empty());
565 ASSERT_EQ(Recover(recovery_file, PackageType::WGT),
566 ci::AppInstaller::Result::OK);
567 ValidatePackage(pkgid, {appid});
569 ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n"));
572 TEST_F(SmokeTest, InstallationMode_GoodSignature) {
573 bf::path path = kSmokePackagesDirectory / "InstallationMode_GoodSignature.wgt"; // NOLINT
574 ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK);
577 TEST_F(SmokeTest, InstallationMode_WrongSignature) {
578 bf::path path = kSmokePackagesDirectory / "InstallationMode_WrongSignature.wgt"; // NOLINT
579 ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::ERROR);
582 TEST_F(SmokeTest, InstallationMode_Rollback) {
583 bf::path path = kSmokePackagesDirectory / "InstallationMode_Rollback.wgt";
584 std::string pkgid = "smokeapp06";
585 std::string appid = "smokeapp06.InstallationModeRollback";
586 ASSERT_EQ(Install(path, PackageType::WGT, RequestResult::FAIL),
587 ci::AppInstaller::Result::ERROR);
588 CheckPackageNonExistance(pkgid, {appid});
591 TEST_F(SmokeTest, UpdateMode_Rollback) {
592 bf::path path_old = kSmokePackagesDirectory / "UpdateMode_Rollback.wgt";
593 bf::path path_new = kSmokePackagesDirectory / "UpdateMode_Rollback_2.wgt";
594 std::string pkgid = "smokeapp07";
595 std::string appid = "smokeapp07.UpdateModeRollback";
596 ASSERT_EQ(Update(path_old, path_new, PackageType::WGT, RequestResult::FAIL),
597 ci::AppInstaller::Result::ERROR);
598 ValidatePackage(pkgid, {appid});
600 ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n"));
603 TEST_F(SmokeTest, InstallationMode_Hybrid) {
604 bf::path path = kSmokePackagesDirectory / "InstallationMode_Hybrid.wgt";
605 std::string pkgid = "smokehyb01";
606 std::string appid1 = "smokehyb01.Web";
607 std::string appid2 = "smokehyb01.Native";
608 ASSERT_EQ(Install(path, PackageType::HYBRID), ci::AppInstaller::Result::OK);
609 ValidatePackage(pkgid, {appid1, appid2});
612 TEST_F(SmokeTest, UpdateMode_Hybrid) {
613 bf::path path_old = kSmokePackagesDirectory / "UpdateMode_Hybrid.wgt";
614 bf::path path_new = kSmokePackagesDirectory / "UpdateMode_Hybrid_2.wgt";
615 std::string pkgid = "smokehyb02";
616 std::string appid1 = "smokehyb02.Web";
617 std::string appid2 = "smokehyb02.Native";
618 ASSERT_EQ(Update(path_old, path_new, PackageType::HYBRID),
619 ci::AppInstaller::Result::OK);
620 ValidatePackage(pkgid, {appid1, appid2});
622 ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n"));
623 ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "VERSION", "2\n"));
626 TEST_F(SmokeTest, DeinstallationMode_Hybrid) {
627 bf::path path = kSmokePackagesDirectory / "DeinstallationMode_Hybrid.wgt";
628 std::string pkgid = "smokehyb03";
629 std::string appid1 = "smokehyb03.Web";
630 std::string appid2 = "smokehyb03.Native";
631 ASSERT_EQ(Install(path, PackageType::HYBRID),
632 ci::AppInstaller::Result::OK);
633 ASSERT_EQ(Uninstall(pkgid, PackageType::WGT), ci::AppInstaller::Result::OK);
634 CheckPackageNonExistance(pkgid, {appid1, appid2});
637 TEST_F(SmokeTest, DeltaMode_Hybrid) {
638 bf::path path = kSmokePackagesDirectory / "DeltaMode_Hybrid.wgt";
639 bf::path delta_package = kSmokePackagesDirectory / "DeltaMode_Hybrid.delta";
640 std::string pkgid = "smokehyb04";
641 std::string appid1 = "smokehyb04.Web";
642 std::string appid2 = "smokehyb04.Native";
643 ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::HYBRID),
644 ci::AppInstaller::Result::OK);
645 ValidatePackage(pkgid, {appid1, appid2});
647 // Check delta modifications
648 bf::path root_path = ci::GetRootAppPath(false);
649 ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "DELETED"));
650 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "ADDED"));
651 ASSERT_FALSE(bf::exists(root_path / pkgid / "lib" / "DELETED"));
652 ASSERT_TRUE(bf::exists(root_path / pkgid / "lib" / "ADDED"));
653 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "css" / "style.css")); // NOLINT
654 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "images" / "tizen_32.png")); // NOLINT
655 ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "js" / "main.js"));
656 ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "version 2\n");
657 ValidateFileContentInPackage(pkgid, "lib/MODIFIED", "version 2\n");
660 TEST_F(SmokeTest, MountInstallationMode) {
661 bf::path path = kSmokePackagesDirectory / "MountInstallationMode.wgt";
662 std::string pkgid = "smokeapp28";
663 std::string appid = "smokeapp28.InstallationMode";
664 ASSERT_EQ(MountInstall(path, PackageType::WGT), ci::AppInstaller::Result::OK);
665 ScopedTzipInterface interface(pkgid);
666 ValidatePackage(pkgid, {appid});
669 TEST_F(SmokeTest, MountUpdateMode) {
670 bf::path path_old = kSmokePackagesDirectory / "MountUpdateMode.wgt";
671 bf::path path_new = kSmokePackagesDirectory / "MountUpdateMode_2.wgt";
672 std::string pkgid = "smokeapp29";
673 std::string appid = "smokeapp29.UpdateMode";
674 ASSERT_EQ(MountUpdate(path_old, path_new, PackageType::WGT),
675 ci::AppInstaller::Result::OK);
676 ScopedTzipInterface interface(pkgid);
677 ValidatePackage(pkgid, {appid});
679 ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n"));
682 } // namespace common_installer
684 int main(int argc, char** argv) {
685 testing::InitGoogleTest(&argc, argv);
686 const char* directory = getenv("HOME");
688 LOG(ERROR) << "Cannot get $HOME value";
691 testing::AddGlobalTestEnvironment(
692 new common_installer::SmokeEnvironment(directory));
693 return RUN_ALL_TESTS();