test/smoke_tests/plugins_smoketest.cc

   1 // Copyright (c) 2016 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 #include <gtest/gtest.h>
   6
   7 #include <memory>
   8 #include <iterator>
   9 #include <tuple>
  10
  11 #include "common/installer_context.h"
  12 #include "common/step/configuration/step_parse_manifest.h"
  13 #include "common/plugins/plugin_factory.h"
  14 #include "common/plugins/plugin_list_parser.h"
  15 #include "common/plugins/plugin_manager.h"
  16 #include "common/plugins/plugin_xml_parser.h"
  17 #include "smoke_tests/libs/test_assessor.h"
  18
  19 namespace ci = common_installer;
  20 namespace fs = std::filesystem;
  21
  22 namespace {
  23
  24 const char kPluginsTestFiles[] =
  25     "/usr/share/app-installers-ut/test_samples/plugins";
  26
  27 const fs::path kTestTagPlugin =
  28     fs::path(kPluginsTestFiles) / "libtest-tag-plugin.so";
  29 const fs::path kTestCategoryPlugin =
  30     fs::path(kPluginsTestFiles) / "libtest-category-plugin.so";
  31 const fs::path kTestMetadataPlugin =
  32     fs::path(kPluginsTestFiles) / "libtest-metadata-plugin.so";
  33 const fs::path kTestValidPluginsListDir =
  34     fs::path(kPluginsTestFiles) / "valid-parser-plugins";
  35 const fs::path kTestValidFailPluginsListDir =
  36     fs::path(kPluginsTestFiles) / "valid-fail-parser-plugins";
  37 const fs::path kTestInvalidPluginsListDir =
  38     fs::path(kPluginsTestFiles) / "invalid-parser-plugins";
  39
  40 void CheckCall(
  41     const ci::TestAssessor::ResultStore& store,
  42     const std::string& name,
  43     ci::Plugin::ActionType action) {
  44   auto iter_pre = store.find(
  45       std::make_tuple(name, action, ci::Plugin::ProcessType::Pre));
  46   auto iter_main = store.find(
  47       std::make_tuple(name, action, ci::Plugin::ProcessType::Main));
  48   auto iter_post = store.find(
  49       std::make_tuple(name, action, ci::Plugin::ProcessType::Post));
  50   ASSERT_NE(iter_pre, store.end());
  51   ASSERT_NE(iter_main, store.end());
  52   ASSERT_NE(iter_post, store.end());
  53
  54   // Error is not set
  55   ASSERT_TRUE(!iter_pre->second) << *iter_pre->second;
  56   ASSERT_TRUE(!iter_main->second) << *iter_main->second;
  57   ASSERT_TRUE(!iter_post->second) << *iter_post->second;
  58
  59   // Check order of calling
  60   auto ts_pre = std::distance(store.begin(), iter_pre);
  61   auto ts_main = std::distance(store.begin(), iter_main);
  62   auto ts_post = std::distance(store.begin(), iter_post);
  63   ASSERT_GT(ts_main, ts_pre);
  64   ASSERT_GT(ts_post, ts_main);
  65 }
  66
  67 void CheckCallMain(
  68     const ci::TestAssessor::ResultStore& store,
  69     const std::string& name,
  70     ci::Plugin::ActionType action) {
  71   auto iter_main = store.find(
  72       std::make_tuple(name, action, ci::Plugin::ProcessType::Main));
  73   ASSERT_NE(iter_main, store.end());
  74
  75   // Error is not set
  76   ASSERT_TRUE(!iter_main->second) << *iter_main->second;
  77 }
  78
  79 }  // namespace
  80
  81 namespace common_installer {
  82
  83 class PluginTest : public testing::Test {
  84 };
  85
  86 TEST_F(PluginTest, PluginsXmlParser_Valid) {
  87   fs::path manifest = fs::path(kPluginsTestFiles) / "tizen-manifest.xml";
  88   PluginsXmlParser parser(manifest);
  89   ASSERT_TRUE(parser.Parse());
  90   ASSERT_NE(parser.doc_ptr(), nullptr);
  91   auto tags = parser.tags_list();
  92   ASSERT_NE(std::find(tags.begin(), tags.end(), "author"), tags.end());
  93   ASSERT_NE(std::find(tags.begin(), tags.end(), "description"), tags.end());
  94   ASSERT_NE(std::find(tags.begin(), tags.end(), "ui-application"), tags.end());
  95   ASSERT_NE(std::find(tags.begin(), tags.end(), "test"), tags.end());
  96
  97   ASSERT_EQ(std::find(tags.begin(), tags.end(), "label"), tags.end());
  98   ASSERT_EQ(std::find(tags.begin(), tags.end(), "app-control"), tags.end());
  99   ASSERT_EQ(std::find(tags.begin(), tags.end(), "datacontrol"), tags.end());
 100   ASSERT_EQ(std::find(tags.begin(), tags.end(), "mime"), tags.end());
 101   ASSERT_EQ(std::find(tags.begin(), tags.end(), "operation"), tags.end());
 102   ASSERT_EQ(std::find(tags.begin(), tags.end(), "uri"), tags.end());
 103   ASSERT_EQ(std::find(tags.begin(), tags.end(), "key"), tags.end());
 104   ASSERT_EQ(std::find(tags.begin(), tags.end(), "name"), tags.end());
 105   ASSERT_EQ(std::find(tags.begin(), tags.end(), ""), tags.end());
 106 }
 107
 108 TEST_F(PluginTest, PluginsXmlParser_Invalid) {
 109   fs::path manifest = fs::path(kPluginsTestFiles) / "invalid_manifest.xml";
 110   PluginsXmlParser parser(manifest);
 111   ASSERT_FALSE(parser.Parse());
 112 }
 113
 114 TEST_F(PluginTest, PluginsListParser_Valid) {
 115   PluginsListParser parser(kTestValidPluginsListDir);
 116   ASSERT_TRUE(parser.Parse());
 117   auto list = parser.PluginInfoList();
 118   ASSERT_EQ(list.size(), 3);
 119   for (auto list_item : list) {
 120     if (list_item->type() == "tag") {
 121       ASSERT_EQ(list_item->name(), "test");
 122       ASSERT_EQ(list_item->path(), kTestTagPlugin.string());
 123     } else if (list_item->type() == "category") {
 124       ASSERT_EQ(list_item->name(), "http://tizen.org/category/test_category");
 125       ASSERT_EQ(list_item->path(), kTestCategoryPlugin.string());
 126     } else if (list_item->type() == "metadata") {
 127       ASSERT_EQ(list_item->name(),
 128           "http://developer.samsung.com/tizen/metadata/test_metadata");
 129       ASSERT_EQ(list_item->path(), kTestMetadataPlugin.string());
 130     }
 131   }
 132 }
 133
 134 TEST_F(PluginTest, PluginsListParser_Invalid) {
 135   PluginsListParser parser(kTestInvalidPluginsListDir);
 136   ASSERT_FALSE(parser.Parse());
 137 }
 138
 139 TEST_F(PluginTest, PluginFactory_CreatingPlugins) {
 140   PluginFactory factory;
 141   PluginInfo tag_info("tag", "test", kTestTagPlugin.string(), false);
 142   ASSERT_TRUE(!!factory.CreatePluginByPluginInfo(tag_info));
 143   PluginInfo category_info("category", "category",
 144                            kTestCategoryPlugin.string(), false);
 145   ASSERT_TRUE(!!factory.CreatePluginByPluginInfo(category_info));
 146   PluginInfo metadata_info("metadata", "metadata",
 147                            kTestMetadataPlugin.string(), false);
 148   ASSERT_TRUE(!!factory.CreatePluginByPluginInfo(metadata_info));
 149   PluginInfo tag_info2("tag", "test", kTestTagPlugin.string(), true);
 150   ASSERT_TRUE(!!factory.CreatePluginByPluginInfo(tag_info2));
 151   PluginInfo category_info2("category", "category",
 152                             kTestCategoryPlugin.string(), true);
 153   ASSERT_TRUE(!!factory.CreatePluginByPluginInfo(category_info2));
 154   PluginInfo metadata_info2("metadata", "metadata",
 155                             kTestMetadataPlugin.string(), true);
 156   ASSERT_TRUE(!!factory.CreatePluginByPluginInfo(metadata_info2));
 157   PluginInfo missing_info("tag", "test",
 158                           "/usr/lib/libmynonexistingplugin.so", false);
 159   ASSERT_FALSE(!!factory.CreatePluginByPluginInfo(missing_info));
 160   PluginInfo new_info("newtype", "test", kTestTagPlugin.string(), false);
 161   ASSERT_FALSE(!!factory.CreatePluginByPluginInfo(new_info));
 162 }
 163
 164 #define CALLING_PLUGIN_FOR_ACTION_TEST(NAME, ACTION)                           \
 165     TEST_F(PluginTest, PluginManager_CallingPlugins ## NAME) {                 \
 166       TestAssessor::Instance().ClearResults();                                 \
 167                                                                                \
 168       fs::path manifest = fs::path(kPluginsTestFiles) / "tizen-manifest.xml";  \
 169       fs::path list = kTestValidPluginsListDir;                                \
 170                                                                                \
 171       InstallerContext context;                                                \
 172       context.unpacked_dir_path.set(manifest.parent_path());                   \
 173       configuration::StepParseManifest step(&context,                          \
 174           configuration::StepParseManifest::ManifestLocation::PACKAGE,         \
 175           configuration::StepParseManifest::StoreLocation::NORMAL);            \
 176       ASSERT_EQ(step.process(), Step::Status::OK);                             \
 177       PluginManager manager(manifest, list, context.pkgid.get(),               \
 178           context.manifest_data.get(), getuid());                              \
 179       ASSERT_TRUE(manager.LoadPlugins(ACTION));                                \
 180       manager.RunPlugins(ACTION);                                              \
 181       auto result = TestAssessor::Instance().GetResults();                     \
 182       ASSERT_EQ(result.size(), 5);                                             \
 183       CheckCall(result, kTagPluginName, ACTION);                               \
 184       CheckCallMain(result, kMetadataPluginName, ACTION);                      \
 185       CheckCallMain(result, kCategoryPluginName, ACTION);                      \
 186     }
 187
 188 CALLING_PLUGIN_FOR_ACTION_TEST(Install, Plugin::ActionType::Install)
 189 CALLING_PLUGIN_FOR_ACTION_TEST(Upgrade, Plugin::ActionType::Upgrade)
 190 CALLING_PLUGIN_FOR_ACTION_TEST(Uninstall, Plugin::ActionType::Uninstall)
 191
 192 #define CALLING_PLUGIN_FOR_FAIL_ACTION_TEST(NAME, ACTION)                      \
 193     TEST_F(PluginTest, PluginManager_CallingFailPlugins ## NAME) {             \
 194       std::string kind_of_plugins[3] = {"category", "metadata", "tag"};        \
 195       for (auto name : kind_of_plugins) {                                      \
 196         std::string manifest_dir = name + "-manifest";                         \
 197         fs::path manifest =                                                    \
 198             fs::path(kPluginsTestFiles) / manifest_dir / "tizen-manifest.xml"; \
 199         fs::path list = kTestValidFailPluginsListDir;                          \
 200                                                                                \
 201         InstallerContext context;                                              \
 202         context.unpacked_dir_path.set(manifest.parent_path());                 \
 203         configuration::StepParseManifest step(&context,                        \
 204             configuration::StepParseManifest::ManifestLocation::PACKAGE,       \
 205             configuration::StepParseManifest::StoreLocation::NORMAL);          \
 206         ASSERT_EQ(step.process(), Step::Status::OK);                           \
 207         PluginManager manager(manifest, list, context.pkgid.get(),             \
 208             context.manifest_data.get(), getuid());                            \
 209         ASSERT_TRUE(manager.LoadPlugins(ACTION));                              \
 210         ASSERT_FALSE(manager.RunPlugins(ACTION));                              \
 211       }                                                                        \
 212     }
 213
 214 CALLING_PLUGIN_FOR_FAIL_ACTION_TEST(Install, Plugin::ActionType::Install)
 215 CALLING_PLUGIN_FOR_FAIL_ACTION_TEST(Upgrade, Plugin::ActionType::Upgrade)
 216 CALLING_PLUGIN_FOR_FAIL_ACTION_TEST(Uninstall, Plugin::ActionType::Uninstall)
 217
 218 }  // namespace common_installer
 219
 220 int main(int argc, char** argv) {
 221   int ret = -1;
 222   try {
 223     testing::InitGoogleTest(&argc, argv);
 224   } catch(...) {
 225     std::cout << "Exception occurred" << std::endl;
 226   }
 227
 228   try {
 229     ret = RUN_ALL_TESTS();
 230   } catch (const ::testing::internal::GoogleTestFailureException& e) {
 231     ret = -1;
 232     std::cout << "GoogleTestFailureException was thrown:" << e.what()
 233               << std::endl;
 234   }
 235
 236   return ret;
 237 }