src/test/DBusDaemonProxyTest.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4 #include <CommonAPI/DBus/DBusConnection.h>
   5 #include <CommonAPI/DBus/DBusDaemonProxy.h>
   6
   7 #include <gtest/gtest.h>
   8
   9 #include <future>
  10 #include <tuple>
  11
  12 namespace {
  13
  14 void dispatch(std::shared_ptr<CommonAPI::DBus::DBusConnection> dbusConnection) {
  15     while (dbusConnection->readWriteDispatch(10)) {}
  16 }
  17
  18 class DBusDaemonProxyTest: public ::testing::Test {
  19  protected:
  20
  21         std::thread* thread;
  22
  23         virtual void SetUp() {
  24                 dbusConnection_ = CommonAPI::DBus::DBusConnection::getSessionBus();
  25                 ASSERT_TRUE(dbusConnection_->connect());
  26                 thread = new std::thread(dispatch, dbusConnection_);
  27                 thread->detach();
  28                 //readWriteDispatchCount_ = 0;
  29         }
  30
  31         virtual void TearDown() {
  32                 delete thread;
  33                 if (dbusConnection_ && dbusConnection_->isConnected()) {
  34                         //dbusConnection_->disconnect();
  35                 }
  36         }
  37
  38         /*bool doReadWriteDispatch(int timeoutMilliseconds = 100) {
  39                 readWriteDispatchCount_++;
  40                 return dbusConnection_->readWriteDispatch(timeoutMilliseconds);
  41         }*/
  42
  43         std::shared_ptr<CommonAPI::DBus::DBusConnection> dbusConnection_;
  44         //size_t readWriteDispatchCount_;
  45 };
  46
  47 TEST_F(DBusDaemonProxyTest, ListNames) {
  48         std::vector<std::string> busNames;
  49         CommonAPI::CallStatus callStatus;
  50
  51         dbusConnection_->getDBusDaemonProxy()->listNames(callStatus, busNames);
  52         ASSERT_EQ(callStatus, CommonAPI::CallStatus::SUCCESS);
  53
  54         ASSERT_GT(busNames.size(), 0);
  55         for (const std::string& busName : busNames) {
  56                 ASSERT_FALSE(busName.empty());
  57                 ASSERT_GT(busName.length(), 1);
  58         }
  59 }
  60
  61 TEST_F(DBusDaemonProxyTest, ListNamesAsync) {
  62         std::promise<std::tuple<CommonAPI::CallStatus, std::vector<std::string>>> promise;
  63         auto future = promise.get_future();
  64
  65         auto callStatusFuture = dbusConnection_->getDBusDaemonProxy()->listNamesAsync(
  66                         [&](const CommonAPI::CallStatus& callStatus, std::vector<std::string> busNames) {
  67                 promise.set_value(std::tuple<CommonAPI::CallStatus, std::vector<std::string>>(callStatus, std::move(busNames)));
  68         });
  69
  70         ASSERT_EQ(future.wait_for(std::chrono::milliseconds(200)), std::future_status::ready);
  71
  72         ASSERT_EQ(callStatusFuture.get(), CommonAPI::CallStatus::SUCCESS);
  73
  74         auto futureResult = future.get();
  75         const CommonAPI::CallStatus& callStatus = std::get<0>(futureResult);
  76         const std::vector<std::string>& busNames = std::get<1>(futureResult);
  77
  78         ASSERT_EQ(callStatus, CommonAPI::CallStatus::SUCCESS);
  79
  80         ASSERT_GT(busNames.size(), 0);
  81         for (const std::string& busName : busNames) {
  82                 ASSERT_FALSE(busName.empty());
  83                 ASSERT_GT(busName.length(), 1);
  84         }
  85 }
  86
  87 TEST_F(DBusDaemonProxyTest, NameHasOwner) {
  88         bool nameHasOwner;
  89         CommonAPI::CallStatus callStatus;
  90
  91         dbusConnection_->getDBusDaemonProxy()->nameHasOwner("org.freedesktop.DBus", callStatus, nameHasOwner);
  92         ASSERT_EQ(callStatus, CommonAPI::CallStatus::SUCCESS);
  93         ASSERT_TRUE(nameHasOwner);
  94
  95         dbusConnection_->getDBusDaemonProxy()->nameHasOwner("org.freedesktop.DBus.InvalidName.XXYYZZ", callStatus, nameHasOwner);
  96         ASSERT_EQ(callStatus, CommonAPI::CallStatus::SUCCESS);
  97         ASSERT_FALSE(nameHasOwner);
  98 }
  99
 100 TEST_F(DBusDaemonProxyTest, NameHasOwnerAsync) {
 101         std::promise<std::tuple<CommonAPI::CallStatus, bool>> promise;
 102         auto future = promise.get_future();
 103
 104         auto callStatusFuture = dbusConnection_->getDBusDaemonProxy()->nameHasOwnerAsync(
 105                         "org.freedesktop.DBus",
 106                         [&](const CommonAPI::CallStatus& callStatus, bool nameHasOwner) {
 107                 promise.set_value(std::tuple<CommonAPI::CallStatus, bool>(callStatus, std::move(nameHasOwner)));
 108         });
 109
 110         //while (readWriteDispatchCount_ < 5) {
 111         //      ASSERT_TRUE(doReadWriteDispatch());
 112                 //if (callStatusFuture.wait_for(std::chrono::milliseconds(100)) == std::future_status::ready)
 113                 //      break;
 114         //}
 115         //ASSERT_NE(readWriteDispatchCount_, 5);
 116         ASSERT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready);
 117
 118         ASSERT_EQ(callStatusFuture.get(), CommonAPI::CallStatus::SUCCESS);
 119
 120         auto futureResult = future.get();
 121         const CommonAPI::CallStatus& callStatus = std::get<0>(futureResult);
 122         const bool& nameHasOwner = std::get<1>(futureResult);
 123
 124         ASSERT_EQ(callStatus, CommonAPI::CallStatus::SUCCESS);
 125         ASSERT_TRUE(nameHasOwner);
 126 }
 127
 128 TEST_F(DBusDaemonProxyTest, NameOwnerChangedEvent) {
 129         std::promise<bool> promise;
 130         auto future = promise.get_future();
 131
 132         dbusConnection_->getDBusDaemonProxy()->getNameOwnerChangedEvent().subscribe(
 133                         [&](const std::string& name, const std::string& oldOwner, const std::string& newOwner) {
 134             static bool promiseIsSet = false;
 135             if(!promiseIsSet) {
 136                 promiseIsSet = true;
 137                 promise.set_value(!name.empty() && (!oldOwner.empty() || !newOwner.empty()));
 138             }
 139         });
 140
 141         // Trigger NameOwnerChanged using a new DBusConnection
 142         ASSERT_TRUE(CommonAPI::DBus::DBusConnection::getSessionBus()->connect());
 143
 144         //while (readWriteDispatchCount_ < 5) {
 145         //      ASSERT_TRUE(doReadWriteDispatch());
 146                 //if (future.wait_for(std::chrono::milliseconds(100)) == std::future_status::ready)
 147                 //      break;
 148         //}
 149
 150         //ASSERT_NE(readWriteDispatchCount_, 5);
 151         ASSERT_TRUE(future.get());
 152 }
 153
 154 } // namespace
 155
 156 int main(int argc, char** argv) {
 157         ::testing::InitGoogleTest(&argc, argv);
 158         return RUN_ALL_TESTS();
 159 }