Updated DBusConnectionTest to current version of CommonAPI, integrated

it into current test suite

3 files changed, 234 insertions, 145 deletions

diff --git a/.gitignore b/.gitignore
index 29281ae..36c6418 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,4 @@
 /DBusAddressTranslatorTest
 /.pydevproject
 /DBusServiceRegistryTest
+/DBusConnectionTest
diff --git a/Makefile.am b/Makefile.am
index df0572d..9d35dd9 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -100,6 +100,7 @@ TestInterfaceSources = \
 		src/test/fakeLegacyService/fake/legacy/service/LegacyInterfaceDBusProxy.cpp
 
 check_PROGRAMS = \
+		DBusConnectionTest \
 		DBusServiceRegistryTest \
 		DBusProxyTest \
 		DBusAddressTranslatorTest \
@@ -133,6 +134,11 @@ DBusAddressTranslatorTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
 DBusAddressTranslatorTest_CXXFLAGS = ${GTEST_CXXFLAGS}
 DBusAddressTranslatorTest_LDADD = ${LDADD_FOR_GTEST}
 
+DBusConnectionTest_SOURCES = src/test/DBusConnectionTest.cpp
+DBusConnectionTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
+DBusConnectionTest_CXXFLAGS = ${GTEST_CXXFLAGS}
+DBusConnectionTest_LDADD = ${LDADD_FOR_GTEST}
+
 DBusTypeStreamTest_SOURCES = src/test/DBusTypeStreamTest.cpp
 DBusTypeStreamTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
 DBusTypeStreamTest_CXXFLAGS = ${GTEST_CXXFLAGS}
diff --git a/src/test/DBusConnectionTest.cpp b/src/test/DBusConnectionTest.cpp
index 0b85009..f06f11d 100644
--- a/src/test/DBusConnectionTest.cpp
+++ b/src/test/DBusConnectionTest.cpp
@@ -4,195 +4,277 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-#include <common-api-dbus/dbus-connection.h>
-#include <common-api-dbus/dbus-output-message-stream.h>
+#include <CommonAPI/DBus/DBusConnection.h>
+#include <CommonAPI/DBus/DBusProxyAsyncCallbackHandler.h>
 
 #include <gtest/gtest.h>
+#include <dbus/dbus.h>
 
 #include <cstring>
 
 
-#define	ASSERT_DBUSMESSAGE_EQ(_dbusMessage1, _dbusMessage2) \
-			ASSERT_FALSE(_dbusMessage1.getSignatureString() == NULL); \
-			ASSERT_FALSE(_dbusMessage2.getSignatureString() == NULL); \
-			ASSERT_STREQ(_dbusMessage1.getSignatureString(), _dbusMessage2.getSignatureString()); \
-			ASSERT_EQ(_dbusMessage1.getBodyLength(), _dbusMessage2.getBodyLength()); \
-			ASSERT_FALSE(_dbusMessage1.getBodyData() == NULL); \
-			ASSERT_FALSE(_dbusMessage2.getBodyData() == NULL); \
-			ASSERT_EQ(memcmp(_dbusMessage1.getBodyData(), _dbusMessage2.getBodyData(), _dbusMessage1.getBodyLength()), 0)
-
-
-namespace {
-
 class DBusConnectionTest: public ::testing::Test {
- public:
-	void onConnectionStatusEvent(const common::api::AvailabilityStatus& newConnectionStatus) {
-		connectionStatusEventCount_++;
-		connectionStatus_ = newConnectionStatus;
-	}
-
-	bool onInterfaceHandlerDBusMessageReply(const common::api::dbus::DBusMessage& dbusMessage,
-											const std::shared_ptr<common::api::dbus::DBusConnection>& dbusConnection) {
-		interfaceHandlerDBusMessageCount_++;
-		interfaceHandlerDBusMessage_ = dbusMessage;
-		interfaceHandlerDBusMessageReply_ = dbusMessage.createMethodReturn("si");
-
-		common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(interfaceHandlerDBusMessageReply_);
-		dbusOutputMessageStream << "This is a default message reply!" << interfaceHandlerDBusMessageCount_;
-		dbusOutputMessageStream.flush();
-
-		dbusConnection->sendDBusMessage(interfaceHandlerDBusMessageReply_);
-
-		return true;
-	}
-
-	void onDBusMessageHandler(const common::api::dbus::DBusMessage& dbusMessage) {
-		dbusMessageHandlerCount_++;
-		dbusMessageHandlerDBusMessage_ = dbusMessage;
-	}
-
  protected:
 	virtual void SetUp() {
-		dbusConnection_ = common::api::dbus::DBusConnection::getSessionBus();
-		connectionStatusEventCount_ = 0;
-		interfaceHandlerDBusMessageCount_ = 0;
-		dbusMessageHandlerCount_ = 0;
 	}
 
 	virtual void TearDown() {
-		if (dbusConnection_ && dbusConnection_->isConnected())
-			dbusConnection_->disconnect();
-
-		// reset DBusMessage
-		interfaceHandlerDBusMessage_ = common::api::dbus::DBusMessage();
-		interfaceHandlerDBusMessageReply_ = common::api::dbus::DBusMessage();
-
-		dbusMessageHandlerDBusMessage_ = common::api::dbus::DBusMessage();
 	}
-
-
-	std::shared_ptr<common::api::dbus::DBusConnection> dbusConnection_;
-
-	uint32_t connectionStatusEventCount_;
-	common::api::AvailabilityStatus connectionStatus_;
-
-	uint32_t interfaceHandlerDBusMessageCount_;
-	common::api::dbus::DBusMessage interfaceHandlerDBusMessage_;
-	common::api::dbus::DBusMessage interfaceHandlerDBusMessageReply_;
-
-	uint32_t dbusMessageHandlerCount_;
-	common::api::dbus::DBusMessage dbusMessageHandlerDBusMessage_;
 };
 
 
-TEST_F(DBusConnectionTest, IsInitiallyDisconnected) {
-	ASSERT_FALSE(dbusConnection_->isConnected());
+//TEST_F(DBusConnectionTest, IsInitiallyDisconnected) {
+//	ASSERT_FALSE(dbusConnection_->isConnected());
+//}
+//
+//TEST_F(DBusConnectionTest, ConnectAndDisconnectWork) {
+//	ASSERT_TRUE(dbusConnection_->connect());
+//	ASSERT_TRUE(dbusConnection_->isConnected());
+//
+//	dbusConnection_->disconnect();
+//	ASSERT_FALSE(dbusConnection_->isConnected());
+//}
+//
+//TEST_F(DBusConnectionTest, ConnectionStatusEventWorks) {
+//	ASSERT_EQ(connectionStatusEventCount_, 0);
+//
+//	auto connectionStatusSubscription = dbusConnection_->getConnectionStatusEvent().subscribe(std::bind(
+//			&DBusConnectionTest::onConnectionStatusEvent,
+//			this,
+//			std::placeholders::_1));
+//
+//	ASSERT_FALSE(dbusConnection_->isConnected());
+//	ASSERT_EQ(connectionStatusEventCount_, 0);
+//
+//	uint32_t expectedEventCount = 0;
+//	while (expectedEventCount < 10) {
+//		ASSERT_TRUE(dbusConnection_->connect());
+//		ASSERT_TRUE(dbusConnection_->isConnected());
+//		ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount);
+//		ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::AVAILABLE);
+//
+//		dbusConnection_->disconnect();
+//		ASSERT_FALSE(dbusConnection_->isConnected());
+//		ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount);
+//		ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::NOT_AVAILABLE);
+//	}
+//
+//	dbusConnection_->getConnectionStatusEvent().unsubscribe(connectionStatusSubscription);
+//	ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
+//
+//	ASSERT_TRUE(dbusConnection_->connect());
+//	ASSERT_TRUE(dbusConnection_->isConnected());
+//	ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
+//
+//	dbusConnection_->disconnect();
+//	ASSERT_FALSE(dbusConnection_->isConnected());
+//	ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
+//}
+//
+//TEST_F(DBusConnectionTest, SendingAsyncDBusMessagesWorks) {
+//	const char* busName = "common.api.dbus.test.TestInterfaceHandler";
+//	const char* objectPath = "/common/api/dbus/test/TestObject";
+//	const char* interfaceName = "common.api.dbus.test.TestInterface";
+//	const char* methodName = "TestMethod";
+//
+//	auto interfaceHandlerDBusConnection = common::api::dbus::DBusConnection::getSessionBus();
+//
+//	ASSERT_TRUE(interfaceHandlerDBusConnection->connect());
+//	ASSERT_TRUE(interfaceHandlerDBusConnection->requestServiceNameAndBlock(busName));
+//
+//	auto interfaceHandlerToken = interfaceHandlerDBusConnection->registerInterfaceHandler(
+//			objectPath,
+//			interfaceName,
+//			std::bind(&DBusConnectionTest::onInterfaceHandlerDBusMessageReply,
+//					  this,
+//					  std::placeholders::_1,
+//					  interfaceHandlerDBusConnection));
+//
+//
+//	ASSERT_TRUE(dbusConnection_->connect());
+//
+//	for (uint32_t expectedDBusMessageCount = 1; expectedDBusMessageCount <= 10; expectedDBusMessageCount++) {
+//		auto dbusMessageCall = common::api::dbus::DBusMessage::createMethodCall(
+//				busName,
+//				objectPath,
+//				interfaceName,
+//				methodName,
+//				"si");
+//		ASSERT_TRUE(dbusMessageCall);
+//
+//		common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(dbusMessageCall);
+//		dbusOutputMessageStream << "This is a test async call"
+//								<< expectedDBusMessageCount;
+//		dbusOutputMessageStream.flush();
+//
+//		dbusConnection_->sendDBusMessageWithReplyAsync(
+//				dbusMessageCall,
+//				std::bind(&DBusConnectionTest::onDBusMessageHandler, this, std::placeholders::_1));
+//
+//		for (int i = 0; i < 10 && interfaceHandlerDBusMessageCount_ < expectedDBusMessageCount; i++)
+//			interfaceHandlerDBusConnection->readWriteDispatch(100);
+//
+//		ASSERT_EQ(interfaceHandlerDBusMessageCount_, expectedDBusMessageCount);
+//		ASSERT_DBUSMESSAGE_EQ(dbusMessageCall, interfaceHandlerDBusMessage_);
+//
+//		for (int i = 0; i < 10 && dbusMessageHandlerCount_ < expectedDBusMessageCount; i++)
+//			dbusConnection_->readWriteDispatch(100);
+//
+//		ASSERT_EQ(dbusMessageHandlerCount_, expectedDBusMessageCount);
+//		ASSERT_DBUSMESSAGE_EQ(dbusMessageHandlerDBusMessage_, interfaceHandlerDBusMessageReply_);
+//	}
+//
+//	dbusConnection_->disconnect();
+//
+//
+//	interfaceHandlerDBusConnection->unregisterInterfaceHandler(interfaceHandlerToken);
+//
+//	ASSERT_TRUE(interfaceHandlerDBusConnection->releaseServiceName(busName));
+//	interfaceHandlerDBusConnection->disconnect();
+//}
+
+
+void dispatch(::DBusConnection* libdbusConnection) {
+	dbus_bool_t success = TRUE;
+	while(success) {
+        success = dbus_connection_read_write_dispatch(libdbusConnection, 1);
+    }
 }
 
-TEST_F(DBusConnectionTest, ConnectAndDisconnectWork) {
-	ASSERT_TRUE(dbusConnection_->connect());
-	ASSERT_TRUE(dbusConnection_->isConnected());
+std::promise<bool> promise;
+std::future<bool> future = promise.get_future();
 
-	dbusConnection_->disconnect();
-	ASSERT_FALSE(dbusConnection_->isConnected());
+void notifyThunk(DBusPendingCall*, void* data) {
+	::DBusConnection* libdbusConnection = reinterpret_cast<DBusConnection*>(data);
+	dbus_connection_close(libdbusConnection);
+	dbus_connection_unref(libdbusConnection);
+	promise.set_value(true);
 }
 
-TEST_F(DBusConnectionTest, ConnectionStatusEventWorks) {
-	ASSERT_EQ(connectionStatusEventCount_, 0);
+TEST_F(DBusConnectionTest, LibdbusConnectionsMayCommitSuicide) {
+	const ::DBusBusType libdbusType = ::DBusBusType::DBUS_BUS_SESSION;
+	::DBusError libdbusError;
+	dbus_error_init(&libdbusError);
+	::DBusConnection* libdbusConnection = dbus_bus_get_private(libdbusType, &libdbusError);
 
-	auto connectionStatusSubscription = dbusConnection_->getConnectionStatusEvent().subscribe(std::bind(
-			&DBusConnectionTest::onConnectionStatusEvent,
-			this,
-			std::placeholders::_1));
+	assert(libdbusConnection);
+	dbus_connection_set_exit_on_disconnect(libdbusConnection, false);
 
-	ASSERT_FALSE(dbusConnection_->isConnected());
-	ASSERT_EQ(connectionStatusEventCount_, 0);
+	auto dispatchThread = std::thread(&dispatch, libdbusConnection);
 
-	uint32_t expectedEventCount = 0;
-	while (expectedEventCount < 10) {
-		ASSERT_TRUE(dbusConnection_->connect());
-		ASSERT_TRUE(dbusConnection_->isConnected());
-		ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount);
-		ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::AVAILABLE);
+	::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(
+			"org.freedesktop.DBus",
+			"/org/freedesktop/DBus",
+			"org.freedesktop.DBus",
+            "ListNames");
 
-		dbusConnection_->disconnect();
-		ASSERT_FALSE(dbusConnection_->isConnected());
-		ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount);
-		ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::NOT_AVAILABLE);
-	}
+	dbus_message_set_signature(libdbusMessageCall, "");
 
-	dbusConnection_->getConnectionStatusEvent().unsubscribe(connectionStatusSubscription);
-	ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
+    bool hasHappened = false;
 
-	ASSERT_TRUE(dbusConnection_->connect());
-	ASSERT_TRUE(dbusConnection_->isConnected());
-	ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
+    DBusPendingCall* libdbusPendingCall;
+    dbus_bool_t libdbusSuccess;
 
-	dbusConnection_->disconnect();
-	ASSERT_FALSE(dbusConnection_->isConnected());
-	ASSERT_EQ(connectionStatusEventCount_, expectedEventCount);
-}
+    dbus_connection_send_with_reply(
+                    libdbusConnection,
+                    libdbusMessageCall,
+                    &libdbusPendingCall,
+                    500);
 
-TEST_F(DBusConnectionTest, SendingAsyncDBusMessagesWorks) {
-	const char* busName = "common.api.dbus.test.TestInterfaceHandler";
-	const char* objectPath = "/common/api/dbus/test/TestObject";
-	const char* interfaceName = "common.api.dbus.test.TestInterface";
-	const char* methodName = "TestMethod";
+    dbus_pending_call_set_notify(
+                    libdbusPendingCall,
+                    notifyThunk,
+                    libdbusConnection,
+                    NULL);
 
-	auto interfaceHandlerDBusConnection = common::api::dbus::DBusConnection::getSessionBus();
+    ASSERT_EQ(true, future.get());
+    dispatchThread.join();
+}
 
-	ASSERT_TRUE(interfaceHandlerDBusConnection->connect());
-	ASSERT_TRUE(interfaceHandlerDBusConnection->requestServiceNameAndBlock(busName));
 
-	auto interfaceHandlerToken = interfaceHandlerDBusConnection->registerInterfaceHandler(
-			objectPath,
-			interfaceName,
-			std::bind(&DBusConnectionTest::onInterfaceHandlerDBusMessageReply,
-					  this,
-					  std::placeholders::_1,
-					  interfaceHandlerDBusConnection));
+std::promise<bool> promise2;
+std::future<bool> future2 = promise2.get_future();
+std::promise<bool> promise3;
+std::future<bool> future3 = promise3.get_future();
 
+void noPartnerCallback(DBusPendingCall*, void* data) {
+	::DBusConnection* libdbusConnection = reinterpret_cast<DBusConnection*>(data);
+	dbus_connection_close(libdbusConnection);
+	dbus_connection_unref(libdbusConnection);
+	promise2.set_value(true);
+}
 
-	ASSERT_TRUE(dbusConnection_->connect());
+void noPartnerCleanup(void* data) {
+	std::cout << "Cleanup" << std::endl;
+	promise3.set_value(true);
+}
 
-	for (uint32_t expectedDBusMessageCount = 1; expectedDBusMessageCount <= 10; expectedDBusMessageCount++) {
-		auto dbusMessageCall = common::api::dbus::DBusMessage::createMethodCall(
-				busName,
-				objectPath,
-				interfaceName,
-				methodName,
-				"si");
-		ASSERT_TRUE(dbusMessageCall);
+TEST_F(DBusConnectionTest, TimeoutForNonexistingServices) {
+	const ::DBusBusType libdbusType = ::DBusBusType::DBUS_BUS_SESSION;
+	::DBusError libdbusError;
+	dbus_error_init(&libdbusError);
+	::DBusConnection* libdbusConnection = dbus_bus_get_private(libdbusType, &libdbusError);
 
-		common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(dbusMessageCall);
-		dbusOutputMessageStream << "This is a test async call"
-								<< expectedDBusMessageCount;
-		dbusOutputMessageStream.flush();
+	assert(libdbusConnection);
+	dbus_connection_set_exit_on_disconnect(libdbusConnection, false);
 
-		dbusConnection_->sendDBusMessageWithReplyAsync(
-				dbusMessageCall,
-				std::bind(&DBusConnectionTest::onDBusMessageHandler, this, std::placeholders::_1));
+	auto dispatchThread = std::thread(&dispatch, libdbusConnection);
 
-		for (int i = 0; i < 10 && interfaceHandlerDBusMessageCount_ < expectedDBusMessageCount; i++)
-			interfaceHandlerDBusConnection->readWriteDispatch(100);
+	::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(
+			"some.connection.somewhere",
+			"/some/non/existing/object",
+			"some.interface.somewhere.but.same.place",
+            "NoReasonableMethod");
 
-		ASSERT_EQ(interfaceHandlerDBusMessageCount_, expectedDBusMessageCount);
-		ASSERT_DBUSMESSAGE_EQ(dbusMessageCall, interfaceHandlerDBusMessage_);
+	dbus_message_set_signature(libdbusMessageCall, "");
 
-		for (int i = 0; i < 10 && dbusMessageHandlerCount_ < expectedDBusMessageCount; i++)
-			dbusConnection_->readWriteDispatch(100);
+    bool hasHappened = false;
 
-		ASSERT_EQ(dbusMessageHandlerCount_, expectedDBusMessageCount);
-		ASSERT_DBUSMESSAGE_EQ(dbusMessageHandlerDBusMessage_, interfaceHandlerDBusMessageReply_);
-	}
+    DBusPendingCall* libdbusPendingCall;
+    dbus_bool_t libdbusSuccess;
 
-	dbusConnection_->disconnect();
+    dbus_connection_send_with_reply(
+                    libdbusConnection,
+                    libdbusMessageCall,
+                    &libdbusPendingCall,
+                    5000);
 
+    dbus_pending_call_set_notify(
+                    libdbusPendingCall,
+                    noPartnerCallback,
+                    libdbusConnection,
+                    noPartnerCleanup);
 
-	interfaceHandlerDBusConnection->unregisterInterfaceHandler(interfaceHandlerToken);
+    ASSERT_EQ(true, future2.get());
+    dispatchThread.join();
+}
 
-	ASSERT_TRUE(interfaceHandlerDBusConnection->releaseServiceName(busName));
-	interfaceHandlerDBusConnection->disconnect();
+//TEST_F(DBusConnectionTest, ConnectionsMayCommitAsynchronousSuicide) {
+//	CommonAPI::DBus::DBusConnection* dbusConnection_ = new CommonAPI::DBus::DBusConnection(CommonAPI::DBus::DBusConnection::BusType::SESSION);
+//	dbusConnection_->connect();
+//
+//    auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall(
+//			"org.freedesktop.DBus",
+//			"/org/freedesktop/DBus",
+//			"org.freedesktop.DBus",
+//            "ListNames",
+//            "");
+//
+//    bool hasHappened = false;
+//
+//	auto future = dbusConnection_->sendDBusMessageWithReplyAsync(dbusMessageCall, CommonAPI::DBus::DBusProxyAsyncCallbackHandler<std::vector<std::string>>::create(
+//    		[&] (const CommonAPI::CallStatus&, std::vector<std::string>) {
+//				hasHappened = true;
+//    			delete dbusConnection_;
+//    		}
+//    ));
+//
+//	ASSERT_EQ(CommonAPI::CallStatus::SUCCESS, future.get());
+//}
+
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }
 
-} // namespace