From: Piotr Ganicz Date: Mon, 20 Mar 2017 14:41:46 +0000 (+0100) Subject: Extensive tests for Recovery and Rollback X-Git-Tag: accepted/tizen/unified/20170515.154302~6 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F02%2F120102%2F1;p=platform%2Fcore%2Fappfw%2Fwgt-backend.git Extensive tests for Recovery and Rollback This commit creates new executable (extensive-smoke-test) for new type of tests which will be testing recovery and rollback modes after each step in each installation mode. Requires: - https://review.tizen.org/gerrit/#/c/116059/ - https://review.tizen.org/gerrit/#/c/119925/ Change-Id: Ib39dfd3df2f42ff33644904f682775a6a9b113f7 --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 465821f..86b3f98 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,6 +31,7 @@ SET(TARGET_WGT_BACKEND "wgt-backend") SET(TARGET_LIBNAME_HYBRID "hybrid-installer") SET(TARGET_SMOKE_TEST "smoke-test") +SET(TARGET_SMOKE_TEST_EXTENSIVE "extensive-smoke-test") SET(TARGET_SMOKE_TEST_HELPER "smoke-test-helper") SET(TARGET_MANIFEST_TEST "manifest-test") diff --git a/src/unit_tests/CMakeLists.txt b/src/unit_tests/CMakeLists.txt index 5aa1409..6b0aac1 100644 --- a/src/unit_tests/CMakeLists.txt +++ b/src/unit_tests/CMakeLists.txt @@ -6,6 +6,11 @@ ADD_EXECUTABLE(${TARGET_SMOKE_TEST} smoke_utils.h smoke_utils.cc ) +ADD_EXECUTABLE(${TARGET_SMOKE_TEST_EXTENSIVE} + extensive_smoke_test.cc + smoke_utils.h + smoke_utils.cc +) ADD_EXECUTABLE(${TARGET_SMOKE_TEST_HELPER} smoke_test_helper.cc ) @@ -14,6 +19,7 @@ ADD_EXECUTABLE(${TARGET_MANIFEST_TEST} ) TARGET_INCLUDE_DIRECTORIES(${TARGET_SMOKE_TEST} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) +TARGET_INCLUDE_DIRECTORIES(${TARGET_SMOKE_TEST_EXTENSIVE} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) TARGET_INCLUDE_DIRECTORIES(${TARGET_SMOKE_TEST_HELPER} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) TARGET_INCLUDE_DIRECTORIES(${TARGET_MANIFEST_TEST} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) @@ -24,6 +30,11 @@ APPLY_PKG_CONFIG(${TARGET_SMOKE_TEST} PUBLIC GTEST GUM_DEPS ) +APPLY_PKG_CONFIG(${TARGET_SMOKE_TEST_EXTENSIVE} PUBLIC + Boost + GTEST + GUM_DEPS +) APPLY_PKG_CONFIG(${TARGET_MANIFEST_TEST} PUBLIC Boost GTEST @@ -33,9 +44,11 @@ APPLY_PKG_CONFIG(${TARGET_MANIFEST_TEST} PUBLIC # GTest main libraries is still missing, so additional linking of # GTEST_MAIN_LIBRARIES is needed. TARGET_LINK_LIBRARIES(${TARGET_SMOKE_TEST} PRIVATE ${TARGET_LIBNAME_WGT} ${TARGET_LIBNAME_HYBRID} ${GTEST_MAIN_LIBRARIES}) +TARGET_LINK_LIBRARIES(${TARGET_SMOKE_TEST_EXTENSIVE} PRIVATE ${TARGET_LIBNAME_WGT} ${TARGET_LIBNAME_HYBRID} ${GTEST_MAIN_LIBRARIES}) TARGET_LINK_LIBRARIES(${TARGET_SMOKE_TEST_HELPER} PRIVATE ${TARGET_LIBNAME_WGT}) TARGET_LINK_LIBRARIES(${TARGET_MANIFEST_TEST} PRIVATE ${TARGET_LIBNAME_WGT} ${GTEST_MAIN_LIBRARIES}) INSTALL(TARGETS ${TARGET_SMOKE_TEST} DESTINATION ${BINDIR}/${DESTINATION_DIR}) +INSTALL(TARGETS ${TARGET_SMOKE_TEST_EXTENSIVE} DESTINATION ${BINDIR}/${DESTINATION_DIR}) INSTALL(TARGETS ${TARGET_SMOKE_TEST_HELPER} DESTINATION ${BINDIR}/${DESTINATION_DIR}) INSTALL(TARGETS ${TARGET_MANIFEST_TEST} DESTINATION ${BINDIR}/${DESTINATION_DIR}) diff --git a/src/unit_tests/extensive_smoke_test.cc b/src/unit_tests/extensive_smoke_test.cc new file mode 100644 index 0000000..58f11f6 --- /dev/null +++ b/src/unit_tests/extensive_smoke_test.cc @@ -0,0 +1,388 @@ +// Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved +// Use of this source code is governed by an apache-2.0 license that can be +// found in the LICENSE file. + +#include + +#include + +#include +#include + +#include "unit_tests/smoke_utils.h" + + +namespace common_installer { + +class SmokeEnvironment : public testing::Environment { + public: + explicit SmokeEnvironment(ci::RequestMode mode) {\ + request_mode_ = mode; + } + void SetUp() override { + if (request_mode_ == 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 { + ASSERT_TRUE(request_mode_ == ci::RequestMode::GLOBAL || + (request_mode_ == ci::RequestMode::USER && + kGlobalUserUid != kTestUserId)); + UninstallAllSmokeApps(request_mode_); + for (auto& path : backups_) + RestorePath(path); + if (request_mode_ == ci::RequestMode::USER) + ASSERT_TRUE(DeleteTestUser(kNormalUserName)); + } + + private: + ci::RequestMode request_mode_; + std::vector backups_; +}; + +class SmokeTest : public testing::Test { +}; + +class PreloadSmokeTest : public testing::Test { + void SetUp() override { + ASSERT_EQ(kGlobalUserUid, kTestUserId); + } +}; + +TEST_F(SmokeTest, RecoveryMode_ForInstallation) { + bf::path path = kSmokePackagesDirectory / "RecoveryMode_ForInstallation.wgt"; + std::string pkgid = "smokewgt09"; + std::string appid = "smokewgt09.RecoveryModeForInstallation"; + + std::vector args = + {"", "-i", path.string(), "-u", kTestUserIdStr.c_str()}; + CrashAfterEachStep(args, [=](int step) -> bool { + if (step >= 1) { + bf::path recovery_file = FindRecoveryFile(); + EXTENDED_ASSERT_FALSE(recovery_file.empty()); + EXTENDED_ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + EXTENDED_ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); + } + return true; + }); +} + +TEST_F(SmokeTest, RecoveryMode_ForUpdate) { + bf::path path_old = kSmokePackagesDirectory / "RecoveryMode_ForUpdate.wgt"; + bf::path path_new = kSmokePackagesDirectory / "RecoveryMode_ForUpdate_2.wgt"; + RemoveAllRecoveryFiles(); + ASSERT_EQ(Install(path_old, PackageType::WGT), ci::AppInstaller::Result::OK); + std::string pkgid = "smokewgt10"; + std::string appid = "smokewgt10.RecoveryModeForUpdate"; + AddDataFiles(pkgid, kTestUserId); + + std::vector args = + {"", "-i", path_new.string(), "-u", kTestUserIdStr.c_str()}; + CrashAfterEachStep(args, [=](int step) -> bool { + if (step >= 1) { + bf::path recovery_file = FindRecoveryFile(); + EXTENDED_ASSERT_FALSE(recovery_file.empty()); + EXTENDED_ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid})); + + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "res/wgt/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + } + return true; + }); +} + +TEST_F(SmokeTest, RecoveryMode_ForDelta) { + bf::path path_old = kSmokePackagesDirectory / "RecoveryMode_ForDelta.wgt"; + bf::path path_new = kSmokePackagesDirectory / "RecoveryMode_ForDelta.delta"; + std::string pkgid = "smokewgt30"; + std::string appid = "smokewgt30.RecoveryModeForDelta"; + bf::path recovery_file = FindRecoveryFile(); + RemoveAllRecoveryFiles(); + std::vector args = + {"", "-i", path_new.string(), "-u", kTestUserIdStr.c_str()}; + CrashAfterEachStep(args, [=](int step) -> bool { + if (step >= 1) { + EXTENDED_ASSERT_FALSE(recovery_file.empty()); + EXTENDED_ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid})); + + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "res/wgt/VERSION", "1\n")); + } + return true; + }); +} + +TEST_F(SmokeTest, RecoveryMode_ForMountInstall) { + bf::path path = kSmokePackagesDirectory / "RecoveryMode_ForMountInstall.wgt"; + std::string pkgid = "smokewgt31"; + std::string appid = "smokewgt31.RecoveryModeForMountInstall"; + RemoveAllRecoveryFiles(); + std::vector args = + {"", "-w", path.string(), "-u", kTestUserIdStr.c_str()}; + CrashAfterEachStep(args, [=](int step) -> bool { + if (step >= 1) { + bf::path recovery_file = FindRecoveryFile(); + EXTENDED_ASSERT_FALSE(recovery_file.empty()); + EXTENDED_ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + EXTENDED_ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); + } + return true; + }); +} + +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); + std::vector args = + {"", "-w", path_new.string(), "-u", kTestUserIdStr.c_str()}; + CrashAfterEachStep(args, [=](int step) -> bool { + if (step >= 1) { + // Filesystem may be mounted after crash + ScopedTzipInterface poweroff_unmount_interface(pkgid); + poweroff_unmount_interface.Release(); + + bf::path recovery_file = FindRecoveryFile(); + EXTENDED_ASSERT_FALSE(recovery_file.empty()); + EXTENDED_ASSERT_EQ(Recover(recovery_file, PackageType::WGT), + ci::AppInstaller::Result::OK); + + ScopedTzipInterface interface(pkgid); + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid})); + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage( + pkgid, "res/wgt/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + } + return true; + }); +} + + +TEST_F(SmokeTest, InstallationMode_Rollback) { + bf::path path = kSmokePackagesDirectory / "InstallationMode_Rollback.wgt"; + std::string pkgid = "smokewgt06"; + std::string appid = "smokewgt06.InstallationModeRollback"; + + const char* argv[] = {"", "-i", path.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + EXTENDED_ASSERT_EQ(Install(path, PackageType::WGT, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + EXTENDED_ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); + return true; + }); +} + +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 = "smokewgt07"; + std::string appid = "smokewgt07.UpdateModeRollback"; + ASSERT_EQ(Install(path_old, PackageType::WGT), ci::AppInstaller::Result::OK); + AddDataFiles(pkgid, kTestUserId); + const char* argv[] = + {"", "-i", path_new.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + EXTENDED_ASSERT_EQ(Install(path_new, PackageType::WGT, RequestResult::FAIL), + ci::AppInstaller::Result::ERROR); + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid})); + + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "res/wgt/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + return true; + }); +} + +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); + const char* argv[] = + {"", "-i", delta_package.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid})); + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", + "version 1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + EXTENDED_ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res/wgt/DELETED")); + EXTENDED_ASSERT_FALSE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / + "res/wgt/ADDED")); + return true; + }); +} + +TEST_F(SmokeTest, InstallationMode_Rollback_Hybrid) { + bf::path path = kSmokePackagesDirectory / + "InstallationMode_Rollback_Hybrid.wgt"; + std::string pkgid = "smokehyb07"; + std::string appid1 = "smokehyb07.web"; + const char* argv[] = {"", "-i", path.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + EXTENDED_ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid1})); + return true; + }, PackageType::HYBRID); +} + +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); + const char* argv[] = + {"", "-i", path_new.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); + + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "res/wgt/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "lib/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + return true; + }, PackageType::HYBRID); +} + +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); + const char* argv[] = {"", "-i", path.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); + // Check delta modifications + bf::path root_path = GetPackageRoot(pkgid, kTestUserId); + EXTENDED_ASSERT_TRUE(bf::exists(root_path / "res" / "wgt" / "DELETED")); + EXTENDED_ASSERT_FALSE(bf::exists(root_path / "res" / "wgt" / "ADDED")); + EXTENDED_ASSERT_TRUE(bf::exists(root_path / "lib" / "DELETED")); + EXTENDED_ASSERT_FALSE(bf::exists(root_path / "lib" / "ADDED")); + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", + "version 1\n")); + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/MODIFIED", + "version 1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + return true; + }); +} + +TEST_F(SmokeTest, MountInstallationMode_Rollback_Hybrid) { + bf::path path = kSmokePackagesDirectory / + "MountInstallationMode_Rollback_Hybrid.wgt"; + std::string pkgid = "smokehyb09"; + std::string appid1 = "smokehyb09.web"; + const char* argv[] = {"", "-w", path.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + ScopedTzipInterface interface(pkgid); + EXTENDED_ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid1})); + return true; + }, PackageType::HYBRID); +} + +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); + const char* argv[] = + {"", "-w", path_new.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + ScopedTzipInterface interface(pkgid); + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); + + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "res/wgt/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "lib/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + return true; + }); +} + +TEST_F(SmokeTest, MountInstallationMode_Rollback) { + bf::path path = + kSmokePackagesDirectory / "MountInstallationMode_Rollback.wgt"; + std::string pkgid = "smokewgt33"; + std::string appid = "smokewgt33.web"; + const char* argv[] = {"", "-w", path.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + ScopedTzipInterface interface(pkgid); + EXTENDED_ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); + return true; + }); +} + +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); + const char* argv[] = + {"", "-w", path_new.c_str(), "-u", kTestUserIdStr.c_str()}; + TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [=]() -> bool { + EXTENDED_ASSERT_EQ(MountInstall(path_new, PackageType::WGT, + RequestResult::FAIL), ci::AppInstaller::Result::ERROR); + ScopedTzipInterface interface(pkgid); + EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid})); + + EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid, + "res/wgt/VERSION", "1\n")); + EXTENDED_ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); + return true; + }); +} + +} // namespace common_installer + +int main(int argc, char** argv) { + ci::RequestMode request_mode = ParseRequestMode(argc, argv); + if (getuid() != 0 || request_mode != ci::RequestMode::GLOBAL) { + std::cout << "Skip tests for preload request" << std::endl; + ::testing::GTEST_FLAG(filter) = "SmokeTest.*"; + } + testing::InitGoogleTest(&argc, argv); + testing::Environment *env = testing::AddGlobalTestEnvironment( + new common_installer::SmokeEnvironment(request_mode)); + return RUN_ALL_TESTS(); +} diff --git a/src/unit_tests/smoke_test.cc b/src/unit_tests/smoke_test.cc index f446f8a..38c2b01 100644 --- a/src/unit_tests/smoke_test.cc +++ b/src/unit_tests/smoke_test.cc @@ -61,7 +61,7 @@ TEST_F(SmokeTest, InstallationMode) { std::string pkgid = "smokewgt03"; std::string appid = "smokewgt03.InstallationMode"; ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); } TEST_F(SmokeTest, UpdateMode) { @@ -72,10 +72,10 @@ TEST_F(SmokeTest, 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(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, DeinstallationMode) { @@ -86,7 +86,7 @@ TEST_F(SmokeTest, DeinstallationMode) { ci::AppInstaller::Result::OK); ASSERT_EQ(Uninstall(pkgid, PackageType::WGT, false), ci::AppInstaller::Result::OK); - CheckPackageNonExistance(pkgid, {appid}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); } TEST_F(SmokeTest, RDSMode) { @@ -102,7 +102,7 @@ TEST_F(SmokeTest, RDSMode) { ASSERT_TRUE(CopyDir(delta_directory, sdk_expected_directory)); ASSERT_EQ(RDSUpdate(path, pkgid, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); // Check delta modifications ASSERT_FALSE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / @@ -136,7 +136,7 @@ TEST_F(SmokeTest, DisablePkg) { ASSERT_EQ(DisablePackage(pkgid, PackageType::WGT), ci::AppInstaller::Result::OK); ASSERT_TRUE(ci::QueryIsDisabledPackage(pkgid, kTestUserId)); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); } TEST_F(SmokeTest, DeltaMode) { @@ -146,7 +146,7 @@ TEST_F(SmokeTest, DeltaMode) { std::string appid = "smokewgt17.DeltaMode"; ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); // Check delta modifications ASSERT_FALSE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / @@ -175,7 +175,7 @@ TEST_F(SmokeTest, RecoveryMode_ForInstallation) { ASSERT_FALSE(recovery_file.empty()); ASSERT_EQ(Recover(recovery_file, PackageType::WGT), ci::AppInstaller::Result::OK); - CheckPackageNonExistance(pkgid, {appid}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); } TEST_F(SmokeTest, RecoveryMode_ForUpdate) { @@ -194,10 +194,10 @@ TEST_F(SmokeTest, RecoveryMode_ForUpdate) { ASSERT_FALSE(recovery_file.empty()); ASSERT_EQ(Recover(recovery_file, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, RecoveryMode_ForDelta) { @@ -215,7 +215,7 @@ TEST_F(SmokeTest, RecoveryMode_ForDelta) { ASSERT_FALSE(recovery_file.empty()); ASSERT_EQ(Recover(recovery_file, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); } @@ -233,7 +233,7 @@ TEST_F(SmokeTest, RecoveryMode_ForMountInstall) { ASSERT_FALSE(recovery_file.empty()); ASSERT_EQ(Recover(recovery_file, PackageType::WGT), ci::AppInstaller::Result::OK); - CheckPackageNonExistance(pkgid, {appid}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); } TEST_F(SmokeTest, RecoveryMode_ForMountUpdate) { @@ -261,9 +261,9 @@ TEST_F(SmokeTest, RecoveryMode_ForMountUpdate) { ci::AppInstaller::Result::OK); ScopedTzipInterface interface(pkgid); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, InstallationMode_GoodSignature) { @@ -284,7 +284,7 @@ TEST_F(SmokeTest, InstallationMode_Rollback) { std::string appid = "smokewgt06.InstallationModeRollback"; ASSERT_EQ(Install(path, PackageType::WGT, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); - CheckPackageNonExistance(pkgid, {appid}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); } TEST_F(SmokeTest, UpdateMode_Rollback) { @@ -296,10 +296,10 @@ TEST_F(SmokeTest, UpdateMode_Rollback) { AddDataFiles(pkgid, kTestUserId); ASSERT_EQ(Install(path_new, PackageType::WGT, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, DeltaMode_Rollback) { @@ -312,10 +312,10 @@ TEST_F(SmokeTest, DeltaMode_Rollback) { ASSERT_EQ(Install(delta_package, PackageType::WGT, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/MODIFIED", "version 1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); ASSERT_TRUE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / "res/wgt/DELETED")); ASSERT_FALSE(bf::exists(GetPackageRoot(pkgid, kTestUserId) / @@ -328,7 +328,7 @@ TEST_F(SmokeTest, InstallationMode_Hybrid) { // 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}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); } TEST_F(SmokeTest, UpdateMode_Hybrid) { @@ -341,7 +341,7 @@ TEST_F(SmokeTest, UpdateMode_Hybrid) { // AddDataFiles(pkgid, kTestUserId); ASSERT_EQ(Install(path_new, PackageType::HYBRID), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid1}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "VERSION", "2\n")); @@ -356,7 +356,7 @@ TEST_F(SmokeTest, DeinstallationMode_Hybrid) { ci::AppInstaller::Result::OK); ASSERT_EQ(Uninstall(pkgid, PackageType::HYBRID, false), ci::AppInstaller::Result::OK); - CheckPackageNonExistance(pkgid, {appid1}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid1})); } TEST_F(SmokeTest, DeltaMode_Hybrid) { @@ -366,7 +366,7 @@ TEST_F(SmokeTest, DeltaMode_Hybrid) { std::string appid1 = "smokehyb04.Web"; ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::HYBRID), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid1}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); // Check delta modifications bf::path root_path = ci::GetRootAppPath(false, @@ -389,7 +389,7 @@ TEST_F(SmokeTest, MountInstallationMode_Hybrid) { ASSERT_EQ(MountInstall(path, PackageType::HYBRID), ci::AppInstaller::Result::OK); ScopedTzipInterface interface(pkgid); - ValidatePackage(pkgid, {appid1}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); } TEST_F(SmokeTest, MountUpdateMode_Hybrid) { @@ -403,11 +403,11 @@ TEST_F(SmokeTest, MountUpdateMode_Hybrid) { ASSERT_EQ(MountInstall(path_new, PackageType::HYBRID), ci::AppInstaller::Result::OK); ScopedTzipInterface interface(pkgid); - ValidatePackage(pkgid, {appid1}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/VERSION", "2\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, InstallationMode_Rollback_Hybrid) { @@ -417,7 +417,7 @@ TEST_F(SmokeTest, InstallationMode_Rollback_Hybrid) { std::string appid1 = "smokehyb07.web"; ASSERT_EQ(Install(path, PackageType::HYBRID, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); - CheckPackageNonExistance(pkgid, {appid1}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid1})); } TEST_F(SmokeTest, UpdateMode_Rollback_Hybrid) { @@ -432,11 +432,11 @@ TEST_F(SmokeTest, UpdateMode_Rollback_Hybrid) { AddDataFiles(pkgid, kTestUserId); ASSERT_EQ(Install(path_new, PackageType::HYBRID, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); - ValidatePackage(pkgid, {appid1}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/VERSION", "1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, DeltaMode_Rollback_Hybrid) { @@ -450,7 +450,7 @@ TEST_F(SmokeTest, DeltaMode_Rollback_Hybrid) { ASSERT_EQ(Install(delta_package, PackageType::HYBRID, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); - ValidatePackage(pkgid, {appid1}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); // Check delta modifications bf::path root_path = GetPackageRoot(pkgid, kTestUserId); ASSERT_TRUE(bf::exists(root_path / "res" / "wgt" / "DELETED")); @@ -461,7 +461,7 @@ TEST_F(SmokeTest, DeltaMode_Rollback_Hybrid) { "version 1\n")); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/MODIFIED", "version 1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, MountInstallationMode_Rollback_Hybrid) { @@ -472,7 +472,7 @@ TEST_F(SmokeTest, MountInstallationMode_Rollback_Hybrid) { ASSERT_EQ(MountInstall(path, PackageType::HYBRID, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); ScopedTzipInterface interface(pkgid); - CheckPackageNonExistance(pkgid, {appid1}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid1})); } TEST_F(SmokeTest, MountUpdateMode_Rollback_Hybrid) { @@ -488,11 +488,11 @@ TEST_F(SmokeTest, MountUpdateMode_Rollback_Hybrid) { ASSERT_EQ(MountInstall(path_new, PackageType::HYBRID, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); ScopedTzipInterface interface(pkgid); - ValidatePackage(pkgid, {appid1}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid1})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "lib/VERSION", "1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, MountInstallationMode) { @@ -501,7 +501,7 @@ TEST_F(SmokeTest, MountInstallationMode) { std::string appid = "smokewgt28.InstallationMode"; ASSERT_EQ(MountInstall(path, PackageType::WGT), ci::AppInstaller::Result::OK); ScopedTzipInterface interface(pkgid); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); } TEST_F(SmokeTest, MountUpdateMode) { @@ -515,10 +515,10 @@ TEST_F(SmokeTest, MountUpdateMode) { ASSERT_EQ(MountInstall(path_new, PackageType::WGT), ci::AppInstaller::Result::OK); ScopedTzipInterface interface(pkgid); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, MountInstallationMode_Rollback) { @@ -529,7 +529,7 @@ TEST_F(SmokeTest, MountInstallationMode_Rollback) { ASSERT_EQ(MountInstall(path, PackageType::WGT, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); ScopedTzipInterface interface(pkgid); - CheckPackageNonExistance(pkgid, {appid}); + ASSERT_TRUE(CheckPackageNonExistance(pkgid, {appid})); } TEST_F(SmokeTest, MountUpdateMode_Rollback) { @@ -544,10 +544,10 @@ TEST_F(SmokeTest, MountUpdateMode_Rollback) { ASSERT_EQ(MountInstall(path_new, PackageType::WGT, RequestResult::FAIL), ci::AppInstaller::Result::ERROR); ScopedTzipInterface interface(pkgid); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(ValidatePackage(pkgid, {appid})); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "1\n")); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(SmokeTest, UserDefinedPlugins) { @@ -559,7 +559,7 @@ TEST_F(SmokeTest, UserDefinedPlugins) { std::string power_privilege = "http://tizen.org/privilege/power"; ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(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()); @@ -597,7 +597,7 @@ TEST_F(PreloadSmokeTest, InstallationMode_Preload) { std::string appid = "smokewgt37.InstallationModePreload"; ASSERT_EQ(InstallPreload(path, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}, true); + ASSERT_TRUE(ValidatePackage(pkgid, {appid}, true)); } TEST_F(PreloadSmokeTest, UpdateMode_Preload) { @@ -611,11 +611,11 @@ TEST_F(PreloadSmokeTest, UpdateMode_Preload) { AddDataFiles(pkgid, kTestUserId); ASSERT_EQ(InstallPreload(path_new, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}, true); + ASSERT_TRUE(ValidatePackage(pkgid, {appid}, true)); ASSERT_TRUE(ValidateFileContentInPackage(pkgid, "res/wgt/VERSION", "2", true)); - ValidateDataFiles(pkgid, kTestUserId); + ASSERT_TRUE(ValidateDataFiles(pkgid, kTestUserId)); } TEST_F(PreloadSmokeTest, DeinstallationMode_Preload) { @@ -646,7 +646,7 @@ TEST_F(SmokeTest, SharedRes30) { std::string pkgid = "smokeSh3xx"; std::string appid = "smokeSh3xx.SharedRes30"; ASSERT_EQ(Install(path, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(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 @@ -659,7 +659,7 @@ TEST_F(SmokeTest, SharedRes30Delta) { std::string appid = "smokeSh3De.SharedRes30Delta"; ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::WGT), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid}); + ASSERT_TRUE(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 @@ -674,7 +674,7 @@ TEST_F(SmokeTest, SharedRes30Hybrid) { std::string appid1 = "smokeSh3Hy.SharedRes30Hybrid"; std::string appid2 = "sharedres30hybridserivce"; ASSERT_EQ(Install(path, PackageType::HYBRID), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid1, appid2}); + ASSERT_TRUE(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 @@ -691,7 +691,7 @@ TEST_F(SmokeTest, SharedRes30HybridDelta) { std::string appid2 = "sharedres30hybriddeltaserivce"; ASSERT_EQ(DeltaInstall(path, delta_package, PackageType::HYBRID), ci::AppInstaller::Result::OK); - ValidatePackage(pkgid, {appid1, appid2}); + ASSERT_TRUE(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 diff --git a/src/unit_tests/smoke_test_helper.cc b/src/unit_tests/smoke_test_helper.cc index 0d37d1c..4501e89 100644 --- a/src/unit_tests/smoke_test_helper.cc +++ b/src/unit_tests/smoke_test_helper.cc @@ -31,6 +31,14 @@ class StepCrash : public ci::Step { // this main of test binay in done purely for recovery smoke test. int main(int argc, char** argv) { + int index = -1; + int backend_argc = argc; + if (!strcmp(argv[argc-2], "-idx")) { + index = atoi(argv[argc-1]); + backend_argc = argc - 2; + LOG(DEBUG) << "Step crash after " << index << " step."; + } + ci::PkgmgrInstaller pkgmgr_installer; wgt::WgtAppQueryInterface query_interface; auto pkgmgr = ci::PkgMgrInterface::Create(argc, argv, &pkgmgr_installer, @@ -41,7 +49,11 @@ int main(int argc, char** argv) { } wgt::WgtInstaller installer(pkgmgr); - installer.AddStep(); + if (index != -1) { + installer.AddStepAtIndex(index); + } else { + installer.AddStep(); + } return (installer.Run() == ci::AppInstaller::Result::OK) ? 0 : 1; } diff --git a/src/unit_tests/smoke_utils.cc b/src/unit_tests/smoke_utils.cc index c1750f1..fff20f4 100644 --- a/src/unit_tests/smoke_utils.cc +++ b/src/unit_tests/smoke_utils.cc @@ -8,6 +8,7 @@ #include #include +#include #include #include #include @@ -249,82 +250,83 @@ void AddDataFiles(const std::string& pkgid, uid_t uid) { } } -void ValidateDataFiles(const std::string& pkgid, uid_t uid) { +bool 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")); + EXTENDED_ASSERT_TRUE(bf::exists(pkg_path / "data" / "file1.txt")); + EXTENDED_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")); + EXTENDED_ASSERT_TRUE(bf::exists(pkg_path / "data" / "file1.txt")); + EXTENDED_ASSERT_TRUE(bf::exists(pkg_path / "data" / "file2.txt")); } + return true; } -void ValidatePackageRWFS(const std::string& pkgid, uid_t uid) { +bool 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)); + EXTENDED_ASSERT_TRUE(bf::exists(data_path)); + EXTENDED_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; + EXTENDED_ASSERT_EQ(uid, stats.st_uid); + EXTENDED_ASSERT_EQ(*system_share, stats.st_gid); 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; + EXTENDED_ASSERT_EQ(uid, stats.st_uid); + EXTENDED_ASSERT_EQ(*system_share, stats.st_gid); } 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; + EXTENDED_ASSERT_EQ(uid, stats.st_uid); + EXTENDED_ASSERT_EQ(*system_share, stats.st_gid); + return true; } -void ValidatePackageFS(const std::string& pkgid, +bool 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 shared_path = package_path / "shared"; - ASSERT_TRUE(bf::exists(root_path)); - ASSERT_TRUE(bf::exists(package_path)); - ASSERT_TRUE(bf::exists(shared_path)); + EXTENDED_ASSERT_TRUE(bf::exists(root_path)); + EXTENDED_ASSERT_TRUE(bf::exists(package_path)); + EXTENDED_ASSERT_TRUE(bf::exists(shared_path)); bf::path manifest_path = bf::path(getUserManifestPath(uid, is_readonly)) / (pkgid + ".xml"); - ASSERT_TRUE(bf::exists(manifest_path)); + EXTENDED_ASSERT_TRUE(bf::exists(manifest_path)); for (auto& appid : appids) { bf::path binary_path = package_path / "bin" / appid; - ASSERT_TRUE(bf::exists(binary_path)); + EXTENDED_ASSERT_TRUE(bf::exists(binary_path)); } bf::path widget_root_path = package_path / "res" / "wgt"; bf::path config_path = widget_root_path / "config.xml"; - ASSERT_TRUE(bf::exists(widget_root_path)); - ASSERT_TRUE(bf::exists(config_path)); + EXTENDED_ASSERT_TRUE(bf::exists(widget_root_path)); + EXTENDED_ASSERT_TRUE(bf::exists(config_path)); bf::path private_tmp_path = package_path / "tmp"; - ASSERT_TRUE(bf::exists(private_tmp_path)); + EXTENDED_ASSERT_TRUE(bf::exists(private_tmp_path)); // backups should not exist bf::path package_backup = ci::GetBackupPathForPackagePath(package_path); bf::path manifest_backup = ci::GetBackupPathForManifestFile(manifest_path); - ASSERT_FALSE(bf::exists(package_backup)); - ASSERT_FALSE(bf::exists(manifest_backup)); + EXTENDED_ASSERT_FALSE(bf::exists(package_backup)); + EXTENDED_ASSERT_FALSE(bf::exists(manifest_backup)); for (bf::recursive_directory_iterator iter(package_path); iter != bf::recursive_directory_iterator(); ++iter) { @@ -342,9 +344,10 @@ void ValidatePackageFS(const std::string& pkgid, } 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(); + EXTENDED_ASSERT_EQ(uid, stats.st_uid); + EXTENDED_ASSERT_EQ(gid, stats.st_gid); } + return true; } void PackageCheckCleanup(const std::string& pkgid, @@ -364,18 +367,20 @@ void PackageCheckCleanup(const std::string& pkgid, ASSERT_FALSE(bf::exists(manifest_backup)); } -void ValidatePackage(const std::string& pkgid, +bool ValidatePackage(const std::string& pkgid, const std::vector& appids, bool is_readonly) { - ASSERT_TRUE(ci::QueryIsPackageInstalled( + EXTENDED_ASSERT_TRUE(ci::QueryIsPackageInstalled( pkgid, ci::GetRequestMode(kTestUserId), kTestUserId)); - ValidatePackageFS(pkgid, appids, kTestUserId, kTestGroupId, is_readonly); + EXTENDED_ASSERT_TRUE(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)); + EXTENDED_ASSERT_TRUE(ValidatePackageRWFS(pkgid, std::get<0>(l))); } else { - ValidatePackageRWFS(pkgid, kTestUserId); + EXTENDED_ASSERT_TRUE(ValidatePackageRWFS(pkgid, kTestUserId)); } + return true; } void ValidateExternalPackageFS(const std::string& pkgid, @@ -411,22 +416,23 @@ void ValidateExternalPackage(const std::string& pkgid, } } -void CheckPackageNonExistance(const std::string& pkgid, +bool CheckPackageNonExistance(const std::string& pkgid, const std::vector& appids) { - ASSERT_FALSE(ci::QueryIsPackageInstalled( + EXTENDED_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)); + EXTENDED_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)); + EXTENDED_ASSERT_FALSE(bf::exists(package_path)); } } + return true; } void CheckPackageReadonlyNonExistance(const std::string& pkgid, @@ -456,6 +462,68 @@ std::unique_ptr CreateInstaller(ci::PkgMgrPtr pkgmgr, } } +void TestRollbackAfterEachStep(int argc, const char*argv[], + std::function validator, + PackageType type) { + TestPkgmgrInstaller pkgmgr_installer; + std::unique_ptr query_interface = + CreateQueryInterface(); + auto pkgmgr = + ci::PkgMgrInterface::Create(argc, const_cast(argv), + &pkgmgr_installer, + query_interface.get()); + if (!pkgmgr) { + LOG(ERROR) << "Failed to initialize pkgmgr interface"; + return; + } + std::unique_ptr backend = CreateInstaller(pkgmgr, type); + int i; + for (i = backend->StepCount()-1; i >= 0; i--) { + backend->AddStepAtIndex(i); + LOG(DEBUG) << "StepFail is inserted at: " << i; + ASSERT_EQ(ci::AppInstaller::Result::ERROR, + backend->Run()); + if (!validator()) + break; + } + ASSERT_EQ(-1, i); +} + +void CrashAfterEachStep(std::vector args, + std::function validator, + PackageType type) { + std::unique_ptr argv(new const char*[args.size()]); + for (size_t i = 0; i < args.size(); ++i) { + argv[i] = args[i].c_str(); + } + TestPkgmgrInstaller pkgmgr_installer; + std::unique_ptr query_interface = + CreateQueryInterface(); + auto pkgmgr = + ci::PkgMgrInterface::Create(args.size(), const_cast(argv.get()), + &pkgmgr_installer, + query_interface.get()); + if (!pkgmgr) { + LOG(ERROR) << "Failed to initialize pkgmgr interface"; + return; + } + std::unique_ptr backend = CreateInstaller(pkgmgr, type); + int stepCount = backend->StepCount(); + + args.push_back("-idx"); + args.push_back(std::to_string(stepCount)); + int i; + for (i = 0; i < stepCount; i++) { + ci::Subprocess backend_crash("/usr/bin/tpk-backend-ut/smoke-test-helper"); + args.back() = std::to_string(i); + backend_crash.Run(args); + ASSERT_NE(backend_crash.Wait(), 0); + if (!validator(i)) + break; + } + ASSERT_EQ(stepCount, i); +} + ci::AppInstaller::Result RunInstallerWithPkgrmgr(ci::PkgMgrPtr pkgmgr, PackageType type, RequestResult mode) { diff --git a/src/unit_tests/smoke_utils.h b/src/unit_tests/smoke_utils.h index efc2551..d0a4b47 100644 --- a/src/unit_tests/smoke_utils.h +++ b/src/unit_tests/smoke_utils.h @@ -5,6 +5,7 @@ #ifndef UNIT_TESTS_SMOKE_UTILS_H_ #define UNIT_TESTS_SMOKE_UTILS_H_ + #include #include @@ -25,6 +26,27 @@ #define SIZEOFARRAY(ARR) \ sizeof(ARR) / sizeof(ARR[0]) \ +#define EXTENDED_ASSERT_TRUE(expression) do { \ + bool tmp = expression; \ + EXPECT_TRUE(tmp) << #expression << " is not true"; \ + if (!tmp) \ + return false; \ +} while (0); + +#define EXTENDED_ASSERT_FALSE(expression) do { \ + bool tmp = expression; \ + EXPECT_FALSE(tmp) << #expression << " is not false"; \ + if (tmp) \ + return false; \ +} while (0); + +#define EXTENDED_ASSERT_EQ(expression, value) do { \ + auto ret = expression; \ + EXPECT_EQ(ret, value) << #expression << " is not equal to " << #value; \ + if (ret != value) \ + return false; \ +} while (0); + namespace bf = boost::filesystem; namespace bs = boost::system; namespace ci = common_installer; @@ -140,18 +162,18 @@ bool ValidateFileContentInPackage(const std::string& pkgid, void AddDataFiles(const std::string& pkgid, uid_t uid); -void ValidateDataFiles(const std::string& pkgid, uid_t uid); +bool ValidateDataFiles(const std::string& pkgid, uid_t uid); -void ValidatePackageRWFS(const std::string& pkgid, uid_t uid); +bool ValidatePackageRWFS(const std::string& pkgid, uid_t uid); -void ValidatePackageFS(const std::string& pkgid, +bool ValidatePackageFS(const std::string& pkgid, const std::vector& appids, uid_t uid, gid_t gid, bool is_readonly); void PackageCheckCleanup(const std::string& pkgid, const std::vector&, bool is_readonly = false); -void ValidatePackage(const std::string& pkgid, +bool ValidatePackage(const std::string& pkgid, const std::vector& appids, bool is_readonly = false); void ValidateExternalPackageFS(const std::string& pkgid, @@ -161,7 +183,7 @@ void ValidateExternalPackageFS(const std::string& pkgid, void ValidateExternalPackage(const std::string& pkgid, const std::vector& appids); -void CheckPackageNonExistance(const std::string& pkgid, +bool CheckPackageNonExistance(const std::string& pkgid, const std::vector& appids); void CheckPackageReadonlyNonExistance(const std::string& pkgid, @@ -172,6 +194,14 @@ std::unique_ptr CreateQueryInterface(); std::unique_ptr CreateInstaller(ci::PkgMgrPtr pkgmgr, PackageType type); +void TestRollbackAfterEachStep(int argc, const char*argv[], + std::function validator, + PackageType type = PackageType::WGT); + +void CrashAfterEachStep(std::vector args, + std::function validator, + PackageType type = PackageType::WGT); + ci::AppInstaller::Result RunInstallerWithPkgrmgr(ci::PkgMgrPtr pkgmgr, PackageType type, RequestResult mode);