X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Funit_tests%2Fsmoke_test.cc;h=0fb52ff6b10c9cc39e931aa8b29ad5e4b517bfdc;hb=374fdf81f016d0c6ea717c87aceffc57c12955d3;hp=39d8dd75966188e9c4a1efe39680ed94f4bacfda;hpb=d372a85c569cba6384e8dcebbc21df80bdda939a;p=platform%2Fcore%2Fappfw%2Fwgt-backend.git diff --git a/src/unit_tests/smoke_test.cc b/src/unit_tests/smoke_test.cc index 39d8dd7..0fb52ff 100644 --- a/src/unit_tests/smoke_test.cc +++ b/src/unit_tests/smoke_test.cc @@ -6,22 +6,35 @@ #include #include #include -#include +#include + +#include #include -#include +#include #include -#include +#include +#include +#include +#include +#include + #include #include #include #include #include #include +#include +#include +#include #include #include #include +#include +#include +#include "hybrid/hybrid_installer.h" #include "wgt/wgt_app_query_interface.h" #include "wgt/wgt_installer.h" @@ -33,26 +46,127 @@ namespace bs = boost::system; namespace ci = common_installer; namespace { +ci::RequestMode kRequestMode = ci::RequestMode::GLOBAL; +const char *short_opts = "g:u"; +const struct option long_opts[] = { + { "request_mode", 1, NULL, 'r' }, + { 0, 0, 0, 0 } /* sentinel */ +}; +const char *request_modes[] { + "global", + "user" +}; +void ParseRequestMode(int argc, char** argv) { + int c; + int opt_idx = 0; + do { + c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx); + switch (c) { + case 'r': + if (strncmp(optarg, request_modes[0], strlen(request_modes[0])) == 0) + kRequestMode = ci::RequestMode::GLOBAL; + else if (strncmp(optarg, request_modes[1], strlen(request_modes[1])) == 0) + kRequestMode = ci::RequestMode::USER; + else + LOG(ERROR) << "Wrong request mode " << optarg + << ". Available: \"global\" or \"user\""; + break; + case 'g': + kRequestMode = ci::RequestMode::GLOBAL; + break; + case 'u': + kRequestMode = ci::RequestMode::USER; + break; + default: + break; + } + } while (c != -1); +} + +const uid_t kGlobalUserUid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER); +const uid_t kGlobalUserGid = tzplatform_getgid(TZ_SYS_GLOBALAPP_USER); +const uid_t kDefaultUserUid = tzplatform_getuid(TZ_SYS_DEFAULT_USER); +uid_t kTestUserId = kGlobalUserUid; +gid_t kTestGroupId = kGlobalUserGid; +std::string kTestUserIdStr = std::to_string(kTestUserId); +const char kNormalUserName[] = "smokeuser"; +const char kSystemShareGroupName[] = "system_share"; +const std::string& kDefaultUserIdStr = std::to_string(kDefaultUserUid); +const char kLegacyExtImageDir[] = "legacy_extimage_dir"; +const char kMigrateTestDBName[] = "app2sd_migrate.db"; const bf::path kSmokePackagesDirectory = "/usr/share/wgt-backend-ut/test_samples/smoke/"; -const char kApplicationDir[] = ".applications"; -const char kApplicationDirBackup[] = ".applications.bck"; -const char KUserAppsDir[] = "apps_rw"; -const char KUserAppsDirBackup[] = "apps_rw.bck"; +enum RWDirectory { + DATA, + CACHE, + SHARED_CACHE, + SHARED_DATA, + SHARED_TRUSTED +}; + +const char* rwDirectories[] = { + "data", + "cache", + "shared/cache", + "shared/data", + "shared/trusted", +}; + +// common entries +const std::vector kDBEntries = { + {".pkgmgr_parser.db"}, + {".pkgmgr_parser.db-journal"}, + {".pkgmgr_cert.db"}, + {".pkgmgr_cert.db-journal"}, + {".app2sd.db"}, + {".app2sd.db-journal"}, +}; +// globaluser entries +const char kGlobalManifestDir[] = "/opt/share/packages"; +const char kSkelDir[] = "/etc/skel/apps_rw"; +const char kPreloadApps[] = "/usr/apps"; +const char kPreloadManifestDir[] = "/usr/share/packages"; +const char kPreloadIcons[] = "/usr/share/icons"; enum class RequestResult { NORMAL, - FAIL, - CRASH + FAIL +}; + +class ScopedTzipInterface { + public: + explicit ScopedTzipInterface(const std::string& pkgid) + : pkg_path_(bf::path(ci::GetRootAppPath(false, + kTestUserId)) / pkgid), + interface_(ci::GetMountLocation(pkg_path_)), + mounted_(true) { + interface_.MountZip(ci::GetZipPackageLocation(pkg_path_, pkgid)); + } + + void Release() { + if (mounted_) { + interface_.UnmountZip(); + mounted_ = false; + } + } + + ~ScopedTzipInterface() { + Release(); + } + + private: + bf::path pkg_path_; + ci::TzipInterface interface_; + bool mounted_; }; class TestPkgmgrInstaller : public ci::PkgmgrInstallerInterface { public: bool CreatePkgMgrInstaller(pkgmgr_installer** installer, ci::InstallationMode* mode) { - *installer = pkgmgr_installer_new(); + *installer = pkgmgr_installer_offline_new(); if (!*installer) return false; *mode = ci::InstallationMode::ONLINE; @@ -64,27 +178,63 @@ class TestPkgmgrInstaller : public ci::PkgmgrInstallerInterface { } }; -class StepCrash : public ci::Step { - public: - using Step::Step; +enum class PackageType { + WGT, + HYBRID +}; + +bool TouchFile(const bf::path& path) { + FILE* f = fopen(path.c_str(), "w+"); + if (!f) + return false; + fclose(f); + return true; +} + +bool AddTestUser(const char *user_name) { + std::cout << "Adding test user: " << user_name << std::endl; + gboolean ret = ci::AddUser(user_name); + if (boost::optional uid = ci::GetUidByUserName(user_name)) { + kTestUserId = *uid; + kTestUserIdStr = std::to_string(kTestUserId); + std::cout << "User created properly: uid=" << *uid; + if (boost::optional gid = ci::GetGidByUid(*uid)) { + kTestGroupId = *gid; + std::cout << " gid=" << *gid; + } + std::cout << std::endl; + return true; + } + LOG(ERROR) << "Adding test user failed"; + return false; +} - ci::Step::Status process() override { - raise(SIGSEGV); - return Status::OK; +bool DeleteTestUser(const char *user_name) { + std::cout << "Deleting test user: " << user_name << std::endl; + uid_t test_uid; + if (boost::optional uid = ci::GetUidByUserName(user_name)) + test_uid = *uid; + gboolean ret = ci::DeleteUser(user_name, true); + if (boost::optional uid = ci::GetUidByUserName(user_name)); + else { + std::cout << "User deleted properly: user_name=" << user_name + << " uid=" << test_uid << std::endl; + return true; } - ci::Step::Status clean() override { return ci::Step::Status::OK; } - ci::Step::Status undo() override { return ci::Step::Status::OK; } - ci::Step::Status precheck() override { return ci::Step::Status::OK; } -}; + LOG(ERROR) << "Deleting test user failed"; + return false; +} void RemoveAllRecoveryFiles() { - bf::path root_path = ci::GetRootAppPath(false); + bf::path root_path = ci::GetRootAppPath(false, + kTestUserId); if (!bf::exists(root_path)) return; for (auto& dir_entry : boost::make_iterator_range( bf::directory_iterator(root_path), bf::directory_iterator())) { if (bf::is_regular_file(dir_entry)) { - if (dir_entry.path().string().find("/recovery") != std::string::npos) { + if (dir_entry.path().string().find("/wgt-recovery") + != std::string::npos) { bs::error_code error; bf::remove(dir_entry.path(), error); } @@ -93,11 +243,13 @@ void RemoveAllRecoveryFiles() { } bf::path FindRecoveryFile() { - bf::path root_path = ci::GetRootAppPath(false); + bf::path root_path = ci::GetRootAppPath(false, + kTestUserId); for (auto& dir_entry : boost::make_iterator_range( bf::directory_iterator(root_path), bf::directory_iterator())) { if (bf::is_regular_file(dir_entry)) { - if (dir_entry.path().string().find("/recovery") != std::string::npos) { + if (dir_entry.path().string().find("/wgt-recovery") + != std::string::npos) { return dir_entry.path(); } } @@ -105,11 +257,17 @@ bf::path FindRecoveryFile() { return {}; } +bf::path GetPackageRoot(const std::string& pkgid, uid_t uid) { + bf::path root_path = ci::GetRootAppPath(false, uid); + return root_path / pkgid; +} + bool ValidateFileContentInPackage(const std::string& pkgid, const std::string& relative, - const std::string& expected) { - bf::path root_path = ci::GetRootAppPath(false); - bf::path file_path = root_path / pkgid / relative; + const std::string& expected, + bool is_readonly = false) { + bf::path file_path = ci::GetRootAppPath(is_readonly, kTestUserId); + file_path = file_path / pkgid / relative; if (!bf::exists(file_path)) { LOG(ERROR) << file_path << " doesn't exist"; return false; @@ -128,25 +286,83 @@ bool ValidateFileContentInPackage(const std::string& pkgid, return content == expected; } -void ValidatePackageFS(const std::string& pkgid, const std::string& appid) { - bf::path root_path = ci::GetRootAppPath(false); +void AddDataFiles(const std::string& pkgid, uid_t uid) { + if (uid == kGlobalUserUid) { + ci::UserList list = ci::GetUserList(); + for (auto l : list) { + auto pkg_path = GetPackageRoot(pkgid, std::get<0>(l)); + ASSERT_TRUE(TouchFile(pkg_path / "data" / "file1.txt")); + ASSERT_TRUE(TouchFile(pkg_path / "data" / "file2.txt")); + } + } else { + auto pkg_path = GetPackageRoot(pkgid, uid); + ASSERT_TRUE(TouchFile(pkg_path / "data" / "file1.txt")); + ASSERT_TRUE(TouchFile(pkg_path / "data" / "file2.txt")); + } +} + +void ValidateDataFiles(const std::string& pkgid, uid_t uid) { + if (uid == kGlobalUserUid) { + ci::UserList list = ci::GetUserList(); + for (auto l : list) { + auto pkg_path = GetPackageRoot(pkgid, std::get<0>(l)); + ASSERT_TRUE(bf::exists(pkg_path / "data" / "file1.txt")); + ASSERT_TRUE(bf::exists(pkg_path / "data" / "file2.txt")); + } + } else { + auto pkg_path = GetPackageRoot(pkgid, uid); + ASSERT_TRUE(bf::exists(pkg_path / "data" / "file1.txt")); + ASSERT_TRUE(bf::exists(pkg_path / "data" / "file2.txt")); + } +} + +void ValidatePackageRWFS(const std::string& pkgid, uid_t uid) { + bf::path root_path = ci::GetRootAppPath(false, uid); + bf::path package_path = root_path / pkgid; + bf::path data_path = package_path / rwDirectories[DATA]; + bf::path cache_path = package_path / rwDirectories[CACHE]; + bf::path shared_data_path = package_path / rwDirectories[SHARED_DATA]; + + ASSERT_TRUE(bf::exists(data_path)); + ASSERT_TRUE(bf::exists(cache_path)); + + struct stat stats; + stat(data_path.c_str(), &stats); + // gid of RW dirs should be system_share + boost::optional system_share = + ci::GetGidByGroupName(kSystemShareGroupName); + ASSERT_EQ(uid, stats.st_uid) << "Invalid gid: " << data_path; + ASSERT_EQ(*system_share, stats.st_gid) << "Invalid gid: " << data_path; + if (bf::exists(shared_data_path)) { + stat(shared_data_path.c_str(), &stats); + ASSERT_EQ(uid, stats.st_uid) << "Invalid gid: " << shared_data_path; + ASSERT_EQ(*system_share, stats.st_gid) << "Invalid gid: " + << shared_data_path; + } + + stat(cache_path.c_str(), &stats); + ASSERT_EQ(uid, stats.st_uid) << "Invalid gid: " << cache_path; + ASSERT_EQ(*system_share, stats.st_gid) << "Invalid gid: " << cache_path; +} + +void ValidatePackageFS(const std::string& pkgid, + const std::vector& appids, + uid_t uid, gid_t gid, bool is_readonly) { + bf::path root_path = ci::GetRootAppPath(is_readonly, uid); bf::path package_path = root_path / pkgid; - bf::path binary_path = package_path / "bin" / appid; - bf::path data_path = package_path / "data"; bf::path shared_path = package_path / "shared"; - bf::path cache_path = package_path / "cache"; ASSERT_TRUE(bf::exists(root_path)); ASSERT_TRUE(bf::exists(package_path)); - ASSERT_TRUE(bf::exists(binary_path)); - ASSERT_TRUE(bf::exists(data_path)); ASSERT_TRUE(bf::exists(shared_path)); - ASSERT_TRUE(bf::exists(cache_path)); bf::path manifest_path = - bf::path(getUserManifestPath(getuid())) / (pkgid + ".xml"); - bf::path icon_path = bf::path(getIconPath(getuid())) / (appid + ".png"); + bf::path(getUserManifestPath(uid, is_readonly)) / (pkgid + ".xml"); ASSERT_TRUE(bf::exists(manifest_path)); - ASSERT_TRUE(bf::exists(icon_path)); + + for (auto& appid : appids) { + bf::path binary_path = package_path / "bin" / appid; + ASSERT_TRUE(bf::exists(binary_path)); + } bf::path widget_root_path = package_path / "res" / "wgt"; bf::path config_path = widget_root_path / "config.xml"; @@ -159,41 +375,116 @@ void ValidatePackageFS(const std::string& pkgid, const std::string& appid) { // backups should not exist bf::path package_backup = ci::GetBackupPathForPackagePath(package_path); bf::path manifest_backup = ci::GetBackupPathForManifestFile(manifest_path); - bf::path icon_backup = ci::GetBackupPathForIconFile(icon_path); ASSERT_FALSE(bf::exists(package_backup)); ASSERT_FALSE(bf::exists(manifest_backup)); - ASSERT_FALSE(bf::exists(icon_backup)); + + for (bf::recursive_directory_iterator iter(package_path); + iter != bf::recursive_directory_iterator(); ++iter) { + if (bf::is_symlink(symlink_status(iter->path()))) + continue; + bool is_rw_dir = false; + for(const auto rw_dir : rwDirectories) { + bf::path rw_dir_path = rw_dir; + is_rw_dir |= ci::MakeRelativePath(iter->path(), package_path) == rw_dir_path; + } + if (is_rw_dir || iter->path().filename() == ".mmc") { + iter.no_push(); + continue; + } + struct stat stats; + stat(iter->path().c_str(), &stats); + ASSERT_EQ(uid, stats.st_uid) << "Invalid uid: " << iter->path(); + ASSERT_EQ(gid, stats.st_gid) << "Invalid gid: " << iter->path(); + } } -void PackageCheckCleanup(const std::string& pkgid, const std::string& appid) { - bf::path root_path = ci::GetRootAppPath(false); +void PackageCheckCleanup(const std::string& pkgid, + const std::vector&, bool is_readonly = false) { + bf::path root_path = ci::GetRootAppPath(is_readonly, kTestUserId); bf::path package_path = root_path / pkgid; ASSERT_FALSE(bf::exists(package_path)); - bf::path manifest_path = - bf::path(getUserManifestPath(getuid())) / (pkgid + ".xml"); - bf::path icon_path = bf::path(getIconPath(getuid())) / (appid + ".png"); + bf::path manifest_path = bf::path(getUserManifestPath(kTestUserId, + is_readonly)) / (pkgid + ".xml"); ASSERT_FALSE(bf::exists(manifest_path)); - ASSERT_FALSE(bf::exists(icon_path)); // backups should not exist bf::path package_backup = ci::GetBackupPathForPackagePath(package_path); bf::path manifest_backup = ci::GetBackupPathForManifestFile(manifest_path); - bf::path icon_backup = ci::GetBackupPathForIconFile(icon_path); ASSERT_FALSE(bf::exists(package_backup)); ASSERT_FALSE(bf::exists(manifest_backup)); - ASSERT_FALSE(bf::exists(icon_backup)); } -void ValidatePackage(const std::string& pkgid, const std::string& appid) { - ASSERT_TRUE(ci::IsPackageInstalled(pkgid, ci::GetRequestMode())); - ValidatePackageFS(pkgid, appid); +void ValidatePackage(const std::string& pkgid, + const std::vector& appids, bool is_readonly = false) { + ASSERT_TRUE(ci::QueryIsPackageInstalled( + pkgid, ci::GetRequestMode(kTestUserId), kTestUserId)); + ValidatePackageFS(pkgid, appids, kTestUserId, kTestGroupId, is_readonly); + if (kTestUserId == kGlobalUserUid) { + ci::UserList list = ci::GetUserList(); + for (auto& l : list) + ValidatePackageRWFS(pkgid, std::get<0>(l)); + } else { + ValidatePackageRWFS(pkgid, kTestUserId); + } +} + +void ValidateExternalPackageFS(const std::string& pkgid, + const std::vector& appids, + uid_t uid, gid_t gid) { + ASSERT_EQ(app2ext_usr_enable_external_pkg(pkgid.c_str(), uid), 0); + bf::path root_path = ci::GetRootAppPath(false, uid); + ASSERT_TRUE(bf::exists(root_path / pkgid / ".mmc" / "res")); + ValidatePackageFS(pkgid, appids, uid, gid, false); + ASSERT_EQ(app2ext_usr_disable_external_pkg(pkgid.c_str(), uid), 0); +} + +void ValidateExternalPackage(const std::string& pkgid, + const std::vector& appids) { + ASSERT_TRUE(ci::QueryIsPackageInstalled( + pkgid, ci::GetRequestMode(kTestUserId), + kTestUserId)); + std::string storage = ci::QueryStorageForPkgId(pkgid, kTestUserId); + bf::path ext_mount_path = ci::GetExternalCardPath(); + if (bf::is_empty(ext_mount_path)) { + LOG(INFO) << "Sdcard not exists!"; + ASSERT_EQ(storage, "installed_internal"); + } else { + ASSERT_EQ(storage, "installed_external"); + } + ValidateExternalPackageFS(pkgid, appids, kTestUserId, kTestGroupId); + if (kTestUserId == kGlobalUserUid) { + ci::UserList list = ci::GetUserList(); + for (auto& l : list) + ValidatePackageRWFS(pkgid, std::get<0>(l)); + } else { + ValidatePackageRWFS(pkgid, kTestUserId); + } } void CheckPackageNonExistance(const std::string& pkgid, - const std::string& appid) { - ASSERT_FALSE(ci::IsPackageInstalled(pkgid, ci::GetRequestMode())); - PackageCheckCleanup(pkgid, appid); + const std::vector& appids) { + ASSERT_FALSE(ci::QueryIsPackageInstalled( + pkgid, ci::GetRequestMode(kTestUserId), + kTestUserId)); + PackageCheckCleanup(pkgid, appids); + if (kTestUserId == kGlobalUserUid) { + ci::UserList list = ci::GetUserList(); + bf::path skel_path(kSkelDir); + ASSERT_FALSE(bf::exists(skel_path / pkgid)); + for (auto& l : list) { + bf::path root_path = ci::GetRootAppPath(false, std::get<0>(l)); + bf::path package_path = root_path / pkgid; + ASSERT_FALSE(bf::exists(package_path)); + } + } +} + +void CheckPackageReadonlyNonExistance(const std::string& pkgid, + const std::vector& appids) { + ASSERT_FALSE(ci::QueryIsPackageInstalled( + pkgid, ci::GetRequestMode(kTestUserId), kTestUserId)); + PackageCheckCleanup(pkgid, appids, true); } std::unique_ptr CreateQueryInterface() { @@ -202,112 +493,319 @@ std::unique_ptr CreateQueryInterface() { return query_interface; } -std::unique_ptr CreateInstaller(ci::PkgMgrPtr pkgmgr) { - std::unique_ptr installer(new wgt::WgtInstaller(pkgmgr)); - return installer; +std::unique_ptr CreateInstaller(ci::PkgMgrPtr pkgmgr, + PackageType type) { + switch (type) { + case PackageType::WGT: + return std::unique_ptr(new wgt::WgtInstaller(pkgmgr)); + case PackageType::HYBRID: + return std::unique_ptr( + new hybrid::HybridInstaller(pkgmgr)); + default: + LOG(ERROR) << "Unknown installer type"; + return nullptr; + } } ci::AppInstaller::Result RunInstallerWithPkgrmgr(ci::PkgMgrPtr pkgmgr, + PackageType type, RequestResult mode) { - std::unique_ptr installer = CreateInstaller(pkgmgr); + std::unique_ptr installer = CreateInstaller(pkgmgr, type); switch (mode) { case RequestResult::FAIL: installer->AddStep(); break; - case RequestResult::CRASH: - installer->AddStep(); default: break; } return installer->Run(); } - -ci::AppInstaller::Result Install(const bf::path& path, - RequestResult mode = RequestResult::NORMAL) { - const char* argv[] = {"", "-i", path.c_str()}; +ci::AppInstaller::Result CallBackend(int argc, + const char* argv[], + PackageType type, + RequestResult mode = RequestResult::NORMAL + ) { TestPkgmgrInstaller pkgmgr_installer; std::unique_ptr query_interface = CreateQueryInterface(); auto pkgmgr = - ci::PkgMgrInterface::Create(SIZEOFARRAY(argv), const_cast(argv), + ci::PkgMgrInterface::Create(argc, const_cast(argv), &pkgmgr_installer, query_interface.get()); if (!pkgmgr) { LOG(ERROR) << "Failed to initialize pkgmgr interface"; return ci::AppInstaller::Result::UNKNOWN; } - return RunInstallerWithPkgrmgr(pkgmgr, mode); + return RunInstallerWithPkgrmgr(pkgmgr, type, mode); } -ci::AppInstaller::Result Update(const bf::path& path_old, - const bf::path& path_new, - RequestResult mode = RequestResult::NORMAL) { - if (Install(path_old) != ci::AppInstaller::Result::OK) { - LOG(ERROR) << "Failed to install application. Cannot update"; - return ci::AppInstaller::Result::UNKNOWN; +ci::AppInstaller::Result Install(const bf::path& path, + PackageType type, + RequestResult mode = RequestResult::NORMAL) { + const char* argv[] = {"", "-i", path.c_str(), "-u", kTestUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); +} + +ci::AppInstaller::Result InstallPreload(const bf::path& path, PackageType type, + RequestResult mode = RequestResult::NORMAL) { + const char* argv[] = {"", "-i", path.c_str(), "--preload"}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); +} + +bool CheckAvailableExternalPath() { + bf::path ext_mount_path = ci::GetExternalCardPath(); + LOG(DEBUG) << "ext_mount_path :" << ext_mount_path; + if (ext_mount_path.empty()) { + LOG(ERROR) << "Sdcard not exists!"; + return false; + } + return true; +} + +ci::AppInstaller::Result InstallExternal(const bf::path& path, + PackageType type, + RequestResult mode = RequestResult::NORMAL) { + int default_storage = 0; + vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT, + &default_storage); + vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT, 1); + + const char* argv[] = {"", "-i", path.c_str(), "-u", kTestUserIdStr.c_str()}; + ci::AppInstaller::Result result = + CallBackend(SIZEOFARRAY(argv), argv, type, mode); + + vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT, + default_storage); + return result; +} + +ci::AppInstaller::Result MigrateLegacyExternalImage(const std::string& pkgid, + const bf::path& path, + const bf::path& legacy_path, + PackageType type, + RequestResult mode = RequestResult::NORMAL) { + if (InstallExternal(path, type) != ci::AppInstaller::Result::OK) { + LOG(ERROR) << "Failed to install application. Cannot perform Migrate"; + return ci::AppInstaller::Result::ERROR; + } + + bf::path ext_mount_path = ci::GetExternalCardPath(); + if (bf::is_empty(ext_mount_path)) { + LOG(ERROR) << "Sdcard not exists!"; + return ci::AppInstaller::Result::ERROR; + } + bf::path app2sd_path = ext_mount_path / "app2sd"; + + char* image_name = app2ext_usr_getname_image(pkgid.c_str(), + kGlobalUserUid); + if (!image_name) { + LOG(ERROR) << "Failed to get external image name"; + return ci::AppInstaller::Result::ERROR; } - return Install(path_new, mode); + bf::path org_image = app2sd_path / image_name; + free(image_name); + + bs::error_code error; + bf::remove(org_image, error); + if (error) { + LOG(ERROR) << "Failed to remove org image"; + return ci::AppInstaller::Result::ERROR; + } + + bf::path db_path = tzplatform_getenv(TZ_SYS_DB); + bf::path app2sd_db = db_path / ".app2sd.db"; + bf::path app2sd_db_journal = db_path / ".app2sd.db-journal"; + bf::remove(app2sd_db, error); + if (error) { + LOG(ERROR) << "Failed to remove app2sd db"; + return ci::AppInstaller::Result::ERROR; + } + bf::remove(app2sd_db_journal, error); + if (error) { + LOG(ERROR) << "Failed to remove app2sd journal db"; + return ci::AppInstaller::Result::ERROR; + } + + bf::path app2sd_migrate_db = legacy_path / kMigrateTestDBName; + if (!ci::CopyFile(app2sd_migrate_db, app2sd_db)) { + LOG(ERROR) << "Failed to copy test db"; + return ci::AppInstaller::Result::ERROR; + } + + bf::path legacy_src = legacy_path / pkgid; + bf::path legacy_dst = app2sd_path / pkgid; + if (!ci::CopyFile(legacy_src, legacy_dst)) { + LOG(ERROR) << "Failed to copy test image"; + return ci::AppInstaller::Result::ERROR; + } + const char* argv[] = {"", "--migrate-extimg", pkgid.c_str(), + "-u", kDefaultUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); +} + +ci::AppInstaller::Result MountInstall(const bf::path& path, + PackageType type, RequestResult mode = RequestResult::NORMAL) { + const char* argv[] = {"", "-w", path.c_str(), "-u", kTestUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); } ci::AppInstaller::Result Uninstall(const std::string& pkgid, + PackageType type, + bool is_preload, RequestResult mode = RequestResult::NORMAL) { - const char* argv[] = {"", "-d", pkgid.c_str()}; - TestPkgmgrInstaller pkgmgr_installer; - std::unique_ptr query_interface = - CreateQueryInterface(); - auto pkgmgr = - ci::PkgMgrInterface::Create(SIZEOFARRAY(argv), const_cast(argv), - &pkgmgr_installer, query_interface.get()); - if (!pkgmgr) { - LOG(ERROR) << "Failed to initialize pkgmgr interface"; - return ci::AppInstaller::Result::UNKNOWN; + if (is_preload) { + const char* argv[] = {"", "-d", pkgid.c_str(), "--preload", + "--force-remove"}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); + } else { + const char* argv[] = {"", "-d", pkgid.c_str(), "-u", + kTestUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); } - return RunInstallerWithPkgrmgr(pkgmgr, mode); } -ci::AppInstaller::Result Reinstall(const bf::path& path, - const bf::path& delta_dir, +ci::AppInstaller::Result RDSUpdate(const bf::path& path, + const std::string& pkgid, + PackageType type, RequestResult mode = RequestResult::NORMAL) { - if (Install(path) != ci::AppInstaller::Result::OK) { + if (Install(path, type) != ci::AppInstaller::Result::OK) { LOG(ERROR) << "Failed to install application. Cannot perform RDS"; return ci::AppInstaller::Result::UNKNOWN; } - const char* argv[] = {"", "-r", delta_dir.c_str()}; - TestPkgmgrInstaller pkgmgr_installer; - std::unique_ptr query_interface = - CreateQueryInterface(); - auto pkgmgr = - ci::PkgMgrInterface::Create(SIZEOFARRAY(argv), const_cast(argv), - &pkgmgr_installer, query_interface.get()); - if (!pkgmgr) { - LOG(ERROR) << "Failed to initialize pkgmgr interface"; - return ci::AppInstaller::Result::UNKNOWN; - } - return RunInstallerWithPkgrmgr(pkgmgr, mode); + const char* argv[] = {"", "-r", pkgid.c_str(), "-u", + kTestUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); } ci::AppInstaller::Result DeltaInstall(const bf::path& path, - const bf::path& delta_package) { - if (Install(path) != ci::AppInstaller::Result::OK) { - LOG(ERROR) << "Failed to install application. Cannot perform RDS"; + const bf::path& delta_package, PackageType type) { + if (Install(path, type) != ci::AppInstaller::Result::OK) { + LOG(ERROR) << "Failed to install application. Cannot perform delta update"; return ci::AppInstaller::Result::UNKNOWN; } - return Install(delta_package); + return Install(delta_package, type); +} + +ci::AppInstaller::Result EnablePackage(const std::string& pkgid, + PackageType type, + RequestResult mode = RequestResult::NORMAL) { + const char* argv[] = {"", "-A", pkgid.c_str(), "-u", kTestUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); +} + +ci::AppInstaller::Result DisablePackage(const std::string& pkgid, + PackageType type, + RequestResult mode = RequestResult::NORMAL) { + const char* argv[] = {"", "-D", pkgid.c_str(), "-u", kTestUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); } ci::AppInstaller::Result Recover(const bf::path& recovery_file, + PackageType type, RequestResult mode = RequestResult::NORMAL) { - const char* argv[] = {"", "-b", recovery_file.c_str()}; - TestPkgmgrInstaller pkgmgr_installer; - std::unique_ptr query_interface = - CreateQueryInterface(); - auto pkgmgr = - ci::PkgMgrInterface::Create(SIZEOFARRAY(argv), const_cast(argv), - &pkgmgr_installer, query_interface.get()); - if (!pkgmgr) { - LOG(ERROR) << "Failed to initialize pkgmgr interface"; - return ci::AppInstaller::Result::UNKNOWN; + const char* argv[] = {"", "-b", recovery_file.c_str(), "-u", + kTestUserIdStr.c_str()}; + return CallBackend(SIZEOFARRAY(argv), argv, type, mode); +} + +void BackupPath(const bf::path& path) { + bf::path backup_path = path.string() + ".bck"; + std::cout << "Backup path: " << path << " to " << backup_path << std::endl; + bs::error_code error; + bf::remove_all(backup_path, error); + if (error) + LOG(ERROR) << "Remove failed: " << backup_path + << " (" << error.message() << ")"; + if (bf::exists(path)) { + bf::rename(path, backup_path, error); + if (error) + LOG(ERROR) << "Failed to setup test environment. Does some previous" + << " test crashed? Path: " + << backup_path << " should not exist."; + assert(!error); + } +} + +void RestorePath(const bf::path& path) { + bf::path backup_path = path.string() + ".bck"; + std::cout << "Restore path: " << path << " from " << backup_path << std::endl; + bs::error_code error; + bf::remove_all(path, error); + if (error) + LOG(ERROR) << "Remove failed: " << path + << " (" << error.message() << ")"; + if (bf::exists(backup_path)) { + bf::rename(backup_path, path, error); + if (error) + LOG(ERROR) << "Failed to restore backup path: " << backup_path + << " (" << error.message() << ")"; + } +} + +std::vector SetupBackupDirectories() { + std::vector entries; + bf::path db_dir = bf::path(tzplatform_getenv(TZ_SYS_DB)); + if (kTestUserId != kGlobalUserUid) + db_dir = db_dir / "user" / std::to_string(kTestUserId); + for (auto e : kDBEntries) { + bf::path path = db_dir / e; + entries.emplace_back(path); + } + + if (getuid() == 0) { + entries.emplace_back(kPreloadApps); + entries.emplace_back(kPreloadManifestDir); + entries.emplace_back(kPreloadIcons); + } + + if (kTestUserId == kGlobalUserUid) { + entries.emplace_back(kSkelDir); + entries.emplace_back(kGlobalManifestDir); + ci::UserList list = ci::GetUserList(); + for (auto l : list) { + bf::path apps = std::get<2>(l) / "apps_rw"; + entries.emplace_back(apps); + } + } else { + tzplatform_set_user(kTestUserId); + bf::path approot = tzplatform_getenv(TZ_USER_APPROOT); + tzplatform_reset_user(); + entries.emplace_back(approot); + } + + bf::path apps_rw = ci::GetRootAppPath(false, kTestUserId); + entries.emplace_back(apps_rw); + + return entries; +} + +void UninstallAllAppsInDirectory(bf::path dir, bool is_preload) { + if(bf::exists(dir)) { + for (auto& dir_entry : boost::make_iterator_range( + bf::directory_iterator(dir), bf::directory_iterator())) { + if (dir_entry.path().string().find("smoke") != std::string::npos && + bf::is_directory(dir_entry)) { + std::string package = dir_entry.path().filename().string(); + std::regex pkg_regex("smoke[a-zA-Z]{3,}[1-9]{2,}"); + if (std::regex_match(package, pkg_regex)) { + if(Uninstall(dir_entry.path().filename().string(), PackageType::WGT, + is_preload, RequestResult::NORMAL) != + ci::AppInstaller::Result::OK) { + LOG(ERROR) << "Cannot uninstall smoke test app: " + << dir_entry.path().filename().string(); + } + } + } + } } - return RunInstallerWithPkgrmgr(pkgmgr, mode); +} + +void UninstallAllSmokeApps() { + if (getuid() == 0 && kRequestMode == ci::RequestMode::GLOBAL) { + bf::path root_path = kPreloadApps; + UninstallAllAppsInDirectory(root_path, true); + } + bf::path apps_rw = ci::GetRootAppPath(false, kTestUserId); + UninstallAllAppsInDirectory(apps_rw, false); } } // namespace @@ -316,181 +814,695 @@ namespace common_installer { class SmokeEnvironment : public testing::Environment { public: - explicit SmokeEnvironment(const bf::path& home) : home_(home) { + explicit SmokeEnvironment() { } void SetUp() override { - bs::error_code error; - bf::remove_all(home_ / kApplicationDirBackup, error); - bf::remove_all(home_ / KUserAppsDirBackup, error); - if (bf::exists(home_ / KUserAppsDir)) { - bf::rename(home_ / KUserAppsDir, home_ / KUserAppsDirBackup, error); - if (error) - LOG(ERROR) << "Failed to setup test environment. Does some previous" - << " test crashed? Directory: " - << (home_ / KUserAppsDirBackup) << " should not exist."; - assert(!error); - } - if (bf::exists(home_ / kApplicationDir)) { - bf::rename(home_ / kApplicationDir, home_ / kApplicationDirBackup, error); - if (error) - LOG(ERROR) << "Failed to setup test environment. Does some previous" - << " test crashed? Directory: " - << (home_ / kApplicationDirBackup) << " should not exist."; - assert(!error); + if (kRequestMode == ci::RequestMode::USER) + ASSERT_TRUE(AddTestUser(kNormalUserName)); + else { + kTestUserId = kGlobalUserUid; + kTestGroupId = kGlobalUserGid; + kTestUserIdStr = std::to_string(kTestUserId); } + backups_ = SetupBackupDirectories(); + for (auto& path : backups_) + BackupPath(path); } void TearDown() override { - bs::error_code error; - bf::remove_all(home_ / kApplicationDir, error); - bf::remove_all(home_ / KUserAppsDir, error); - if (bf::exists(home_ / KUserAppsDirBackup)) - bf::rename(home_ / KUserAppsDirBackup, home_ / KUserAppsDir, error); - if (bf::exists(home_ / kApplicationDirBackup)) - bf::rename(home_ / kApplicationDirBackup, home_ / kApplicationDir, error); + ASSERT_TRUE(kRequestMode == ci::RequestMode::GLOBAL || + (kRequestMode == ci::RequestMode::USER && + kGlobalUserUid != kTestUserId)); + UninstallAllSmokeApps(); + for (auto& path : backups_) + RestorePath(path); + if (kRequestMode == ci::RequestMode::USER) + ASSERT_TRUE(DeleteTestUser(kNormalUserName)); } private: - bf::path home_; + std::vector backups_; }; class SmokeTest : public testing::Test { }; +class PreloadSmokeTest : public testing::Test { + void SetUp() override { + ASSERT_TRUE(kRequestMode == ci::RequestMode::GLOBAL); + } +}; + TEST_F(SmokeTest, InstallationMode) { bf::path path = kSmokePackagesDirectory / "InstallationMode.wgt"; - std::string pkgid = "smokeapp03"; - std::string appid = "smokeapp03.InstallationMode"; - ASSERT_EQ(Install(path), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, appid); + std::string pkgid = "smokewgt03"; + std::string appid = "smokewgt03.InstallationMode"; + ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); } TEST_F(SmokeTest, UpdateMode) { bf::path path_old = kSmokePackagesDirectory / "UpdateMode.wgt"; bf::path path_new = kSmokePackagesDirectory / "UpdateMode_2.wgt"; - std::string pkgid = "smokeapp04"; - std::string appid = "smokeapp04.UpdateMode"; - ASSERT_EQ(Update(path_old, path_new), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, appid); + std::string pkgid = "smokewgt04"; + std::string appid = "smokewgt04.UpdateMode"; + ASSERT_EQ(Install(path_old, PackageType::WGT), ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(Install(path_new, PackageType::WGT), ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); + ValidateDataFiles(pkgid, kTestUserId); } TEST_F(SmokeTest, DeinstallationMode) { bf::path path = kSmokePackagesDirectory / "DeinstallationMode.wgt"; - std::string pkgid = "smokeapp05"; - std::string appid = "smokeapp05.DeinstallationMode"; - ASSERT_EQ(Install(path), + std::string pkgid = "smokewgt05"; + std::string appid = "smokewgt05.DeinstallationMode"; + ASSERT_EQ(Install(path, PackageType::WGT), + ci::AppInstaller::Result::OK); + ASSERT_EQ(Uninstall(pkgid, PackageType::WGT, false), ci::AppInstaller::Result::OK); - ASSERT_EQ(Uninstall(pkgid), ci::AppInstaller::Result::OK); - CheckPackageNonExistance(pkgid, appid); + CheckPackageNonExistance(pkgid, {appid}); } TEST_F(SmokeTest, RDSMode) { bf::path path = kSmokePackagesDirectory / "RDSMode.wgt"; + std::string pkgid = "smokewgt11"; + std::string appid = "smokewgt11.RDSMode"; bf::path delta_directory = kSmokePackagesDirectory / "delta_dir/"; - std::string pkgid = "smokeapp11"; - std::string appid = "smokeapp11.RDSMode"; - ASSERT_EQ(Reinstall(path, delta_directory), + bf::path sdk_expected_directory = + bf::path(ci::GetRootAppPath(false, kTestUserId)) / "tmp" / pkgid; + bs::error_code error; + bf::create_directories(sdk_expected_directory.parent_path(), error); + ASSERT_FALSE(error); + ASSERT_TRUE(CopyDir(delta_directory, sdk_expected_directory)); + ASSERT_EQ(RDSUpdate(path, pkgid, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, appid); + ValidatePackage(pkgid, {appid}); // Check delta modifications - bf::path root_path = ci::GetRootAppPath(false); - ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "DELETED")); - ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "ADDED")); - ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "2\n"); + ASSERT_FALSE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res" / "wgt" / "DELETED")); + ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res" / "wgt" / "ADDED")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "2\n")); +} + +TEST_F(SmokeTest, EnablePkg) { + bf::path path = kSmokePackagesDirectory / "EnablePkg.wgt"; + std::string pkgid = "smokewgt22"; + ASSERT_EQ(Install(path, PackageType::WGT), + ci::AppInstaller::Result::OK); + ASSERT_EQ(DisablePackage(pkgid, PackageType::WGT), + ci::AppInstaller::Result::OK); + ASSERT_EQ(EnablePackage(pkgid, PackageType::WGT), + ci::AppInstaller::Result::OK); + + ASSERT_TRUE(ci::QueryIsPackageInstalled(pkgid, + ci::GetRequestMode(kTestUserId), + kTestUserId)); +} + +TEST_F(SmokeTest, DisablePkg) { + bf::path path = kSmokePackagesDirectory / "DisablePkg.wgt"; + std::string pkgid = "smokewgt21"; + std::string appid = "smokewgt21.DisablePkg"; + ASSERT_EQ(Install(path, PackageType::WGT), + ci::AppInstaller::Result::OK); + ASSERT_EQ(DisablePackage(pkgid, PackageType::WGT), + ci::AppInstaller::Result::OK); + ASSERT_TRUE(ci::QueryIsDisabledPackage(pkgid, kTestUserId)); + ValidatePackage(pkgid, {appid}); } TEST_F(SmokeTest, DeltaMode) { bf::path path = kSmokePackagesDirectory / "DeltaMode.wgt"; bf::path delta_package = kSmokePackagesDirectory / "DeltaMode.delta"; - std::string pkgid = "smokeapp17"; - std::string appid = "smokeapp17.DeltaMode"; - ASSERT_EQ(DeltaInstall(path, delta_package), + std::string pkgid = "smokewgt17"; + std::string appid = "smokewgt17.DeltaMode"; + ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, appid); + ValidatePackage(pkgid, {appid}); // Check delta modifications - bf::path root_path = ci::GetRootAppPath(false); - ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "DELETED")); - ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "ADDED")); - ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "css" / "style.css")); // NOLINT - ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "images" / "tizen_32.png")); // NOLINT - ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "js" / "main.js")); - ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "version 2\n"); + ASSERT_FALSE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res" / "wgt" / "DELETED")); + ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res" / "wgt" / "ADDED")); + ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res" / "wgt" / "css" / "style.css")); + ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res" / "wgt" / "images" / "tizen_32.png")); + ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res" / "wgt" / "js" / "main.js")); + ASSERT_TRUE(ValidateFileContentInPackage( + pkgid, "res/wgt/MODIFIED", "version 2\n")); } TEST_F(SmokeTest, RecoveryMode_ForInstallation) { bf::path path = kSmokePackagesDirectory / "RecoveryMode_ForInstallation.wgt"; - ASSERT_DEATH(Install(path, RequestResult::CRASH), ".*"); + Subprocess backend_crash("/usr/bin/wgt-backend-ut/smoke-test-helper"); + backend_crash.Run("-i", path.string(), "-u", kTestUserIdStr.c_str()); + ASSERT_NE(backend_crash.Wait(), 0); - std::string pkgid = "smokeapp09"; - std::string appid = "smokeapp09.RecoveryModeForInstallation"; + std::string pkgid = "smokewgt09"; + std::string appid = "smokewgt09.RecoveryModeForInstallation"; bf::path recovery_file = FindRecoveryFile(); ASSERT_FALSE(recovery_file.empty()); - ASSERT_EQ(Recover(recovery_file), + ASSERT_EQ(Recover(recovery_file, PackageType::WGT), ci::AppInstaller::Result::OK); - CheckPackageNonExistance(pkgid, appid); + CheckPackageNonExistance(pkgid, {appid}); } TEST_F(SmokeTest, RecoveryMode_ForUpdate) { bf::path path_old = kSmokePackagesDirectory / "RecoveryMode_ForUpdate.wgt"; bf::path path_new = kSmokePackagesDirectory / "RecoveryMode_ForUpdate_2.wgt"; RemoveAllRecoveryFiles(); - ASSERT_DEATH(Update(path_old, path_new, RequestResult::CRASH), ".*"); + ASSERT_EQ(Install(path_old, PackageType::WGT), ci::AppInstaller::Result::OK); + std::string pkgid = "smokewgt10"; + std::string appid = "smokewgt10.RecoveryModeForUpdate"; + AddDataFiles(pkgid, kTestUserId); + Subprocess backend_crash("/usr/bin/wgt-backend-ut/smoke-test-helper"); + backend_crash.Run("-i", path_new.string(), "-u", kTestUserIdStr.c_str()); + ASSERT_NE(backend_crash.Wait(), 0); + + bf::path recovery_file = FindRecoveryFile(); + ASSERT_FALSE(recovery_file.empty()); + ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, RecoveryMode_ForDelta) { + bf::path path_old = kSmokePackagesDirectory / "RecoveryMode_ForDelta.wgt"; + bf::path path_new = kSmokePackagesDirectory / "RecoveryMode_ForDelta.delta"; + RemoveAllRecoveryFiles(); + ASSERT_EQ(Install(path_old, PackageType::WGT), ci::AppInstaller::Result::OK); + Subprocess backend_crash("/usr/bin/wgt-backend-ut/smoke-test-helper"); + backend_crash.Run("-i", path_new.string(), "-u", kTestUserIdStr.c_str()); + ASSERT_NE(backend_crash.Wait(), 0); + + std::string pkgid = "smokewgt30"; + std::string appid = "smokewgt30.RecoveryModeForDelta"; + bf::path recovery_file = FindRecoveryFile(); + ASSERT_FALSE(recovery_file.empty()); + ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); +} + +TEST_F(SmokeTest, RecoveryMode_ForMountInstall) { + bf::path path = kSmokePackagesDirectory / "RecoveryMode_ForMountInstall.wgt"; + RemoveAllRecoveryFiles(); + Subprocess backend_crash("/usr/bin/wgt-backend-ut/smoke-test-helper"); + backend_crash.Run("-w", path.string(), "-u", kTestUserIdStr.c_str()); + ASSERT_NE(backend_crash.Wait(), 0); + + std::string pkgid = "smokewgt31"; + std::string appid = "smokewgt31.RecoveryModeForMountInstall"; + bf::path recovery_file = FindRecoveryFile(); + ASSERT_FALSE(recovery_file.empty()); + ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + CheckPackageNonExistance(pkgid, {appid}); +} + +TEST_F(SmokeTest, RecoveryMode_ForMountUpdate) { + bf::path path_old = + kSmokePackagesDirectory / "RecoveryMode_ForMountUpdate.wgt"; + bf::path path_new = + kSmokePackagesDirectory / "RecoveryMode_ForMountUpdate_2.wgt"; + std::string pkgid = "smokewgt32"; + std::string appid = "smokewgt32.RecoveryModeForMountUpdate"; + RemoveAllRecoveryFiles(); + ASSERT_EQ(MountInstall(path_old, PackageType::WGT), + ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + Subprocess backend_crash("/usr/bin/wgt-backend-ut/smoke-test-helper"); + backend_crash.Run("-w", path_new.string(), "-u", kTestUserIdStr.c_str()); + ASSERT_NE(backend_crash.Wait(), 0); + + // Filesystem may be mounted after crash + ScopedTzipInterface poweroff_unmount_interface(pkgid); + poweroff_unmount_interface.Release(); - std::string pkgid = "smokeapp10"; - std::string appid = "smokeapp10.RecoveryModeForUpdate"; bf::path recovery_file = FindRecoveryFile(); ASSERT_FALSE(recovery_file.empty()); - ASSERT_EQ(Recover(recovery_file), + ASSERT_EQ(Recover(recovery_file, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, appid); + ScopedTzipInterface interface(pkgid); + ValidatePackage(pkgid, {appid}); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); + ValidateDataFiles(pkgid, kTestUserId); } TEST_F(SmokeTest, InstallationMode_GoodSignature) { + // pkgid: smokewgt08 bf::path path = kSmokePackagesDirectory / "InstallationMode_GoodSignature.wgt"; // NOLINT - ASSERT_EQ(Install(path), ci::AppInstaller::Result::OK); + ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); } TEST_F(SmokeTest, InstallationMode_WrongSignature) { + // pkgid: smokewgt12 bf::path path = kSmokePackagesDirectory / "InstallationMode_WrongSignature.wgt"; // NOLINT - ASSERT_EQ(Install(path), ci::AppInstaller::Result::ERROR); + ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::ERROR); } TEST_F(SmokeTest, InstallationMode_Rollback) { bf::path path = kSmokePackagesDirectory / "InstallationMode_Rollback.wgt"; - std::string pkgid = "smokeapp06"; - std::string appid = "smokeapp06.InstallationModeRollback"; - ASSERT_EQ(Install(path, RequestResult::FAIL), + std::string pkgid = "smokewgt06"; + std::string appid = "smokewgt06.InstallationModeRollback"; + ASSERT_EQ(Install(path, PackageType::WGT, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); - CheckPackageNonExistance(pkgid, appid); + CheckPackageNonExistance(pkgid, {appid}); } TEST_F(SmokeTest, UpdateMode_Rollback) { bf::path path_old = kSmokePackagesDirectory / "UpdateMode_Rollback.wgt"; bf::path path_new = kSmokePackagesDirectory / "UpdateMode_Rollback_2.wgt"; - std::string pkgid = "smokeapp07"; - std::string appid = "smokeapp07.UpdateModeRollback"; - ASSERT_EQ(Update(path_old, path_new, RequestResult::FAIL), - ci::AppInstaller::Result::ERROR); - ValidatePackage(pkgid, appid); + std::string pkgid = "smokewgt07"; + std::string appid = "smokewgt07.UpdateModeRollback"; + ASSERT_EQ(Install(path_old, PackageType::WGT), ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(Install(path_new, PackageType::WGT, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + ValidatePackage(pkgid, {appid}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, DeltaMode_Rollback) { + bf::path path = kSmokePackagesDirectory / "DeltaMode_Rollback.wgt"; + bf::path delta_package = kSmokePackagesDirectory / "DeltaMode_Rollback.delta"; + std::string pkgid = "smokewgt01"; + std::string appid = "smokewgt01.DeltaMode"; + ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(Install(delta_package, PackageType::WGT, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + + ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", + "version 1\n")); + ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res/wgt/DELETED")); + ASSERT_FALSE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res/wgt/ADDED")); +} + +TEST_F(SmokeTest, InstallationMode_Hybrid) { + bf::path path = kSmokePackagesDirectory / "InstallationMode_Hybrid.wgt"; + std::string pkgid = "smokehyb01"; + // Excutable for native app doesn't create symlink + std::string appid1 = "smokehyb01.Web"; + ASSERT_EQ(Install(path, PackageType::HYBRID), ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid1}); +} + +TEST_F(SmokeTest, UpdateMode_Hybrid) { + bf::path path_old = kSmokePackagesDirectory / "UpdateMode_Hybrid.wgt"; + bf::path path_new = kSmokePackagesDirectory / "UpdateMode_Hybrid_2.wgt"; + std::string pkgid = "smokehyb02"; + std::string appid1 = "smokehyb02.Web"; + ASSERT_EQ(Install(path_old, PackageType::HYBRID), + ci::AppInstaller::Result::OK); +// AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(Install(path_new, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid1}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "VERSION", "2\n")); +// ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, DeinstallationMode_Hybrid) { + bf::path path = kSmokePackagesDirectory / "DeinstallationMode_Hybrid.wgt"; + std::string pkgid = "smokehyb03"; + std::string appid1 = "smokehyb03.Web"; + ASSERT_EQ(Install(path, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + ASSERT_EQ(Uninstall(pkgid, PackageType::HYBRID, false), + ci::AppInstaller::Result::OK); + CheckPackageNonExistance(pkgid, {appid1}); +} + +TEST_F(SmokeTest, DeltaMode_Hybrid) { + bf::path path = kSmokePackagesDirectory / "DeltaMode_Hybrid.wgt"; + bf::path delta_package = kSmokePackagesDirectory / "DeltaMode_Hybrid.delta"; + std::string pkgid = "smokehyb04"; + std::string appid1 = "smokehyb04.Web"; + ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid1}); + + // Check delta modifications + bf::path root_path = ci::GetRootAppPath(false, + kTestUserId); + ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "DELETED")); + ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "ADDED")); + ASSERT_FALSE(bf::exists(root_path / pkgid / "lib" / "DELETED")); + ASSERT_TRUE(bf::exists(root_path / pkgid / "lib" / "ADDED")); + ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "css" / "style.css")); // NOLINT + ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "images" / "tizen_32.png")); // NOLINT + ASSERT_TRUE(bf::exists(root_path / pkgid / "res" / "wgt" / "js" / "main.js")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "version 2\n")); // NOLINT + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/MODIFIED", "version 2\n")); // NOLINT +} + +TEST_F(SmokeTest, MountInstallationMode_Hybrid) { + bf::path path = kSmokePackagesDirectory / "MountInstallationMode_Hybrid.wgt"; + std::string pkgid = "smokehyb05"; + std::string appid1 = "smokehyb05.web"; + ASSERT_EQ(MountInstall(path, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + ScopedTzipInterface interface(pkgid); + ValidatePackage(pkgid, {appid1}); +} + +TEST_F(SmokeTest, MountUpdateMode_Hybrid) { + bf::path path_old = kSmokePackagesDirectory / "MountUpdateMode_Hybrid.wgt"; + bf::path path_new = kSmokePackagesDirectory / "MountUpdateMode_Hybrid_2.wgt"; + std::string pkgid = "smokehyb06"; + std::string appid1 = "smokehyb06.web"; + ASSERT_EQ(MountInstall(path_old, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(MountInstall(path_new, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + ScopedTzipInterface interface(pkgid); + ValidatePackage(pkgid, {appid1}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/VERSION", "2\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, InstallationMode_Rollback_Hybrid) { + bf::path path = kSmokePackagesDirectory / + "InstallationMode_Rollback_Hybrid.wgt"; + std::string pkgid = "smokehyb07"; + std::string appid1 = "smokehyb07.web"; + ASSERT_EQ(Install(path, PackageType::HYBRID, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + CheckPackageNonExistance(pkgid, {appid1}); +} + +TEST_F(SmokeTest, UpdateMode_Rollback_Hybrid) { + bf::path path_old = kSmokePackagesDirectory / + "UpdateMode_Rollback_Hybrid.wgt"; + bf::path path_new = kSmokePackagesDirectory / + "UpdateMode_Rollback_Hybrid_2.wgt"; + std::string pkgid = "smokehyb08"; + std::string appid1 = "smokehyb08.web"; + ASSERT_EQ(Install(path_old, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(Install(path_new, PackageType::HYBRID, + RequestResult::FAIL), ci::AppInstaller::Result::ERROR); + ValidatePackage(pkgid, {appid1}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/VERSION", "1\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, DeltaMode_Rollback_Hybrid) { + bf::path path = kSmokePackagesDirectory / "DeltaMode_Rollback_Hybrid.wgt"; + bf::path delta_package = kSmokePackagesDirectory / + "DeltaMode_Rollback_Hybrid.delta"; + std::string pkgid = "smokehyb11"; + std::string appid1 = "smokehyb11.web"; + ASSERT_EQ(Install(path, PackageType::HYBRID), ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(Install(delta_package, PackageType::HYBRID, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + + ValidatePackage(pkgid, {appid1}); + // Check delta modifications + bf::path root_path = GetPackageRoot(pkgid, kTestUserId); + ASSERT_TRUE(bf::exists(root_path / "res" / "wgt" / "DELETED")); + ASSERT_FALSE(bf::exists(root_path / "res" / "wgt" / "ADDED")); + ASSERT_TRUE(bf::exists(root_path / "lib" / "DELETED")); + ASSERT_FALSE(bf::exists(root_path / "lib" / "ADDED")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", + "version 1\n")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/MODIFIED", + "version 1\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, MountInstallationMode_Rollback_Hybrid) { + bf::path path = kSmokePackagesDirectory / + "MountInstallationMode_Rollback_Hybrid.wgt"; + std::string pkgid = "smokehyb09"; + std::string appid1 = "smokehyb09.web"; + ASSERT_EQ(MountInstall(path, PackageType::HYBRID, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + ScopedTzipInterface interface(pkgid); + CheckPackageNonExistance(pkgid, {appid1}); +} + +TEST_F(SmokeTest, MountUpdateMode_Rollback_Hybrid) { + bf::path path_old = kSmokePackagesDirectory / + "MountUpdateMode_Rollback_Hybrid.wgt"; + bf::path path_new = kSmokePackagesDirectory / + "MountUpdateMode_Rollback_Hybrid_2.wgt"; + std::string pkgid = "smokehyb10"; + std::string appid1 = "smokehyb10.web"; + ASSERT_EQ(MountInstall(path_old, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(MountInstall(path_new, PackageType::HYBRID, + RequestResult::FAIL), ci::AppInstaller::Result::ERROR); + ScopedTzipInterface interface(pkgid); + ValidatePackage(pkgid, {appid1}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/VERSION", "1\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, MountInstallationMode) { + bf::path path = kSmokePackagesDirectory / "MountInstallationMode.wgt"; + std::string pkgid = "smokewgt28"; + std::string appid = "smokewgt28.InstallationMode"; + ASSERT_EQ(MountInstall(path, PackageType::WGT), ci::AppInstaller::Result::OK); + ScopedTzipInterface interface(pkgid); + ValidatePackage(pkgid, {appid}); +} + +TEST_F(SmokeTest, MountUpdateMode) { + bf::path path_old = kSmokePackagesDirectory / "MountUpdateMode.wgt"; + bf::path path_new = kSmokePackagesDirectory / "MountUpdateMode_2.wgt"; + std::string pkgid = "smokewgt29"; + std::string appid = "smokewgt29.UpdateMode"; + ASSERT_EQ(MountInstall(path_old, PackageType::WGT), + ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(MountInstall(path_new, PackageType::WGT), + ci::AppInstaller::Result::OK); + ScopedTzipInterface interface(pkgid); + ValidatePackage(pkgid, {appid}); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, MountInstallationMode_Rollback) { + bf::path path = + kSmokePackagesDirectory / "MountInstallationMode_Rollback.wgt"; + std::string pkgid = "smokewgt33"; + std::string appid = "smokewgt33.web"; + ASSERT_EQ(MountInstall(path, PackageType::WGT, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + ScopedTzipInterface interface(pkgid); + CheckPackageNonExistance(pkgid, {appid}); +} + +TEST_F(SmokeTest, MountUpdateMode_Rollback) { + bf::path path_old = kSmokePackagesDirectory / "MountUpdateMode_Rollback.wgt"; + bf::path path_new = + kSmokePackagesDirectory / "MountUpdateMode_Rollback_2.wgt"; + std::string pkgid = "smokewgt34"; + std::string appid = "smokewgt34.web"; + ASSERT_EQ(MountInstall(path_old, PackageType::WGT), + ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(MountInstall(path_new, PackageType::WGT, + RequestResult::FAIL), ci::AppInstaller::Result::ERROR); + ScopedTzipInterface interface(pkgid); + ValidatePackage(pkgid, {appid}); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(SmokeTest, UserDefinedPlugins) { + bf::path path = kSmokePackagesDirectory / "SimpleEchoPrivilege.wgt"; + std::string pkgid = "smokewgt02"; + std::string appid = "smokewgt02.SimpleEcho"; + std::string call_privilege = "http://tizen.org/privilege/call"; + std::string location_privilege = "http://tizen.org/privilege/location"; + std::string power_privilege = "http://tizen.org/privilege/power"; + + ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); + std::vector res; + ASSERT_TRUE(ci::QueryPrivilegesForPkgId(pkgid, kTestUserId, &res)); + ASSERT_TRUE(std::find(res.begin(), res.end(), call_privilege) != res.end()); + ASSERT_TRUE(std::find(res.begin(), res.end(), location_privilege) + != res.end()); + ASSERT_TRUE(std::find(res.begin(), res.end(), power_privilege) != res.end()); +} + +TEST_F(SmokeTest, InstallExternalMode) { + ASSERT_TRUE(CheckAvailableExternalPath()); + bf::path path = kSmokePackagesDirectory / "InstallExternalMode.wgt"; + std::string pkgid = "smokewgt35"; + std::string appid = "smokewgt35.web"; + ASSERT_EQ(InstallExternal(path, PackageType::WGT), + ci::AppInstaller::Result::OK); + ValidateExternalPackage(pkgid, {appid}); +} + +TEST_F(SmokeTest, MigrateLegacyExternalImageMode) { + ASSERT_TRUE(CheckAvailableExternalPath()); + bf::path path = + kSmokePackagesDirectory / "MigrateLegacyExternalImageMode.wgt"; + std::string pkgid = "smokewgt36"; + std::string appid = "smokewgt36.web"; + bf::path legacy_path = kSmokePackagesDirectory / kLegacyExtImageDir; + ASSERT_EQ(MigrateLegacyExternalImage(pkgid, path, legacy_path, + PackageType::WGT), ci::AppInstaller::Result::OK); + ValidateExternalPackage(pkgid, {appid}); +} + +TEST_F(PreloadSmokeTest, InstallationMode_Preload) { + ASSERT_EQ(getuid(), 0) << "Test cannot be run by normal user"; + bf::path path = kSmokePackagesDirectory / "InstallationMode_Preload.wgt"; + std::string pkgid = "smokewgt37"; + std::string appid = "smokewgt37.InstallationModePreload"; + ASSERT_EQ(InstallPreload(path, PackageType::WGT), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}, true); +} + +TEST_F(PreloadSmokeTest, UpdateMode_Preload) { + ASSERT_EQ(getuid(), 0) << "Test cannot be run by normal user"; + bf::path path_old = kSmokePackagesDirectory / "UpdateMode_Preload.wgt"; + bf::path path_new = kSmokePackagesDirectory / "UpdateMode_Preload2.wgt"; + std::string pkgid = "smokewgt38"; + std::string appid = "smokewgt38.UpdateModePreload"; + ASSERT_EQ(InstallPreload(path_old, PackageType::WGT), + ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + ASSERT_EQ(InstallPreload(path_new, PackageType::WGT), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}, true); + + ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2", + true)); + ValidateDataFiles(pkgid, kTestUserId); +} + +TEST_F(PreloadSmokeTest, DeinstallationMode_Preload) { + ASSERT_EQ(getuid(), 0) << "Test cannot be run by normal user"; + bf::path path = kSmokePackagesDirectory / "DeinstallationMode_Preload.wgt"; + std::string pkgid = "smokewgt39"; + std::string appid = "smokewgt39.DeinstallationModePreload"; + ASSERT_EQ(InstallPreload(path, PackageType::WGT), + ci::AppInstaller::Result::OK); + ASSERT_EQ(Uninstall(pkgid, PackageType::WGT, true), + ci::AppInstaller::Result::OK); + CheckPackageReadonlyNonExistance(pkgid, {appid}); +} + +TEST_F(SmokeTest, SharedRes24) { + bf::path path = kSmokePackagesDirectory / "SharedRes24.wgt"; + std::string pkgid = "smokeSh2xx"; + std::string appid = "smokeSh2xx.SharedRes24"; + ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); + bf::path root_path = ci::GetRootAppPath(false, kTestUserId); + ASSERT_TRUE(bf::is_regular_file(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "NOT-SHARED-WGT")); // NOLINT + ASSERT_FALSE(bf::exists(root_path / pkgid / "shared" / "res" / "NOT-SHARED-WGT")); // NOLINT +} + +TEST_F(SmokeTest, SharedRes30) { + bf::path path = kSmokePackagesDirectory / "SharedRes30.wgt"; + std::string pkgid = "smokeSh3xx"; + std::string appid = "smokeSh3xx.SharedRes30"; + ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); + bf::path root_path = ci::GetRootAppPath(false, kTestUserId); + ASSERT_TRUE(bf::is_regular_file(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-WGT")); // NOLINT + ASSERT_TRUE(bf::is_symlink(root_path / pkgid / "shared" / "res" / "SHARED-WGT")); // NOLINT +} + +TEST_F(SmokeTest, SharedRes30Delta) { + bf::path path = kSmokePackagesDirectory / "SharedRes30Delta.wgt"; + bf::path delta_package = kSmokePackagesDirectory / "SharedRes30Delta.delta"; + std::string pkgid = "smokeSh3De"; + std::string appid = "smokeSh3De.SharedRes30Delta"; + ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::WGT), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid}); + // Check delta modifications + bf::path root_path = ci::GetRootAppPath(false, kTestUserId); + ASSERT_TRUE(bf::is_regular_file(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-WGT-2")); // NOLINT + ASSERT_TRUE(bf::is_symlink(root_path / pkgid / "shared" / "res" / "SHARED-WGT-2")); // NOLINT + ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-WGT-1")); // NOLINT + ASSERT_FALSE(bf::exists(root_path / pkgid / "shared" / "res" / "SHARED-WGT-1")); // NOLINT +} + +TEST_F(SmokeTest, SharedRes30Hybrid) { + bf::path path = kSmokePackagesDirectory / "SharedRes30Hybrid.wgt"; + std::string pkgid = "smokeSh3Hy"; + std::string appid1 = "smokeSh3Hy.SharedRes30Hybrid"; + std::string appid2 = "sharedres30hybridserivce"; + ASSERT_EQ(Install(path, PackageType::HYBRID), ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid1, appid2}); + bf::path root_path = ci::GetRootAppPath(false, kTestUserId); + ASSERT_TRUE(bf::is_regular_file(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-WGT")); // NOLINT + ASSERT_TRUE(bf::is_symlink(root_path / pkgid / "shared" / "res" / "SHARED-WGT")); // NOLINT + ASSERT_TRUE(bf::is_regular_file(root_path / pkgid / "shared" / "res" / "SHARED-TPK")); // NOLINT + ASSERT_TRUE(bf::is_symlink(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-TPK")); // NOLINT +} + +TEST_F(SmokeTest, SharedRes30HybridDelta) { + bf::path path = kSmokePackagesDirectory / "SharedRes30HybridDelta.wgt"; + bf::path delta_package = kSmokePackagesDirectory / "SharedRes30HybridDelta.delta"; + std::string pkgid = "smokeSh3HD"; + std::string appid1 = "smokeSh3HD.SharedRes30HybridDelta"; + std::string appid2 = "sharedres30hybriddeltaserivce"; + ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::HYBRID), + ci::AppInstaller::Result::OK); + ValidatePackage(pkgid, {appid1, appid2}); + // Check delta modifications + bf::path root_path = ci::GetRootAppPath(false, kTestUserId); + ASSERT_TRUE(bf::is_regular_file(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-WGT-2")); // NOLINT + ASSERT_TRUE(bf::is_symlink(root_path / pkgid / "shared" / "res" / "SHARED-WGT-2")); // NOLINT + ASSERT_TRUE(bf::is_regular_file(root_path / pkgid / "shared" / "res" / "SHARED-TPK-2")); // NOLINT + ASSERT_TRUE(bf::is_symlink(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-TPK-2")); // NOLINT + ASSERT_FALSE(bf::exists(root_path / pkgid / "res" / "wgt" / "shared" / "res" / "SHARED-WGT-1")); // NOLINT + ASSERT_FALSE(bf::exists(root_path / pkgid / "shared" / "res" / "SHARED-WGT-1")); // NOLINT } } // namespace common_installer int main(int argc, char** argv) { testing::InitGoogleTest(&argc, argv); - const char* directory = getenv("HOME"); - if (!directory) { - LOG(ERROR) << "Cannot get $HOME value"; - return 1; - } - testing::AddGlobalTestEnvironment( - new common_installer::SmokeEnvironment(directory)); + testing::Environment *env = testing::AddGlobalTestEnvironment( + new common_installer::SmokeEnvironment()); + ParseRequestMode(argc, argv); return RUN_ALL_TESTS(); }