test/smoke_tests/wgt_smoke_utils.h

   1 // Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   2 // Use of this source code is governed by an apache-2.0 license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef TEST_SMOKE_TESTS_WGT_SMOKE_UTILS_H_
   6 #define TEST_SMOKE_TESTS_WGT_SMOKE_UTILS_H_
   7
   8 #include <common/installer/app_installer.h>
   9 #include <common/pkgmgr_interface.h>
  10 #include <common/step/configuration/step_fail.h>
  11 #include <smoke_tests/common/smoke_utils.h>
  12
  13 #include <memory>
  14 #include <string>
  15 #include <vector>
  16
  17 #include "hybrid/hybrid_installer.h"
  18 #include "wgt/wgt_installer.h"
  19 #include "wgt/utils/wgt_app_query_interface.h"
  20
  21 namespace smoke_test {
  22
  23 bool ValidatePackage(const std::string& pkgid,
  24     const std::vector<std::string>& appids,
  25     const TestParameters& params);
  26
  27 bool ValidateExternalPackage(const std::string& pkgid,
  28     const std::vector<std::string>& appids,
  29     const TestParameters& params);
  30
  31 bool ValidateExtendedPackage(const std::string& pkgid,
  32     const std::vector<std::string>& appids,
  33     const TestParameters& params);
  34
  35 extern const bf::path kSmokePackagesDirectory;
  36
  37 class WgtBackendInterface: public BackendInterface {
  38  public:
  39   using BackendInterface::BackendInterface;
  40
  41 // private:
  42   AppQueryInterfacePtr CreateQueryInterface() const override;
  43   AppInstallerPtr CreateInstaller(
  44       common_installer::PkgMgrPtr pkgmgr) const override;
  45   AppInstallerPtr CreateFailExpectedInstaller(
  46       common_installer::PkgMgrPtr pkgmgr, int fail_at) const override;
  47   common_installer::Subprocess CreateSubprocess() const override;
  48 };
  49
  50 class HybridBackendInterface: public BackendInterface {
  51  public:
  52   using BackendInterface::BackendInterface;
  53
  54   AppQueryInterfacePtr CreateQueryInterface() const override;
  55   AppInstallerPtr CreateInstaller(
  56       common_installer::PkgMgrPtr pkgmgr) const override;
  57   AppInstallerPtr CreateFailExpectedInstaller(
  58       common_installer::PkgMgrPtr pkgmgr, int fail_at) const override;
  59 };
  60
  61 #ifdef OVERRIDE_STEPS_BLOCK
  62 #undef OVERRIDE_STEPS_BLOCK
  63 #endif
  64 #define OVERRIDE_STEPS_BLOCK(TYPE, STEPS)                                      \
  65   void STEPS() override {                                                      \
  66     TYPE::STEPS();                                                             \
  67     if (fail_at_ > -1)                                                         \
  68       AddStepAtIndex<common_installer::configuration::StepFail>(fail_at_);     \
  69     else                                                                       \
  70       AddStep<common_installer::configuration::StepFail>();                    \
  71   }                                                                            \
  72
  73 class FailExpectedWgtInstaller : public wgt::WgtInstaller {
  74  public:
  75   explicit FailExpectedWgtInstaller(
  76       common_installer::PkgMgrPtr pkgmgr, int fail_at)
  77       : wgt::WgtInstaller(pkgmgr), fail_at_(fail_at) { }
  78
  79  private:
  80   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, InstallSteps)
  81   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, UpdateSteps)
  82   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, UninstallSteps)
  83   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReinstallSteps)
  84   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, DeltaSteps)
  85   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MoveSteps)
  86   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, RecoverySteps)
  87   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MountInstallSteps)
  88   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MountUpdateSteps)
  89   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestDirectInstallSteps)
  90   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestDirectUpdateSteps)
  91   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestPartialInstallSteps)
  92   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestPartialUpdateSteps)
  93   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, PartialUninstallSteps)
  94   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReadonlyUpdateInstallSteps)
  95   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReadonlyUpdateUninstallSteps)
  96   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, DisablePkgSteps)
  97   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, EnablePkgSteps)
  98   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MigrateExtImgSteps)
  99   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, RecoverDBSteps)
 100
 101   int fail_at_;
 102 };
 103
 104 class FailExpectedHybridInstaller : public hybrid::HybridInstaller {
 105  public:
 106   explicit FailExpectedHybridInstaller(
 107       common_installer::PkgMgrPtr pkgmgr, int fail_at)
 108       : hybrid::HybridInstaller(pkgmgr), fail_at_(fail_at) { }
 109
 110  private:
 111   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, InstallSteps)
 112   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, UpdateSteps)
 113   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, UninstallSteps)
 114   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReinstallSteps)
 115   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, DeltaSteps)
 116   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MoveSteps)
 117   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, RecoverySteps)
 118   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MountInstallSteps)
 119   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MountUpdateSteps)
 120   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestDirectInstallSteps)
 121   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestDirectUpdateSteps)
 122   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestPartialInstallSteps)
 123   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestPartialUpdateSteps)
 124   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, PartialUninstallSteps)
 125   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReadonlyUpdateInstallSteps)
 126   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReadonlyUpdateUninstallSteps)
 127   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, DisablePkgSteps)
 128   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, EnablePkgSteps)
 129   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MigrateExtImgSteps)
 130   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, RecoverDBSteps)
 131
 132   int fail_at_;
 133 };
 134
 135 #ifdef OVERRIDE_STEPS_BLOCK
 136 #undef OVERRIDE_STEPS_BLOCK
 137 #endif
 138 #define OVERRIDE_STEPS_BLOCK(STEPS)                                            \
 139   void STEPS() override {                                                      \
 140     wgt::WgtInstaller::STEPS();                                                \
 141     if (crash_at_ > -1)                                                        \
 142       AddStepAtIndex<StepCrash>(crash_at_, type_);                             \
 143     else if (step_name_.size())                                                \
 144       AddStepAfter<StepCrash>(step_name_, type_);                              \
 145     else                                                                       \
 146       AddStep<StepCrash>(type_);                                               \
 147   }                                                                            \
 148
 149 class CrashWgtInstaller : public wgt::WgtInstaller {
 150  public:
 151   explicit CrashWgtInstaller(common_installer::PkgMgrPtr pkgmgr, int crash_at,
 152       std::string step_name, CrashStepType type) :
 153           wgt::WgtInstaller(pkgmgr), crash_at_(crash_at),
 154           step_name_(step_name), type_(type) { }
 155
 156  private:
 157   OVERRIDE_STEPS_BLOCK(InstallSteps)
 158   OVERRIDE_STEPS_BLOCK(UpdateSteps)
 159   OVERRIDE_STEPS_BLOCK(UninstallSteps)
 160   OVERRIDE_STEPS_BLOCK(ReinstallSteps)
 161   OVERRIDE_STEPS_BLOCK(DeltaSteps)
 162   OVERRIDE_STEPS_BLOCK(MoveSteps)
 163   OVERRIDE_STEPS_BLOCK(RecoverySteps)
 164   OVERRIDE_STEPS_BLOCK(MountInstallSteps)
 165   OVERRIDE_STEPS_BLOCK(MountUpdateSteps)
 166   OVERRIDE_STEPS_BLOCK(ManifestDirectInstallSteps)
 167   OVERRIDE_STEPS_BLOCK(ManifestDirectUpdateSteps)
 168   OVERRIDE_STEPS_BLOCK(ManifestPartialInstallSteps)
 169   OVERRIDE_STEPS_BLOCK(ManifestPartialUpdateSteps)
 170   OVERRIDE_STEPS_BLOCK(PartialUninstallSteps)
 171   OVERRIDE_STEPS_BLOCK(ReadonlyUpdateInstallSteps)
 172   OVERRIDE_STEPS_BLOCK(ReadonlyUpdateUninstallSteps)
 173   OVERRIDE_STEPS_BLOCK(DisablePkgSteps)
 174   OVERRIDE_STEPS_BLOCK(EnablePkgSteps)
 175   OVERRIDE_STEPS_BLOCK(MigrateExtImgSteps)
 176   OVERRIDE_STEPS_BLOCK(RecoverDBSteps)
 177
 178   int crash_at_;
 179   std::string step_name_;
 180   CrashStepType type_;
 181 };
 182
 183 #ifdef OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS
 184 #undef OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS
 185 #endif
 186 #define OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(TYPE, STEPS)               \
 187   void STEPS() override {                                                      \
 188     TYPE::STEPS();                                                             \
 189     RemoveStep("RunParserPlugin");                                             \
 190   }                                                                            \
 191
 192 class WgtInstallerWithoutPasrserPlugins : public wgt::WgtInstaller {
 193  public:
 194   explicit WgtInstallerWithoutPasrserPlugins(
 195       common_installer::PkgMgrPtr pkgmgr) : wgt::WgtInstaller(pkgmgr) { }
 196
 197  private:
 198   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 199       wgt::WgtInstaller, InstallSteps)
 200   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 201       wgt::WgtInstaller, UpdateSteps)
 202   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 203       wgt::WgtInstaller, UninstallSteps)
 204   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 205       wgt::WgtInstaller, ReinstallSteps)
 206   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 207       wgt::WgtInstaller, DeltaSteps)
 208   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 209       wgt::WgtInstaller, MoveSteps)
 210   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 211       wgt::WgtInstaller, MountInstallSteps)
 212   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 213       wgt::WgtInstaller, MountUpdateSteps)
 214   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 215       wgt::WgtInstaller, ManifestDirectInstallSteps)
 216   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 217       wgt::WgtInstaller, ManifestDirectUpdateSteps)
 218   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 219       wgt::WgtInstaller, ManifestPartialInstallSteps)
 220   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 221       wgt::WgtInstaller, ManifestPartialUpdateSteps)
 222   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 223       wgt::WgtInstaller, PartialUninstallSteps)
 224   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 225       wgt::WgtInstaller, ReadonlyUpdateInstallSteps)
 226   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 227       wgt::WgtInstaller, ReadonlyUpdateUninstallSteps)
 228   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 229       wgt::WgtInstaller, DisablePkgSteps)
 230   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 231       wgt::WgtInstaller, EnablePkgSteps)
 232   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 233       wgt::WgtInstaller, MigrateExtImgSteps)
 234   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 235       wgt::WgtInstaller, RecoverDBSteps)
 236   void RecoverySteps() override {
 237     wgt::WgtInstaller::RecoverySteps();
 238     RemoveStep("RecoverParserPlugin");
 239   }
 240 };
 241
 242 class HybridInstallerWithoutPasrserPlugins : public hybrid::HybridInstaller {
 243  public:
 244   explicit HybridInstallerWithoutPasrserPlugins(
 245       common_installer::PkgMgrPtr pkgmgr) : hybrid::HybridInstaller(pkgmgr) { }
 246
 247  private:
 248   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 249       hybrid::HybridInstaller, InstallSteps)
 250   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 251       hybrid::HybridInstaller, UpdateSteps)
 252   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 253       hybrid::HybridInstaller, UninstallSteps)
 254   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 255       hybrid::HybridInstaller, ReinstallSteps)
 256   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 257       hybrid::HybridInstaller, DeltaSteps)
 258   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 259       hybrid::HybridInstaller, MoveSteps)
 260   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 261       hybrid::HybridInstaller, MountInstallSteps)
 262   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 263       hybrid::HybridInstaller, MountUpdateSteps)
 264   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 265       hybrid::HybridInstaller, ManifestDirectInstallSteps)
 266   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 267       hybrid::HybridInstaller, ManifestDirectUpdateSteps)
 268   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 269       hybrid::HybridInstaller, ManifestPartialInstallSteps)
 270   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 271       hybrid::HybridInstaller, ManifestPartialUpdateSteps)
 272   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 273       hybrid::HybridInstaller, PartialUninstallSteps)
 274   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 275       hybrid::HybridInstaller, ReadonlyUpdateInstallSteps)
 276   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 277       hybrid::HybridInstaller, ReadonlyUpdateUninstallSteps)
 278   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 279       hybrid::HybridInstaller, DisablePkgSteps)
 280   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 281       hybrid::HybridInstaller, EnablePkgSteps)
 282   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 283       hybrid::HybridInstaller, MigrateExtImgSteps)
 284   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 285       hybrid::HybridInstaller, RecoverDBSteps)
 286   void RecoverySteps() override {
 287     hybrid::HybridInstaller::RecoverySteps();
 288     RemoveStep("RecoverParserPlugin");
 289   }
 290 };
 291
 292 }  // namespace smoke_test
 293
 294
 295 #endif  // TEST_SMOKE_TESTS_WGT_SMOKE_UTILS_H_