utest/test_uninstallhandler.cpp

   1 /**
   2  * Samsung Ukraine R&D Center (SRK under a contract between)
   3  * LLC "Samsung Electronics Co", Ltd (Seoul, Republic of Korea)
   4  * Copyright (C) 2018 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License
  17  */
  18 #include <gmock/gmock.h>
  19 #include <gtest/gtest.h>
  20 #include <memory>
  21 #include <functional>
  22 #include <thread>
  23 #include <jsoncpp/json/reader.h>
  24 #include <jsoncpp/json/writer.h>
  25 #include "dbuslistener.h"
  26 #include "dbushandler.h"
  27 #include "uninstallhandler.h"
  28 #include "settings.h"
  29 #include "dbus_mock.h"
  30 #include "device_policy_manager_mock.h"
  31
  32 using ::testing::_;
  33 using ::testing::Eq;
  34 using ::testing::StrEq;
  35 using ::testing::Return;
  36 using ::testing::DoAll;
  37 using ::testing::Invoke;
  38
  39 namespace
  40 {
  41 const std::string APP_ID = "org.example.photostealware";
  42 const char* TEST_SIGNAL = "{\"type\":\"uninstall_application\",\"data\":{\"app_id\":\"org.example.photostealware\"}}";
  43 const char* TEST_SIGNAL_EMPTY_DATA = "{\"type\":\"uninstall_application\"}";
  44 const char* TEST_SIGNAL_INCORRECT_APP_ID = "{\"type\":\"uninstall_application\",\"data\":{\"app_id\":0}}";
  45 }
  46
  47 /**
  48  * @brief Test signal when device is locked
  49  */
  50 TEST(TestUninstallHandler, test_process_locked)
  51 {
  52     DBusConnectionMock conn;
  53     DBusMessageMock msg;
  54     DBusMessageIterMock iter;
  55     EXPECT_CALL(conn, dbus_bus_get(_, _)).WillOnce(Return(&conn));
  56     EXPECT_CALL(conn, dbus_bus_request_name(_, _, _)).WillOnce(Return(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER));
  57     EXPECT_CALL(conn, dbus_bus_add_match(_, _)).Times(1);
  58     EXPECT_CALL(conn, dbus_connection_flush()).Times(1);
  59     EXPECT_CALL(conn, dbus_connection_read_write(_)).WillRepeatedly(Return(true));
  60     EXPECT_CALL(conn, dbus_connection_pop_message()).WillOnce(Return(&msg)).WillRepeatedly(Return(nullptr));
  61     EXPECT_CALL(conn, dbus_connection_unref()).Times(1);
  62     EXPECT_CALL(msg, dbus_message_is_signal(_, _)).WillOnce(Return(true));
  63     EXPECT_CALL(msg, dbus_message_iter_init(_)).WillOnce(Return(true));
  64     EXPECT_CALL(msg, dbus_message_unref()).Times(1);
  65     EXPECT_CALL(iter, dbus_message_iter_get_arg_type()).WillOnce(Return(DBUS_TYPE_STRING));
  66     EXPECT_CALL(iter, dbus_message_iter_get_basic(_)).WillOnce(Invoke([](void* value) {*(char**)value = strdup(TEST_SIGNAL);}));
  67
  68     bool allowed = true;
  69     dbus::DBusListener listener{[&allowed](){return allowed;}};
  70     dbus::UninstallHandler handler{listener};
  71
  72     agent::Settings::instance().setLock(true);
  73
  74     std::thread t(&dbus::DBusListener::loop, &listener);
  75     std::this_thread::sleep_for(std::chrono::milliseconds(100));
  76     allowed = false;
  77     t.join();
  78
  79     agent::Settings::instance().setLock(false);
  80 }
  81
  82 /**
  83  * @brief Test signal with empty data
  84  */
  85 TEST(TestUninstallHandler, test_process_empty_data)
  86 {
  87     DBusConnectionMock conn;
  88     DBusMessageMock msg;
  89     DBusMessageIterMock iter;
  90     EXPECT_CALL(conn, dbus_bus_get(_, _)).WillOnce(Return(&conn));
  91     EXPECT_CALL(conn, dbus_bus_request_name(_, _, _)).WillOnce(Return(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER));
  92     EXPECT_CALL(conn, dbus_bus_add_match(_, _)).Times(1);
  93     EXPECT_CALL(conn, dbus_connection_flush()).Times(1);
  94     EXPECT_CALL(conn, dbus_connection_read_write(_)).WillRepeatedly(Return(true));
  95     EXPECT_CALL(conn, dbus_connection_pop_message()).WillOnce(Return(&msg)).WillRepeatedly(Return(nullptr));
  96     EXPECT_CALL(conn, dbus_connection_unref()).Times(1);
  97     EXPECT_CALL(msg, dbus_message_is_signal(_, _)).WillOnce(Return(true));
  98     EXPECT_CALL(msg, dbus_message_iter_init(_)).WillOnce(Return(true));
  99     EXPECT_CALL(msg, dbus_message_unref()).Times(1);
 100     EXPECT_CALL(iter, dbus_message_iter_get_arg_type()).WillOnce(Return(DBUS_TYPE_STRING));
 101     EXPECT_CALL(iter, dbus_message_iter_get_basic(_)).WillOnce(Invoke([](void* value) {*(char**)value = strdup(TEST_SIGNAL_EMPTY_DATA);}));
 102
 103     bool allowed = true;
 104     dbus::DBusListener listener{[&allowed](){return allowed;}};
 105     dbus::UninstallHandler handler{listener};
 106
 107     std::thread t(&dbus::DBusListener::loop, &listener);
 108     std::this_thread::sleep_for(std::chrono::milliseconds(100));
 109     allowed = false;
 110     t.join();
 111 }
 112
 113 /**
 114  * @brief Test signal with invalid application id
 115  */
 116 TEST(TestUninstallHandler, test_process_invalid_app_id)
 117 {
 118     DBusConnectionMock conn;
 119     DBusMessageMock msg;
 120     DBusMessageIterMock iter;
 121     EXPECT_CALL(conn, dbus_bus_get(_, _)).WillOnce(Return(&conn));
 122     EXPECT_CALL(conn, dbus_bus_request_name(_, _, _)).WillOnce(Return(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER));
 123     EXPECT_CALL(conn, dbus_bus_add_match(_, _)).Times(1);
 124     EXPECT_CALL(conn, dbus_connection_flush()).Times(1);
 125     EXPECT_CALL(conn, dbus_connection_read_write(_)).WillRepeatedly(Return(true));
 126     EXPECT_CALL(conn, dbus_connection_pop_message()).WillOnce(Return(&msg)).WillRepeatedly(Return(nullptr));
 127     EXPECT_CALL(conn, dbus_connection_unref()).Times(1);
 128     EXPECT_CALL(msg, dbus_message_is_signal(_, _)).WillOnce(Return(true));
 129     EXPECT_CALL(msg, dbus_message_iter_init(_)).WillOnce(Return(true));
 130     EXPECT_CALL(msg, dbus_message_unref()).Times(1);
 131     EXPECT_CALL(iter, dbus_message_iter_get_arg_type()).WillOnce(Return(DBUS_TYPE_STRING));
 132     EXPECT_CALL(iter, dbus_message_iter_get_basic(_)).WillOnce(Invoke([](void* value) {*(char**)value = strdup(TEST_SIGNAL_INCORRECT_APP_ID);}));
 133
 134     bool allowed = true;
 135     dbus::DBusListener listener{[&allowed](){return allowed;}};
 136     dbus::UninstallHandler handler{listener};
 137
 138     std::thread t(&dbus::DBusListener::loop, &listener);
 139     std::this_thread::sleep_for(std::chrono::milliseconds(100));
 140     allowed = false;
 141     t.join();
 142 }
 143
 144 /**
 145  * @brief Test signal for normal sequence
 146  */
 147 TEST(TestUninstallHandler, test_process)
 148 {
 149     DBusConnectionMock conn;
 150     DBusMessageMock msg;
 151     DBusMessageIterMock iter;
 152     DPMMock dpm;
 153     EXPECT_CALL(conn, dbus_bus_get(_, _)).WillOnce(Return(&conn));
 154     EXPECT_CALL(conn, dbus_bus_request_name(_, _, _)).WillOnce(Return(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER));
 155     EXPECT_CALL(conn, dbus_bus_add_match(_, _)).Times(1);
 156     EXPECT_CALL(conn, dbus_connection_flush()).Times(1);
 157     EXPECT_CALL(conn, dbus_connection_read_write(_)).WillRepeatedly(Return(true));
 158     EXPECT_CALL(conn, dbus_connection_pop_message()).WillOnce(Return(&msg)).WillRepeatedly(Return(nullptr));
 159     EXPECT_CALL(conn, dbus_connection_unref()).Times(1);
 160     EXPECT_CALL(msg, dbus_message_is_signal(_, _)).WillOnce(Return(true));
 161     EXPECT_CALL(msg, dbus_message_iter_init(_)).WillOnce(Return(true));
 162     EXPECT_CALL(msg, dbus_message_unref()).Times(1);
 163     EXPECT_CALL(iter, dbus_message_iter_get_arg_type()).WillOnce(Return(DBUS_TYPE_STRING));
 164     EXPECT_CALL(iter, dbus_message_iter_get_basic(_)).WillOnce(Invoke([](void* value) {*(char**)value = strdup(TEST_SIGNAL);}));
 165     EXPECT_CALL(dpm, dpm_manager_create()).WillOnce(Return(&dpm));
 166     EXPECT_CALL(dpm, dpm_application_uninstall_package(StrEq(APP_ID))).WillOnce(Return(0));
 167     EXPECT_CALL(dpm, dpm_manager_destroy()).Times(1);
 168
 169     bool allowed = true;
 170     dbus::DBusListener listener{[&allowed](){return allowed;}};
 171     dbus::UninstallHandler handler{listener};
 172
 173     std::thread t(&dbus::DBusListener::loop, &listener);
 174     std::this_thread::sleep_for(std::chrono::milliseconds(100));
 175     allowed = false;
 176     t.join();
 177 }