projects / quassel.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
tests: Extend SignalProxyTest to cover request/receive method pairs
[quassel.git] / tests / common / signalproxytest.cpp
diff --git a/tests/common/signalproxytest.cpp b/tests/common/signalproxytest.cpp
index c79f0a2..4ac47eb 100644 (file)
--- a/tests/common/signalproxytest.cpp
+++ b/tests/common/signalproxytest.cpp
@@ -65,20 +65,32 @@ public:
     using Data = std::pair<int, QString>;
     using Spy = ValueSpy<Data>;
 
     using Data = std::pair<int, QString>;
     using Spy = ValueSpy<Data>;
 
-    ProxyObject(Spy* spy)
+    ProxyObject(Spy* spy, Peer* expectedPeer)
         : _spy{spy}
         : _spy{spy}
+        , _expectedPeer{expectedPeer}
     {}
 
 signals:
     void sendData(int, const QString&);
     void sendMoreData(int, const QString&);
     {}
 
 signals:
     void sendData(int, const QString&);
     void sendMoreData(int, const QString&);
+    void sendToFunctor(int, const QString&);
 
 public slots:
 
 public slots:
-    void receiveData(int i, const QString& s) { _spy->notify(std::make_pair(i, s)); }
-    void receiveExtraData(int i, const QString& s) { _spy->notify(std::make_pair(-i, s.toUpper())); }
+    void receiveData(int i, const QString& s)
+    {
+        EXPECT_EQ(_expectedPeer, SignalProxy::current()->sourcePeer());
+        _spy->notify(std::make_pair(i, s));
+    }
+
+    void receiveExtraData(int i, const QString& s)
+    {
+        EXPECT_EQ(_expectedPeer, SignalProxy::current()->sourcePeer());
+        _spy->notify(std::make_pair(-i, s.toUpper()));
+    }
 
 private:
     Spy* _spy;
 
 private:
     Spy* _spy;
+    Peer* _expectedPeer;
 };
 
 TEST_F(SignalProxyTest, attachSignal)
 };
 
 TEST_F(SignalProxyTest, attachSignal)
@@ -88,21 +100,29 @@ TEST_F(SignalProxyTest, attachSignal)
         EXPECT_CALL(*_clientPeer, Dispatches(RpcCall(Eq(SIGNAL(sendData(int,QString))), ElementsAre(42, "Hello"))));
         EXPECT_CALL(*_clientPeer, Dispatches(RpcCall(Eq(SIGNAL(sendExtraData(int,QString))), ElementsAre(42, "Hello"))));
         EXPECT_CALL(*_serverPeer, Dispatches(RpcCall(Eq("2sendData(int,QString)"), ElementsAre(23, "World"))));
         EXPECT_CALL(*_clientPeer, Dispatches(RpcCall(Eq(SIGNAL(sendData(int,QString))), ElementsAre(42, "Hello"))));
         EXPECT_CALL(*_clientPeer, Dispatches(RpcCall(Eq(SIGNAL(sendExtraData(int,QString))), ElementsAre(42, "Hello"))));
         EXPECT_CALL(*_serverPeer, Dispatches(RpcCall(Eq("2sendData(int,QString)"), ElementsAre(23, "World"))));
+        EXPECT_CALL(*_serverPeer, Dispatches(RpcCall(Eq("2sendToFunctor(int,QString)"), ElementsAre(17, "Hi Universe"))));
     }
 
     ProxyObject::Spy clientSpy, serverSpy;
     }
 
     ProxyObject::Spy clientSpy, serverSpy;
-    ProxyObject clientObject{&clientSpy};
-    ProxyObject serverObject{&serverSpy};
+    ProxyObject clientObject{&clientSpy, _clientPeer};
+    ProxyObject serverObject{&serverSpy, _serverPeer};
 
     // Deliberately not normalize some of the macro invocations
 
     // Deliberately not normalize some of the macro invocations
-    _clientProxy.attachSignal(&clientObject, SIGNAL(sendData(int, const QString&)));
-    _serverProxy.attachSlot(SIGNAL(sendData(int,QString)), &serverObject, SLOT(receiveData(int, const QString&)));
+    _clientProxy.attachSignal(&clientObject, &ProxyObject::sendData);
+    _serverProxy.attachSlot(SIGNAL(sendData(int,QString)), &serverObject, &ProxyObject::receiveData);
+
+    _clientProxy.attachSignal(&clientObject, &ProxyObject::sendMoreData, SIGNAL(sendExtraData(int, const QString&)));
+    _serverProxy.attachSlot(SIGNAL(sendExtraData(int, const QString&)), &serverObject, &ProxyObject::receiveExtraData);
 
 
-    _clientProxy.attachSignal(&clientObject, SIGNAL(sendMoreData(int,QString)), SIGNAL(sendExtraData(int,QString)));
-    _serverProxy.attachSlot(SIGNAL(sendExtraData(int, const QString&)), &serverObject, SLOT(receiveExtraData(int,QString)));
+    _serverProxy.attachSignal(&serverObject, &ProxyObject::sendData);
+    //_clientProxy.attachSlot(SIGNAL(sendData(int, const QString&)), &clientObject, SLOT(receiveData(int,QString)));
+    _clientProxy.attachSlot(SIGNAL(sendData(int, const QString&)), &clientObject, &ProxyObject::receiveData);
 
 
-    _serverProxy.attachSignal(&serverObject, SIGNAL(sendData(int,QString)));
-    _clientProxy.attachSlot(SIGNAL(sendData(int, const QString&)), &clientObject, SLOT(receiveData(int,QString)));
+    _serverProxy.attachSignal(&serverObject, &ProxyObject::sendToFunctor);
+    _clientProxy.attachSlot(SIGNAL(sendToFunctor(int, const QString&)), this, [this, &clientSpy](int i, const QString& s) {
+        EXPECT_EQ(_clientPeer, SignalProxy::current()->sourcePeer());
+        clientSpy.notify(std::make_pair(i, s));
+    });
 
     emit clientObject.sendData(42, "Hello");
     ASSERT_TRUE(serverSpy.wait());
 
     emit clientObject.sendData(42, "Hello");
     ASSERT_TRUE(serverSpy.wait());
@@ -115,6 +135,10 @@ TEST_F(SignalProxyTest, attachSignal)
     emit serverObject.sendData(23, "World");
     ASSERT_TRUE(clientSpy.wait());
     EXPECT_EQ(ProxyObject::Data(23, "World"), clientSpy.value());
     emit serverObject.sendData(23, "World");
     ASSERT_TRUE(clientSpy.wait());
     EXPECT_EQ(ProxyObject::Data(23, "World"), clientSpy.value());
+
+    emit serverObject.sendToFunctor(17, "Hi Universe");
+    ASSERT_TRUE(clientSpy.wait());
+    EXPECT_EQ(ProxyObject::Data(17, "Hi Universe"), clientSpy.value());
 }
 
 // -----------------------------------------------------------------------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------------------------------------------------------------------
@@ -129,7 +153,6 @@ class SyncObj : public SyncableObject
     Q_PROPERTY(double doubleProperty READ doubleProperty WRITE setDoubleProperty)
 
 public:
     Q_PROPERTY(double doubleProperty READ doubleProperty WRITE setDoubleProperty)
 
 public:
-
     int intProperty() const
     {
         return _intProperty;
     int intProperty() const
     {
         return _intProperty;
@@ -197,19 +220,45 @@ public slots:
         emit syncMethodCalled(intArg, stringArg);
     }
 
         emit syncMethodCalled(intArg, stringArg);
     }
 
-    void requestMethod(const QString& stringArg, int intArg)
+    int requestInt(const QString& stringArg, int intArg)
+    {
+        REQUEST(ARG(stringArg), ARG(intArg));
+        REQUEST_OTHER(setIntProperty, ARG(intArg));
+        emit requestMethodCalled(stringArg, intArg);
+        return -intArg;
+    }
+
+    QString requestString(const QString& stringArg, int intArg)
     {
         REQUEST(ARG(stringArg), ARG(intArg));
         REQUEST_OTHER(setStringProperty, ARG(stringArg));
         emit requestMethodCalled(stringArg, intArg);
     {
         REQUEST(ARG(stringArg), ARG(intArg));
         REQUEST_OTHER(setStringProperty, ARG(stringArg));
         emit requestMethodCalled(stringArg, intArg);
+        return stringArg.toUpper();
     }
 
     }
 
+    // Receive methods can either have the full signature of the request method + return value, or...
+    void receiveInt(const QString&, int, int reply)
+    {
+        _intProperty = reply;
+        emit intReceived(reply);
+    }
+
+    // ... only the return value
+    void receiveString(const QString& reply)
+    {
+        _stringProperty = reply;
+        emit stringReceived(reply);
+    }
+
+
 signals:
     void intPropertyChanged(int);
     void stringPropertyChanged(const QString&);
     void fooDataChanged(const QByteArray&);
     void syncMethodCalled(int, const QString&);
     void requestMethodCalled(const QString&, int);
 signals:
     void intPropertyChanged(int);
     void stringPropertyChanged(const QString&);
     void fooDataChanged(const QByteArray&);
     void syncMethodCalled(int, const QString&);
     void requestMethodCalled(const QString&, int);
+    void intReceived(int);
+    void stringReceived(const QString&);
 
 private:
     int _intProperty{};
 
 private:
     int _intProperty{};
@@ -243,7 +292,12 @@ TEST_F(SignalProxyTest, syncableObject)
         EXPECT_CALL(*_serverPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("setStringProperty"), ElementsAre("World"))));
 
         // Request method
         EXPECT_CALL(*_serverPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("setStringProperty"), ElementsAre("World"))));
 
         // Request method
-        EXPECT_CALL(*_clientPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("requestMethod"), ElementsAre("Hello", 23))));
+        EXPECT_CALL(*_clientPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("requestInt"), ElementsAre("Hello", 23))));
+        EXPECT_CALL(*_serverPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("receiveInt"), ElementsAre("Hello", 23, -23))));
+        EXPECT_CALL(*_clientPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("setIntProperty"), ElementsAre(23))));
+
+        EXPECT_CALL(*_clientPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("requestString"), ElementsAre("Hello", 23))));
+        EXPECT_CALL(*_serverPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("receiveString"), ElementsAre("HELLO"))));
         EXPECT_CALL(*_clientPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("setStringProperty"), ElementsAre("Hello"))));
 
         // Update properties (twice)
         EXPECT_CALL(*_clientPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Foo"), Eq("setStringProperty"), ElementsAre("Hello"))));
 
         // Update properties (twice)
@@ -259,6 +313,10 @@ TEST_F(SignalProxyTest, syncableObject)
                                                              {"intProperty", 17},
                                                              {"doubleProperty", 2.3}
                                                          }))));
                                                              {"intProperty", 17},
                                                              {"doubleProperty", 2.3}
                                                          }))));
+
+        // Rename object
+        EXPECT_CALL(*_serverPeer, Dispatches(RpcCall(Eq("__objectRenamed__"), ElementsAre("SyncObj", "Bar", "Foo"))));
+        EXPECT_CALL(*_serverPeer, Dispatches(SyncMessage(Eq("SyncObj"), Eq("Bar"), Eq("setStringProperty"), ElementsAre("Hi Universe"))));
     }
 
     SignalSpy spy;
     }
 
     SignalSpy spy;
@@ -308,10 +366,17 @@ TEST_F(SignalProxyTest, syncableObject)
 
     // -- Request method
 
 
     // -- Request method
 
-    spy.connect(&serverObject, &SyncObj::requestMethodCalled);
-    clientObject.requestMethod("Hello", 23);
+    spy.connect(&clientObject, &SyncObj::intReceived);
+    clientObject.requestInt("Hello", 23);
+    ASSERT_TRUE(spy.wait());
+    EXPECT_EQ(23, serverObject.intProperty());
+    EXPECT_EQ(-23, clientObject.intProperty());
+
+    spy.connect(&clientObject, &SyncObj::stringReceived);
+    clientObject.requestString("Hello", 23);
     ASSERT_TRUE(spy.wait());
     EXPECT_EQ("Hello", serverObject.stringProperty());
     ASSERT_TRUE(spy.wait());
     EXPECT_EQ("Hello", serverObject.stringProperty());
+    EXPECT_EQ("HELLO", clientObject.stringProperty());
 
     // -- Property update
 
 
     // -- Property update
 
@@ -334,6 +399,14 @@ TEST_F(SignalProxyTest, syncableObject)
     EXPECT_EQ(17, clientObject.intProperty());
     EXPECT_EQ("Quassel", clientObject.stringProperty());
     EXPECT_EQ(2.3, clientObject.doubleProperty());
     EXPECT_EQ(17, clientObject.intProperty());
     EXPECT_EQ("Quassel", clientObject.stringProperty());
     EXPECT_EQ(2.3, clientObject.doubleProperty());
+
+    // -- Rename object
+    spy.connect(&clientObject, &SyncObj::stringPropertyChanged);
+    serverObject.setObjectName("Bar");
+    serverObject.setStringProperty("Hi Universe");
+    ASSERT_TRUE(spy.wait());
+    EXPECT_EQ("Bar", clientObject.objectName());
+    EXPECT_EQ("Hi Universe", clientObject.stringProperty());
 }
 
 #include "signalproxytest.moc"
 }
 
 #include "signalproxytest.moc"
Quassel IRC