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   common_installer::Subprocess CreateSubprocess() const override;
  60 };
  61
  62 #ifdef OVERRIDE_STEPS_BLOCK
  63 #undef OVERRIDE_STEPS_BLOCK
  64 #endif
  65 #define OVERRIDE_STEPS_BLOCK(TYPE, STEPS)                                      \
  66   void STEPS() override {                                                      \
  67     TYPE::STEPS();                                                             \
  68     if (fail_at_ > -1)                                                         \
  69       AddStepAtIndex<common_installer::configuration::StepFail>(fail_at_);     \
  70     else                                                                       \
  71       AddStep<common_installer::configuration::StepFail>();                    \
  72   }                                                                            \
  73
  74 class FailExpectedWgtInstaller : public wgt::WgtInstaller {
  75  public:
  76   explicit FailExpectedWgtInstaller(
  77       common_installer::PkgMgrPtr pkgmgr, int fail_at)
  78       : wgt::WgtInstaller(pkgmgr), fail_at_(fail_at) { }
  79
  80  private:
  81   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, InstallSteps)
  82   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, UpdateSteps)
  83   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, UninstallSteps)
  84   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReinstallSteps)
  85   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, DeltaSteps)
  86   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MoveSteps)
  87   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, RecoverySteps)
  88   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MountInstallSteps)
  89   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MountUpdateSteps)
  90   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestDirectInstallSteps)
  91   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestDirectUpdateSteps)
  92   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestPartialInstallSteps)
  93   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestPartialUpdateSteps)
  94   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, PartialUninstallSteps)
  95   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReadonlyUpdateInstallSteps)
  96   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReadonlyUpdateUninstallSteps)
  97   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, DisablePkgSteps)
  98   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, EnablePkgSteps)
  99   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MigrateExtImgSteps)
 100   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, RecoverDBSteps)
 101
 102   int fail_at_;
 103 };
 104
 105 class FailExpectedHybridInstaller : public hybrid::HybridInstaller {
 106  public:
 107   explicit FailExpectedHybridInstaller(
 108       common_installer::PkgMgrPtr pkgmgr, int fail_at)
 109       : hybrid::HybridInstaller(pkgmgr), fail_at_(fail_at) { }
 110
 111  private:
 112   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, InstallSteps)
 113   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, UpdateSteps)
 114   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, UninstallSteps)
 115   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReinstallSteps)
 116   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, DeltaSteps)
 117   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MoveSteps)
 118   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, RecoverySteps)
 119   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MountInstallSteps)
 120   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MountUpdateSteps)
 121   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestDirectInstallSteps)
 122   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestDirectUpdateSteps)
 123   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestPartialInstallSteps)
 124   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestPartialUpdateSteps)
 125   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, PartialUninstallSteps)
 126   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReadonlyUpdateInstallSteps)
 127   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReadonlyUpdateUninstallSteps)
 128   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, DisablePkgSteps)
 129   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, EnablePkgSteps)
 130   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MigrateExtImgSteps)
 131   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, RecoverDBSteps)
 132
 133   int fail_at_;
 134 };
 135
 136 #ifdef OVERRIDE_STEPS_BLOCK
 137 #undef OVERRIDE_STEPS_BLOCK
 138 #endif
 139 #define OVERRIDE_STEPS_BLOCK(TYPE, STEPS)                                      \
 140   void STEPS() override {                                                      \
 141     TYPE::STEPS();                                                             \
 142     if (crash_at_ > -1)                                                        \
 143       AddStepAtIndex<StepCrash>(crash_at_, type_);                             \
 144     else if (step_name_.size())                                                \
 145       AddStepAfter<StepCrash>(step_name_, type_);                              \
 146     else                                                                       \
 147       AddStep<StepCrash>(type_);                                               \
 148   }                                                                            \
 149
 150 class CrashWgtInstaller : public wgt::WgtInstaller {
 151  public:
 152   explicit CrashWgtInstaller(common_installer::PkgMgrPtr pkgmgr, int crash_at,
 153       std::string step_name, CrashStepType type) :
 154           wgt::WgtInstaller(pkgmgr), crash_at_(crash_at),
 155           step_name_(step_name), type_(type) { }
 156
 157  private:
 158   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, InstallSteps)
 159   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, UpdateSteps)
 160   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, UninstallSteps)
 161   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReinstallSteps)
 162   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, DeltaSteps)
 163   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MoveSteps)
 164   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, RecoverySteps)
 165   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MountInstallSteps)
 166   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MountUpdateSteps)
 167   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestDirectInstallSteps)
 168   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestDirectUpdateSteps)
 169   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestPartialInstallSteps)
 170   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ManifestPartialUpdateSteps)
 171   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, PartialUninstallSteps)
 172   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReadonlyUpdateInstallSteps)
 173   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, ReadonlyUpdateUninstallSteps)
 174   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, DisablePkgSteps)
 175   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, EnablePkgSteps)
 176   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, MigrateExtImgSteps)
 177   OVERRIDE_STEPS_BLOCK(wgt::WgtInstaller, RecoverDBSteps)
 178
 179   int crash_at_;
 180   std::string step_name_;
 181   CrashStepType type_;
 182 };
 183
 184 class CrashHybridInstaller : public hybrid::HybridInstaller {
 185  public:
 186   explicit CrashHybridInstaller(common_installer::PkgMgrPtr pkgmgr,
 187       int crash_at, std::string step_name, CrashStepType type) :
 188           hybrid::HybridInstaller(pkgmgr), crash_at_(crash_at),
 189           step_name_(step_name), type_(type) { }
 190
 191  private:
 192   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, InstallSteps)
 193   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, UpdateSteps)
 194   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, UninstallSteps)
 195   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReinstallSteps)
 196   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, DeltaSteps)
 197   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MoveSteps)
 198   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, RecoverySteps)
 199   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MountInstallSteps)
 200   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MountUpdateSteps)
 201   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestDirectInstallSteps)
 202   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestDirectUpdateSteps)
 203   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestPartialInstallSteps)
 204   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ManifestPartialUpdateSteps)
 205   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, PartialUninstallSteps)
 206   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReadonlyUpdateInstallSteps)
 207   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, ReadonlyUpdateUninstallSteps)
 208   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, DisablePkgSteps)
 209   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, EnablePkgSteps)
 210   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, MigrateExtImgSteps)
 211   OVERRIDE_STEPS_BLOCK(hybrid::HybridInstaller, RecoverDBSteps)
 212
 213   int crash_at_;
 214   std::string step_name_;
 215   CrashStepType type_;
 216 };
 217
 218 #ifdef OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS
 219 #undef OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS
 220 #endif
 221 #define OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(TYPE, STEPS)               \
 222   void STEPS() override {                                                      \
 223     TYPE::STEPS();                                                             \
 224     RemoveStep("RunParserPlugin");                                             \
 225   }                                                                            \
 226
 227 class WgtInstallerWithoutPasrserPlugins : public wgt::WgtInstaller {
 228  public:
 229   explicit WgtInstallerWithoutPasrserPlugins(
 230       common_installer::PkgMgrPtr pkgmgr) : wgt::WgtInstaller(pkgmgr) { }
 231
 232  private:
 233   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 234       wgt::WgtInstaller, InstallSteps)
 235   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 236       wgt::WgtInstaller, UpdateSteps)
 237   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 238       wgt::WgtInstaller, UninstallSteps)
 239   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 240       wgt::WgtInstaller, ReinstallSteps)
 241   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 242       wgt::WgtInstaller, DeltaSteps)
 243   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 244       wgt::WgtInstaller, MoveSteps)
 245   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 246       wgt::WgtInstaller, MountInstallSteps)
 247   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 248       wgt::WgtInstaller, MountUpdateSteps)
 249   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 250       wgt::WgtInstaller, ManifestDirectInstallSteps)
 251   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 252       wgt::WgtInstaller, ManifestDirectUpdateSteps)
 253   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 254       wgt::WgtInstaller, ManifestPartialInstallSteps)
 255   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 256       wgt::WgtInstaller, ManifestPartialUpdateSteps)
 257   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 258       wgt::WgtInstaller, PartialUninstallSteps)
 259   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 260       wgt::WgtInstaller, ReadonlyUpdateInstallSteps)
 261   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 262       wgt::WgtInstaller, ReadonlyUpdateUninstallSteps)
 263   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 264       wgt::WgtInstaller, DisablePkgSteps)
 265   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 266       wgt::WgtInstaller, EnablePkgSteps)
 267   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 268       wgt::WgtInstaller, MigrateExtImgSteps)
 269   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 270       wgt::WgtInstaller, RecoverDBSteps)
 271   void RecoverySteps() override {
 272     wgt::WgtInstaller::RecoverySteps();
 273     RemoveStep("RecoverParserPlugin");
 274   }
 275 };
 276
 277 class HybridInstallerWithoutPasrserPlugins : public hybrid::HybridInstaller {
 278  public:
 279   explicit HybridInstallerWithoutPasrserPlugins(
 280       common_installer::PkgMgrPtr pkgmgr) : hybrid::HybridInstaller(pkgmgr) { }
 281
 282  private:
 283   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 284       hybrid::HybridInstaller, InstallSteps)
 285   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 286       hybrid::HybridInstaller, UpdateSteps)
 287   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 288       hybrid::HybridInstaller, UninstallSteps)
 289   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 290       hybrid::HybridInstaller, ReinstallSteps)
 291   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 292       hybrid::HybridInstaller, DeltaSteps)
 293   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 294       hybrid::HybridInstaller, MoveSteps)
 295   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 296       hybrid::HybridInstaller, MountInstallSteps)
 297   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 298       hybrid::HybridInstaller, MountUpdateSteps)
 299   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 300       hybrid::HybridInstaller, ManifestDirectInstallSteps)
 301   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 302       hybrid::HybridInstaller, ManifestDirectUpdateSteps)
 303   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 304       hybrid::HybridInstaller, ManifestPartialInstallSteps)
 305   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 306       hybrid::HybridInstaller, ManifestPartialUpdateSteps)
 307   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 308       hybrid::HybridInstaller, PartialUninstallSteps)
 309   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 310       hybrid::HybridInstaller, ReadonlyUpdateInstallSteps)
 311   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 312       hybrid::HybridInstaller, ReadonlyUpdateUninstallSteps)
 313   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 314       hybrid::HybridInstaller, DisablePkgSteps)
 315   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 316       hybrid::HybridInstaller, EnablePkgSteps)
 317   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 318       hybrid::HybridInstaller, MigrateExtImgSteps)
 319   OVERRIDE_STEPS_BLOCK_WITHOUT_PARSER_PLUGINS(
 320       hybrid::HybridInstaller, RecoverDBSteps)
 321   void RecoverySteps() override {
 322     hybrid::HybridInstaller::RecoverySteps();
 323     RemoveStep("RecoverParserPlugin");
 324   }
 325 };
 326
 327 }  // namespace smoke_test
 328
 329
 330 #endif  // TEST_SMOKE_TESTS_WGT_SMOKE_UTILS_H_