Split initialization to 2 phases. initialize() and connectToServer()

13 files changed, 90 insertions, 16 deletions

diff --git a/include/resource-factory.h b/include/resource-factory.h
index 90131c9..2e544fe 100644
--- a/include/resource-factory.h
+++ b/include/resource-factory.h
@@ -5,12 +5,12 @@
 #include <QDBusConnection>
 #include "resource-types.h"
 
-class ResourceLibrary;
 class Resource;
 
 class ResourceFactory: public QObject
 {
    Q_OBJECT
+   Q_DISABLE_COPY( ResourceFactory );
 private:
    QDBusConnection sessionBusConnection;
 public:
diff --git a/include/resource.h b/include/resource.h
index 1cec065..3cdf8b8 100644
--- a/include/resource.h
+++ b/include/resource.h
@@ -9,6 +9,7 @@
 class Resource: public QObject
 {
    Q_OBJECT
+   Q_DISABLE_COPY( Resource );
    friend class ResourceFactory;
    friend class TestResource;
 private:
@@ -24,6 +25,8 @@ public:
    enum ResourceClass getResourceClass();
    quint16 getResourceFlags();
 
+   bool connectToServer();
+
    virtual bool requestExclusiveAccess();
    virtual bool releaseExclusiveAccess();
    virtual bool getExclusiveAccessState();
diff --git a/src/libplayback-wrapper.cpp b/src/libplayback-wrapper.cpp
index 904ccb6..6b51f94 100644
--- a/src/libplayback-wrapper.cpp
+++ b/src/libplayback-wrapper.cpp
@@ -22,9 +22,14 @@ bool LibPlaybackWrapper::initialize()
 	return false;
     }
     if(dbusConnection == NULL) {
+	qDebug("Unable to connect to dbus, dbusConnection == NULL!");
 	return false;
     }
-    
+    return true;
+}
+
+bool LibPlaybackWrapper::connectToServer()
+{
     enum pb_class_e libPlaybackClass = resourceClassToLibPlaybackClass(resource->getResourceClass());
     quint16 libPlaybackFlags = resourceFlagToLibPlaybackFlags(resource->getResourceFlags());
     libPlaybackHandle = pb_playback_new_2(dbusConnection, libPlaybackClass, libPlaybackFlags,
diff --git a/src/libplayback-wrapper.h b/src/libplayback-wrapper.h
index 83baf28..be86c7f 100644
--- a/src/libplayback-wrapper.h
+++ b/src/libplayback-wrapper.h
@@ -8,6 +8,7 @@
 class LibPlaybackWrapper: public QObject, public ResourceLibrary
 {
    Q_OBJECT
+   Q_DISABLE_COPY( LibPlaybackWrapper );
 private:
    DBusConnection *dbusConnection;
    pb_playback_t *libPlaybackHandle;
@@ -16,6 +17,7 @@ public:
    LibPlaybackWrapper(Resource *resource);
    ~LibPlaybackWrapper();
    bool initialize();
+   bool connectToServer();
 };
 
 void libPlaybackStateHandler(pb_playback_t *libPlaybackHandle, enum pb_state_e requestedState,
diff --git a/src/resource-factory.cpp b/src/resource-factory.cpp
index 03566e2..b042b34 100644
--- a/src/resource-factory.cpp
+++ b/src/resource-factory.cpp
@@ -20,6 +20,7 @@ Resource * ResourceFactory::createResource(enum ResourceClass type, quint16 usag
 	return resource;
     }
     else {
+	qDebug("Failed to initialize Resource. Returning NULL!");
 	delete resource;
 	return NULL;
     }
diff --git a/src/resource-library.h b/src/resource-library.h
index f9e178b..f68471d 100644
--- a/src/resource-library.h
+++ b/src/resource-library.h
@@ -6,6 +6,7 @@ class ResourceLibrary
 public:
    virtual ~ResourceLibrary() {}
    virtual bool initialize() = 0;
+   virtual bool connectToServer() = 0;
 };
 
 #endif
diff --git a/src/resource.cpp b/src/resource.cpp
index 3bbe0a4..2de05ee 100644
--- a/src/resource.cpp
+++ b/src/resource.cpp
@@ -15,6 +15,10 @@ bool Resource::initialize(ResourceLibrary *library)
     return resourceLibrary->initialize();
 }
 
+bool Resource::connectToServer()
+{
+    return resourceLibrary->connectToServer();
+}
 
 quint16 Resource::getResourceFlags()
 {
diff --git a/tests/mock-resource-library.cpp b/tests/mock-resource-library.cpp
index 4a4fdb4..49c29e4 100644
--- a/tests/mock-resource-library.cpp
+++ b/tests/mock-resource-library.cpp
@@ -1,7 +1,10 @@
 #include "mock-resource-library.h"
 
-MockResourceLibrary::MockResourceLibrary(QObject *parent, bool makeInitFail)
-    : QObject(parent), initializeFails(makeInitFail)
+MockResourceLibrary::MockResourceLibrary(QObject *parent,
+					 bool makeInitializationFail,
+					 bool makeConnectingToServerFail)
+    : QObject(parent), initializeFails(makeInitializationFail),
+      connectToServerFails(makeConnectingToServerFail)
 {
 }
 
@@ -11,10 +14,26 @@ MockResourceLibrary::~MockResourceLibrary()
 
 void MockResourceLibrary::makeInitializeFail()
 {
-    initializeFails=true;
+    initializeFails = true;
 }
 
 bool MockResourceLibrary::initialize()
 {
-    return !initializeFails;
+    if(initializeFails==false)
+	return true;
+    else
+	return false;
+}
+
+void MockResourceLibrary::makeServerConnectFail()
+{
+    connectToServerFails = true;
+}
+
+bool MockResourceLibrary::connectToServer()
+{
+    if(connectToServerFails == false)
+	return true;
+    else
+	return false;
 }
diff --git a/tests/mock-resource-library.h b/tests/mock-resource-library.h
index df6fd97..6c743fe 100644
--- a/tests/mock-resource-library.h
+++ b/tests/mock-resource-library.h
@@ -9,11 +9,15 @@ class MockResourceLibrary: public QObject, public ResourceLibrary
    Q_OBJECT
 private:
    bool initializeFails;
+   bool connectToServerFails;
 public:
-   MockResourceLibrary(QObject *parent=0,bool makeInitFail=false);
+   MockResourceLibrary(QObject *parent=0,bool makeInitializationFail=false,
+		       bool makeConnectingToServerFail=false);
    virtual ~MockResourceLibrary();
    void makeInitializeFail();
+   void makeServerConnectFail();
    bool initialize();
+   bool connectToServer();
 };
 
 #endif
diff --git a/tests/test-libplayback.cpp b/tests/test-libplayback.cpp
index 46c28e3..7cdb2bf 100644
--- a/tests/test-libplayback.cpp
+++ b/tests/test-libplayback.cpp
@@ -2,6 +2,8 @@
 
 TestLibplayback::TestLibplayback()
 {
+    resourceFactory=NULL;
+    resource=NULL;
 }
 
 TestLibplayback::~TestLibplayback()
@@ -12,12 +14,13 @@ void TestLibplayback::initTestCase()
 {
     resourceFactory = new ResourceFactory(this);
     QVERIFY(resourceFactory != NULL);
+    Resource *resource = resourceFactory->createResource(MediaClass, RP_FLAGS_AUDIO|RP_FLAGS_VIDEO);
+    QVERIFY(resource != NULL);
 }
 
-void TestLibplayback::testCreateResource()
+void TestLibplayback::testConnectToServer()
 {
-    Resource *resource = resourceFactory->createResource(MediaClass, RP_FLAGS_AUDIO|RP_FLAGS_VIDEO);
-    QVERIFY(resource != NULL);
+    resource->connectToServer();
 }
 
 QTEST_MAIN(TestLibplayback)
diff --git a/tests/test-libplayback.h b/tests/test-libplayback.h
index 75a04ed..9c294e6 100644
--- a/tests/test-libplayback.h
+++ b/tests/test-libplayback.h
@@ -3,20 +3,21 @@
 
 #include <QtTest/QTest>
 #include "resource-factory.h"
+#include "resource.h"
 
 class TestLibplayback: public QObject
 {
    Q_OBJECT
 private:
-   ResourceLibrary *resourceLibrary;
    ResourceFactory *resourceFactory;
+   Resource *resource;
 public:
    TestLibplayback();
    ~TestLibplayback();
 private slots:
    void initTestCase();
 
-   void testCreateResource();
+   void testConnectToServer();
 };
 
 #endif
diff --git a/tests/test-resource.cpp b/tests/test-resource.cpp
index 3dce276..eb2b59d 100644
--- a/tests/test-resource.cpp
+++ b/tests/test-resource.cpp
@@ -7,13 +7,14 @@ TestResource::~TestResource()
 {
 }
 
-void TestResource::initTestCase()
+void TestResource::init()
 {
     resource = new Resource(MediaClass, RP_FLAGS_AUDIO|RP_FLAGS_VIDEO, this);
-    resourceLibrary = new MockResourceLibrary(resource, false);
+    resourceLibrary = new MockResourceLibrary(resource, false, false);
     QVERIFY(resource != NULL);
     QVERIFY(resource->resourceClass == MediaClass);
     QVERIFY(resource->flags == (RP_FLAGS_AUDIO|RP_FLAGS_VIDEO));
+    qDebug("INIT!");
 }
 
 void TestResource::testInitializeSucceeds()
@@ -34,7 +35,34 @@ void TestResource::testInitializeFails()
 
     QEXPECT_FAIL("", "Expecting resourceLibrary->initialize() to fail", Continue);
     QVERIFY(initializeSucceeded);
-    delete resource;
+}
+
+void TestResource::testConnectToServerSucceeds()
+{
+    bool initializeSucceeded = resource->initialize(resourceLibrary);
+
+    QVERIFY(resource->resourceLibrary == resourceLibrary);
+    QVERIFY(initializeSucceeded);
+
+    bool connectToServerSucceeded = resource->connectToServer();
+    QVERIFY(connectToServerSucceeded);
+}
+
+void TestResource::testConnectToServerFails()
+{
+    MockResourceLibrary *mockResourceLibrary =
+	static_cast<MockResourceLibrary *>(resourceLibrary);
+
+    bool initializeSucceeded = resource->initialize(resourceLibrary);
+
+    QVERIFY(resource->resourceLibrary == resourceLibrary);
+    QVERIFY(initializeSucceeded);
+
+    mockResourceLibrary->makeServerConnectFail();
+    bool connectToServerSucceeded = resource->connectToServer();
+
+    QEXPECT_FAIL("", "Expecting resourceLibrary->connectToServer() to fail", Continue);
+    QVERIFY(connectToServerSucceeded);
 }
 
 QTEST_MAIN(TestResource)
diff --git a/tests/test-resource.h b/tests/test-resource.h
index 6ae3859..295d6d3 100644
--- a/tests/test-resource.h
+++ b/tests/test-resource.h
@@ -15,10 +15,13 @@ public:
    TestResource();
    ~TestResource();
 private slots:
-   void initTestCase();
+   void init();
 
    void testInitializeSucceeds();
    void testInitializeFails();
+
+   void testConnectToServerSucceeds();
+   void testConnectToServerFails();
 };
 
 #endif