2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 * @file TestCases_PluginDAO.cpp
18 * @author Pawel Sikorski (p.sikorski@samsung.com)
20 * @brief This file contains tests for feature dao class.
24 #include <dpl/test/test_runner.h>
25 #include <dpl/foreach.h>
26 #include <dpl/exception.h>
27 #include <dpl/wrt-dao-rw/plugin_dao.h>
28 //#include <plugin_install/plugin_objects.h>
29 #include <dpl/wrt-dao-ro/wrt_db_types.h>
30 #include <dpl/log/wrt_log.h>
32 using namespace WrtDB;
34 #define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
35 { std::string tmp(in); \
36 RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]"); }
38 RUNNER_TEST_GROUP_INIT(DAO)
41 * Name: plugin_dao_test_register_plugins
42 * Description: registers new plugin and check if it was correctly registered
43 * Expected: plugin should be correctly registered
45 RUNNER_TEST(plugin_dao_test_register_plugins)
48 std::string libraryPath("np1 lib_path");
49 std::string libraryName("np1");
51 PluginMetafileData pluginData;
52 pluginData.m_libraryName = libraryName;
54 PluginHandle handle = PluginDAO::registerPlugin(pluginData, libraryPath);
55 PluginDAO::setPluginInstallationStatus(
58 INSTALLATION_COMPLETED);
59 RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
61 PluginDAO dao(handle);
63 tmp = dao.getLibraryPath(); //do for each
64 RUNNER_ASSERT_MSG(tmp == libraryPath, "Equals: " + tmp);
66 unsigned int size = PluginDAO::getPluginHandleList().size();
67 PluginDAO::unregisterPlugin(handle);
68 RUNNER_ASSERT(PluginDAO::getPluginHandleList().size() == size - 1);
72 std::string libraryName("np2");
74 PluginMetafileData pluginData;
75 pluginData.m_libraryName = libraryName;
77 PluginHandle handle = PluginDAO::registerPlugin(pluginData, "");
78 PluginDAO::setPluginInstallationStatus(
81 INSTALLATION_COMPLETED);
82 RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
84 PluginDAO dao(handle);
85 RUNNER_ASSERT(dao.getLibraryPath() == "");
87 unsigned int size = PluginDAO::getPluginHandleList().size();
88 PluginDAO::unregisterPlugin(handle);
89 RUNNER_ASSERT(PluginDAO::getPluginHandleList().size() == size - 1);
94 * Name: plugin_dao_test_register_plugin_implemented_object
95 * Description: registers new PluginImplementedObject
96 * and check if it was correctly registered
97 * Expected: plugin dao shoudld be upodated with PluginImplementedObject
99 RUNNER_TEST(plugin_dao_test_register_plugin_implemented_object)
102 std::string libraryPath("np3 lib_path");
103 std::string libraryName("np3");
105 PluginMetafileData pluginData;
106 pluginData.m_libraryName = libraryName;
108 PluginHandle handle =
109 PluginDAO::registerPlugin(pluginData, libraryPath);
110 RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
112 std::string object1("object1");
113 std::string object2("object2");
114 PluginDAO::registerPluginImplementedObject(object1, handle);
115 PluginDAO::registerPluginImplementedObject(object2, handle);
117 PluginHandle retHandle1 =
118 PluginDAO::getPluginHandleForImplementedObject(object1);
119 PluginHandle retHandle2 =
120 PluginDAO::getPluginHandleForImplementedObject(object1);
121 RUNNER_ASSERT(retHandle1 == handle);
122 RUNNER_ASSERT(retHandle2 == handle);
127 * Name: plugin_dao_test_get_root_plugin_handle_list
128 * Description: test of returning root plugin handle list
131 RUNNER_TEST(plugin_dao_test_get_root_plugin_handle_list)
133 PluginHandleList handles = PluginDAOReadOnly::getRootPluginHandleList();
134 RUNNER_ASSERT(handles.size() == 3);
138 if(*n == 2 || *n == 3 || *n == 5)
140 else RUNNER_ASSERT_MSG(false, "Wrong plugin handle");
143 RUNNER_ASSERT(count == 3);
147 * Name: plugin_dao_test_get_implemented_objects
148 * Description: test of returning plugin handle list
151 RUNNER_TEST(plugin_dao_test_get_implemented_objects)
153 ImplementedObjectsList handles = PluginDAOReadOnly::getImplementedObjects();
154 RUNNER_ASSERT(handles.size() == 6);
158 if(*n == "" || *n == "Plugin_3_Object_A" || *n == "Plugin_4_Object_A" ||
159 *n == "Plugin_4_Object_B" || *n == "Plugin_4_Object_C" || *n == "Plugin_5_Object_A")
161 else RUNNER_ASSERT_MSG(false, "Wrong implemented object");
164 RUNNER_ASSERT(count == 6);
168 * Name: plugin_dao_test_register_plugin_implemented_object
169 * Description: registers dependecies for plugins and checks if they were saved
170 * Expected: registered dependecies should be returned from database
172 RUNNER_TEST(plugin_dao_test_register_library_dependencies)
175 std::string libraryPath("np4 lib_path");
176 std::string libraryName("np4");
178 PluginMetafileData pluginData;
179 pluginData.m_libraryName = libraryName;
181 PluginHandle handle =
182 PluginDAO::registerPlugin(pluginData, libraryPath);
183 PluginDAO::setPluginInstallationStatus(
186 INSTALLATION_COMPLETED);
187 RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
189 PluginHandle depHandles[] = { 117, 119 };
191 PluginHandleSetPtr dependencies(new PluginHandleSet);
192 dependencies->insert(depHandles[0]);
193 dependencies->insert(depHandles[1]);
195 PluginDAO::registerPluginLibrariesDependencies(handle, dependencies);
197 PluginDAO dao(handle);
198 PluginHandleSetPtr retDependencies;
199 retDependencies = dao.getLibraryDependencies();
202 retDependencies->size() == sizeof(depHandles) /
203 sizeof(depHandles[0]));
205 retDependencies->find(depHandles[0]) != retDependencies->end());
207 retDependencies->find(depHandles[1]) != retDependencies->end());
212 * Name: plugin_dao_test_register_required_object
213 * Description: registers required plugin objects for plugins and checks if they
215 * Expected: registered required plugin objects should be returned from database
217 RUNNER_TEST(plugin_dao_test_register_required_object)
220 std::string libraryPath("np5 lib_path");
221 std::string libraryName("np5");
223 PluginMetafileData pluginData;
224 pluginData.m_libraryName = libraryName;
226 PluginHandle handle =
227 PluginDAO::registerPlugin(pluginData, libraryPath);
228 PluginDAO::setPluginInstallationStatus(
231 INSTALLATION_COMPLETED);
232 RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
234 const size_t numObjects = 2;
235 std::string objectReq[numObjects];
236 objectReq[0] = std::string("object1.req");
237 objectReq[1] = std::string("object2.req");
238 PluginDAO::registerPluginRequiredObject(objectReq[0], handle);
239 PluginDAO::registerPluginRequiredObject(objectReq[1], handle);
241 WrtDB::PluginObjectsDAO::ObjectsPtr objects =
242 PluginDAO::getRequiredObjectsForPluginHandle(handle);
244 RUNNER_ASSERT(objects->size() == numObjects
245 && objects->find(objectReq[0]) != objects->end()
246 && objects->find(objectReq[1]) != objects->end());
251 * Name: plugin_dao_test_is_library_installed
252 * Description: tests if plugin isntallation/registrartion works
253 * Expected: only registered plugins should be reported as installed
255 RUNNER_TEST(plugin_dao_test_is_library_installed)
259 std::list<const char *> preinstalled;
260 preinstalled.push_back("plugin1");
261 preinstalled.push_back("plugin2");
262 preinstalled.push_back("plugin3");
263 preinstalled.push_back("p4");
264 preinstalled.push_back("p5");
266 FOREACH(it, preinstalled)
267 RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled(*it),
268 std::string("Not found: ") + *it);
274 PluginDAO::isPluginInstalled("not_installed1") == false,
275 "Found not_installed1");
276 RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("p 4") == false,
278 RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("") == false,
280 RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("p33") == false,
282 RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("feature1") == false,
288 * Name: plugin_dao_test_get_plugin_handle_list
289 * Description: test of returning plugin handle list
290 * Expected: returned list should be no less than number of registered plugins
292 RUNNER_TEST(plugin_dao_test_get_plugin_handle_list)
294 PluginHandleList handles = PluginDAO::getPluginHandleList();
295 RUNNER_ASSERT(handles.size() >= 5);
299 * Name: plugin_dao_test_constructor_name
300 * Description: tests construction of plugin dao based on plugin name
301 * Expected: Instance of dao should be constructed only
302 * if there is given plugin in database
304 RUNNER_TEST(plugin_dao_test_constructor_name)
308 std::list<const char *> preinstalled;
309 preinstalled.push_back("plugin1");
310 preinstalled.push_back("plugin2");
311 preinstalled.push_back("plugin3");
312 preinstalled.push_back("p4");
313 preinstalled.push_back("p5");
315 FOREACH(it, preinstalled)
318 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), *it);
324 std::list<const char *> not_installed;
325 not_installed.push_back("plugin 1");
326 not_installed.push_back("");
327 not_installed.push_back("p 3");
329 FOREACH(it, not_installed)
334 RUNNER_ASSERT_MSG(false, "should not be found");
336 Catch(PluginDAO::Exception::PluginNotExist) {
344 * Name: plugin_dao_test_get_plugin_properties
345 * Description: tests reading plugin properties from database
346 * Expected: Data, inserted into database, should be accessible via dao
348 RUNNER_TEST(plugin_dao_test_get_plugin_properties)
352 RUNNER_ASSERT(dao.getPluginHandle() == 4);
353 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "p4");
354 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "path_to_p4");
359 RUNNER_ASSERT(dao.getPluginHandle() == 5);
360 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "p5");
361 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "path_to_p5");
366 RUNNER_ASSERT(dao.getPluginHandle() == 2);
367 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "plugin2");
368 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "path_to_plugin2");
373 RUNNER_ASSERT(dao.getPluginHandle() == 1);
374 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryName(), "plugin1");
375 RUNNER_ASSERT_WHAT_EQUALS(dao.getLibraryPath(), "");
380 * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_1
381 * Description: tests receiving from dao Implemented Objects
382 * Expected: returned object is size 0
384 RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_1)
387 const int handle = 1;
388 PluginDAOReadOnly dao(handle);
389 auto dbHandle = dao.getPluginHandle();
390 RUNNER_ASSERT(dbHandle == handle);
391 auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
393 RUNNER_ASSERT(objects.empty());
398 * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_2
399 * Description: tests receiving from dao Implemented Objects
400 * Expected: returned object is size as it was inserted
402 RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_2)
405 std::set< std::string > preinstalled = {
409 PluginDAOReadOnly dao(2);
410 auto dbHandle = dao.getPluginHandle();
411 auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
413 //WrtLogE("\n%u %u\n", objects.size(), preinstalled.size());
415 RUNNER_ASSERT(objects.size() == preinstalled.size());
417 FOREACH(dbObject, objects)
419 RUNNER_ASSERT(preinstalled.find(*dbObject) != preinstalled.end());
425 * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_3
426 * Description: tests receiving from dao Implemented Objects
427 * Expected: returned objects list has preinserted object
429 RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_3)
432 std::set< std::string > preinstalled = {
436 PluginDAOReadOnly dao(3);
437 auto dbHandle = dao.getPluginHandle();
438 auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
439 RUNNER_ASSERT(objects.size() == preinstalled.size());
441 FOREACH(dbObject, objects)
443 RUNNER_ASSERT(preinstalled.find(*dbObject) != preinstalled.end());
449 * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_4
450 * Description: tests receiving from dao Implemented Objects
451 * Expected: returned objects list has all preinserted objects
453 RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_4)
456 std::set< std::string > preinstalled = {
462 PluginDAOReadOnly dao(4);
463 auto dbHandle = dao.getPluginHandle();
464 auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
465 RUNNER_ASSERT(objects.size() == preinstalled.size());
467 FOREACH(dbObject, objects)
469 RUNNER_ASSERT(preinstalled.find(*dbObject) != preinstalled.end());
475 * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_5
476 * Description: tests receiving from dao Implemented Objects
477 * Expected: returned objects list do not have object that was not inserted
479 RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_5)
482 std::set< std::string > preinstalled = {
486 PluginDAOReadOnly dao(5);
487 auto dbHandle = dao.getPluginHandle();
488 auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
489 RUNNER_ASSERT(objects.size() == preinstalled.size());
491 FOREACH(dbObject, objects)
493 RUNNER_ASSERT(preinstalled.find(*dbObject) == preinstalled.end());
498 #undef RUNNER_ASSERT_WHAT_EQUALS