CommonAPI-DBus/src/test/DBusConnectionTest.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
   5 #include <common-api-dbus/dbus-connection.h>
   6 #include <common-api-dbus/dbus-output-message-stream.h>
   7
   8 #include <gtest/gtest.h>
   9
  10 #include <cstring>
  11
  12
  13 #define ASSERT_DBUSMESSAGE_EQ(_dbusMessage1, _dbusMessage2) \
  14                         ASSERT_FALSE(_dbusMessage1.getSignatureString() == NULL); \
  15                         ASSERT_FALSE(_dbusMessage2.getSignatureString() == NULL); \
  16                         ASSERT_STREQ(_dbusMessage1.getSignatureString(), _dbusMessage2.getSignatureString()); \
  17                         ASSERT_EQ(_dbusMessage1.getBodyLength(), _dbusMessage2.getBodyLength()); \
  18                         ASSERT_FALSE(_dbusMessage1.getBodyData() == NULL); \
  19                         ASSERT_FALSE(_dbusMessage2.getBodyData() == NULL); \
  20                         ASSERT_EQ(memcmp(_dbusMessage1.getBodyData(), _dbusMessage2.getBodyData(), _dbusMessage1.getBodyLength()), 0)
  21
  22
  23 namespace {
  24
  25 class DBusConnectionTest: public ::testing::Test {
  26  public:
  27         void onConnectionStatusEvent(const common::api::AvailabilityStatus& newConnectionStatus) {
  28                 connectionStatusEventCount_++;
  29                 connectionStatus_ = newConnectionStatus;
  30         }
  31
  32         bool onInterfaceHandlerDBusMessageReply(const common::api::dbus::DBusMessage& dbusMessage,
  33                                                                                         const std::shared_ptr<common::api::dbus::DBusConnection>& dbusConnection) {
  34                 interfaceHandlerDBusMessageCount_++;
  35                 interfaceHandlerDBusMessage_ = dbusMessage;
  36                 interfaceHandlerDBusMessageReply_ = dbusMessage.createMethodReturn("si");
  37
  38                 common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(interfaceHandlerDBusMessageReply_);
  39                 dbusOutputMessageStream << "This is a default message reply!" << interfaceHandlerDBusMessageCount_;
  40                 dbusOutputMessageStream.flush();
  41
  42                 dbusConnection->sendDBusMessage(interfaceHandlerDBusMessageReply_);
  43
  44                 return true;
  45         }
  46
  47         void onDBusMessageHandler(const common::api::dbus::DBusMessage& dbusMessage) {
  48                 dbusMessageHandlerCount_++;
  49                 dbusMessageHandlerDBusMessage_ = dbusMessage;
  50         }
  51
  52  protected:
  53         virtual void SetUp() {
  54                 dbusConnection_ = common::api::dbus::DBusConnection::getSessionBus();
  55                 connectionStatusEventCount_ = 0;
  56                 interfaceHandlerDBusMessageCount_ = 0;
  57                 dbusMessageHandlerCount_ = 0;
  58         }
  59
  60         virtual void TearDown() {
  61                 if (dbusConnection_ && dbusConnection_->isConnected())
  62                         dbusConnection_->disconnect();
  63
  64                 // reset DBusMessage
  65                 interfaceHandlerDBusMessage_ = common::api::dbus::DBusMessage();
  66                 interfaceHandlerDBusMessageReply_ = common::api::dbus::DBusMessage();
  67
  68                 dbusMessageHandlerDBusMessage_ = common::api::dbus::DBusMessage();
  69         }
  70
  71
  72         std::shared_ptr<common::api::dbus::DBusConnection> dbusConnection_;
  73
  74         uint32_t connectionStatusEventCount_;
  75         common::api::AvailabilityStatus connectionStatus_;
  76
  77         uint32_t interfaceHandlerDBusMessageCount_;
  78         common::api::dbus::DBusMessage interfaceHandlerDBusMessage_;
  79         common::api::dbus::DBusMessage interfaceHandlerDBusMessageReply_;
  80
  81         uint32_t dbusMessageHandlerCount_;
  82         common::api::dbus::DBusMessage dbusMessageHandlerDBusMessage_;
  83 };
  84
  85
  86 TEST_F(DBusConnectionTest, IsInitiallyDisconnected) {
  87         ASSERT_FALSE(dbusConnection_->isConnected());
  88 }
  89
  90 TEST_F(DBusConnectionTest, ConnectAndDisconnectWork) {
  91         ASSERT_TRUE(dbusConnection_->connect());
  92         ASSERT_TRUE(dbusConnection_->isConnected());
  93
  94         dbusConnection_->disconnect();
  95         ASSERT_FALSE(dbusConnection_->isConnected());
  96 }
  97
  98 TEST_F(DBusConnectionTest, ConnectionStatusEventWorks) {
  99         ASSERT_EQ(connectionStatusEventCount_, 0);
 100
 101         auto connectionStatusSubscription = dbusConnection_->getConnectionStatusEvent().subscribe(std::bind(
 102                         &DBusConnectionTest::onConnectionStatusEvent,
 103                         this,
 104                         std::placeholders::_1));
 105
 106         ASSERT_FALSE(dbusConnection_->isConnected());
 107         ASSERT_EQ(connectionStatusEventCount_, 0);
 108
 109         uint32_t expectedEventCount = 0;
 110         while (expectedEventCount < 10) {
 111                 ASSERT_TRUE(dbusConnection_->connect());
 112                 ASSERT_TRUE(dbusConnection_->isConnected());
 113                 ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount);
 114                 ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::AVAILABLE);
 115
 116                 dbusConnection_->disconnect();
 117                 ASSERT_FALSE(dbusConnection_->isConnected());
 118                 ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount);
 119                 ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::NOT_AVAILABLE);
 120         }
 121
 122         dbusConnection_->getConnectionStatusEvent().unsubscribe(connectionStatusSubscription);
 123         ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
 124
 125         ASSERT_TRUE(dbusConnection_->connect());
 126         ASSERT_TRUE(dbusConnection_->isConnected());
 127         ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
 128
 129         dbusConnection_->disconnect();
 130         ASSERT_FALSE(dbusConnection_->isConnected());
 131         ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
 132 }
 133
 134 TEST_F(DBusConnectionTest, SendingAsyncDBusMessagesWorks) {
 135         const char* busName = "common.api.dbus.test.TestInterfaceHandler";
 136         const char* objectPath = "/common/api/dbus/test/TestObject";
 137         const char* interfaceName = "common.api.dbus.test.TestInterface";
 138         const char* methodName = "TestMethod";
 139
 140         auto interfaceHandlerDBusConnection = common::api::dbus::DBusConnection::getSessionBus();
 141
 142         ASSERT_TRUE(interfaceHandlerDBusConnection->connect());
 143         ASSERT_TRUE(interfaceHandlerDBusConnection->requestServiceNameAndBlock(busName));
 144
 145         auto interfaceHandlerToken = interfaceHandlerDBusConnection->registerInterfaceHandler(
 146                         objectPath,
 147                         interfaceName,
 148                         std::bind(&DBusConnectionTest::onInterfaceHandlerDBusMessageReply,
 149                                           this,
 150                                           std::placeholders::_1,
 151                                           interfaceHandlerDBusConnection));
 152
 153
 154         ASSERT_TRUE(dbusConnection_->connect());
 155
 156         for (uint32_t expectedDBusMessageCount = 1; expectedDBusMessageCount <= 10; expectedDBusMessageCount++) {
 157                 auto dbusMessageCall = common::api::dbus::DBusMessage::createMethodCall(
 158                                 busName,
 159                                 objectPath,
 160                                 interfaceName,
 161                                 methodName,
 162                                 "si");
 163                 ASSERT_TRUE(dbusMessageCall);
 164
 165                 common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(dbusMessageCall);
 166                 dbusOutputMessageStream << "This is a test async call"
 167                                                                 << expectedDBusMessageCount;
 168                 dbusOutputMessageStream.flush();
 169
 170                 dbusConnection_->sendDBusMessageWithReplyAsync(
 171                                 dbusMessageCall,
 172                                 std::bind(&DBusConnectionTest::onDBusMessageHandler, this, std::placeholders::_1));
 173
 174                 for (int i = 0; i < 10 && interfaceHandlerDBusMessageCount_ < expectedDBusMessageCount; i++)
 175                         interfaceHandlerDBusConnection->readWriteDispatch(100);
 176
 177                 ASSERT_EQ(interfaceHandlerDBusMessageCount_, expectedDBusMessageCount);
 178                 ASSERT_DBUSMESSAGE_EQ(dbusMessageCall, interfaceHandlerDBusMessage_);
 179
 180                 for (int i = 0; i < 10 && dbusMessageHandlerCount_ < expectedDBusMessageCount; i++)
 181                         dbusConnection_->readWriteDispatch(100);
 182
 183                 ASSERT_EQ(dbusMessageHandlerCount_, expectedDBusMessageCount);
 184                 ASSERT_DBUSMESSAGE_EQ(dbusMessageHandlerDBusMessage_, interfaceHandlerDBusMessageReply_);
 185         }
 186
 187         dbusConnection_->disconnect();
 188
 189
 190         interfaceHandlerDBusConnection->unregisterInterfaceHandler(interfaceHandlerToken);
 191
 192         ASSERT_TRUE(interfaceHandlerDBusConnection->releaseServiceName(busName));
 193         interfaceHandlerDBusConnection->disconnect();
 194 }
 195
 196 } // namespace