← Back to branch summary

~unity-api-team/libqtdbusmock/new-nm-methods

« back to all changes in this revision

Viewing changes to tests/libqtdbusmock/TestDBusMock.cpp

  • Committer: Pete Woods
  • Date: 2013-08-13 17:42:30 UTC
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: pete.woods@canonical.com-20130813174230-fn3zplof05p7wz6m
More tests, and fix cutom mock bug

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/libqtdbusmock/TestDBusMock.cpp
18
18
 
19
19
#include <libqtdbusmock/DBusMock.h>
20
20
#include <QCoreApplication>
 
21
#include <NetworkManager.h>
21
22
 
22
23
#include <gmock/gmock.h>
23
24
#include <gtest/gtest.h>
31
32
 
32
33
class TestDBusMock: public Test {
33
34
protected:
34
 
        TestDBusMock() :
35
 
                        dbusMock(dbusTestRunner) {
36
 
        }
37
 
 
38
 
        virtual ~TestDBusMock() {
39
 
        }
40
 
 
41
 
        bool processListContains(const char *str) {
42
 
                QProcess pgrep;
43
 
                pgrep.start("ps",
44
 
                                QStringList() << "--no-headers" << "--ppid"
45
 
                                                << QString::number(QCoreApplication::applicationPid())
46
 
                                                << "-o" << "args");
47
 
                pgrep.waitForFinished();
48
 
                pgrep.waitForReadyRead();
49
 
 
50
 
                return pgrep.readAll().contains(str);
51
 
        }
52
 
 
53
 
        DBusTestRunner dbusTestRunner;
54
 
 
55
 
        DBusMock dbusMock;
 
35
        TestDBusMock() :
 
36
                        dbusMock(dbusTestRunner) {
 
37
        }
 
38
 
 
39
        virtual ~TestDBusMock() {
 
40
        }
 
41
 
 
42
        bool processListContains(const char *str) {
 
43
                QProcess pgrep;
 
44
                pgrep.start("ps",
 
45
                                QStringList() << "--no-headers" << "--ppid"
 
46
                                                << QString::number(QCoreApplication::applicationPid())
 
47
                                                << "-o" << "args");
 
48
                pgrep.waitForFinished();
 
49
                pgrep.waitForReadyRead();
 
50
 
 
51
                return pgrep.readAll().contains(str);
 
52
        }
 
53
 
 
54
        DBusTestRunner dbusTestRunner;
 
55
 
 
56
        DBusMock dbusMock;
56
57
};
57
58
 
58
59
TEST_F(TestDBusMock, StartsDBusMockSession) {
59
 
        dbusMock.registerCustomMock("test.name", "/test/object", "test.Interface",
60
 
                        QDBusConnection::SessionBus);
61
 
        dbusTestRunner.startServices();
 
60
        dbusMock.registerCustomMock("test.name", "/test/object", "test.Interface",
 
61
                        QDBusConnection::SessionBus);
 
62
        dbusTestRunner.startServices();
62
63
 
63
 
        EXPECT_TRUE(
64
 
                        processListContains(
65
 
                                        "python3 -m dbusmock test.name /test/object test.Interface"));
 
64
        EXPECT_TRUE(
 
65
                        processListContains(
 
66
                                        "python3 -m dbusmock test.name /test/object test.Interface"));
66
67
}
67
68
 
68
69
TEST_F(TestDBusMock, StartsDBusMockSystem) {
69
 
        dbusMock.registerCustomMock("test.name2", "/test/object2",
70
 
                        "test.Interface2", QDBusConnection::SystemBus);
71
 
        dbusTestRunner.startServices();
 
70
        dbusMock.registerCustomMock("test.name2", "/test/object2",
 
71
                        "test.Interface2", QDBusConnection::SystemBus);
 
72
        dbusTestRunner.startServices();
72
73
 
73
 
        EXPECT_TRUE(
74
 
                        processListContains(
75
 
                                        "python3 -m dbusmock -s test.name2 /test/object2 test.Interface2"));
 
74
        EXPECT_TRUE(
 
75
                        processListContains(
 
76
                                        "python3 -m dbusmock -s test.name2 /test/object2 test.Interface2"));
76
77
}
77
78
 
78
79
TEST_F(TestDBusMock, StartsDBusMockWithTemplate) {
79
 
        dbusMock.registerNetworkManager();
80
 
        dbusTestRunner.startServices();
81
 
 
82
 
        EXPECT_TRUE(
83
 
                        processListContains(
84
 
                                        "python3 -m dbusmock --template networkmanager"));
 
80
        dbusMock.registerNetworkManager();
 
81
        dbusTestRunner.startServices();
 
82
 
 
83
        EXPECT_TRUE(
 
84
                        processListContains(
 
85
                                        "python3 -m dbusmock --template networkmanager"));
 
86
 
 
87
        NetworkManagerMockInterface &networkManager(
 
88
                        dbusMock.networkManagerInterface());
 
89
        networkManager.AddWiFiDevice("device", "eth1", NM_STATE_DISCONNECTED).waitForFinished();
 
90
 
 
91
//      OrgFreedesktopDBusMockInterface &networkManagerMock(
 
92
//                      dbusMock.mockInterface(NM_DBUS_SERVICE, NM_DBUS_PATH,
 
93
//                                      NM_DBUS_INTERFACE, QDBusConnection::SystemBus));
 
94
//      QList<MethodCall> methodCalls(
 
95
//                      networkManagerMock.GetMethodCalls("AddWiFiDevice"));
 
96
 
 
97
//      ASSERT_EQ(1, methodCalls.size());
 
98
//      ASSERT_EQ(3, methodCalls.first().args().size());
 
99
}
 
100
 
 
101
TEST_F(TestDBusMock, GetMethodCalls) {
 
102
        dbusMock.registerCustomMock("test.name", "/test/path", "test.interface",
 
103
                        QDBusConnection::SessionBus);
 
104
        dbusTestRunner.startServices();
 
105
 
 
106
        OrgFreedesktopDBusMockInterface &mockInterface(
 
107
                        dbusMock.mockInterface("test.name", "/test/path", "test.interface",
 
108
                                        QDBusConnection::SessionBus));
 
109
        mockInterface.AddMethod("test.interface", "MethodName", "s", "s",
 
110
                        "ret = 'output'").waitForFinished();
 
111
 
 
112
        QDBusMessage message(
 
113
                        QDBusMessage::createMethodCall("test.name", "/test/path",
 
114
                                        "test.interface", "MethodName"));
 
115
        message.setArguments(QVariantList() << QVariant("input"));
 
116
        QDBusMessage reply(dbusTestRunner.sessionConnection().call(message));
 
117
        ASSERT_EQ(1, reply.arguments().size());
 
118
        EXPECT_EQ("output", reply.arguments().first().toString().toStdString());
 
119
 
 
120
        QList<MethodCall> methodCalls(mockInterface.GetMethodCalls("MethodName"));
 
121
        ASSERT_EQ(1, methodCalls.size());
 
122
        MethodCall call;
 
123
        call = methodCalls.first();
 
124
        ASSERT_EQ(1, call.args().size());
 
125
        EXPECT_EQ("input", call.args().first().toString().toStdString());
 
126
}
 
127
 
 
128
TEST_F(TestDBusMock, GetAllMethodCalls) {
 
129
        dbusMock.registerCustomMock("test.name", "/test/path", "test.interface",
 
130
                        QDBusConnection::SessionBus);
 
131
        dbusTestRunner.startServices();
 
132
 
 
133
        OrgFreedesktopDBusMockInterface &mockInterface(
 
134
                        dbusMock.mockInterface("test.name", "/test/path", "test.interface",
 
135
                                        QDBusConnection::SessionBus));
 
136
        mockInterface.AddMethod("test.interface", "MethodName", "s", "s",
 
137
                        "ret = 'output'").waitForFinished();
 
138
 
 
139
        QDBusMessage message(
 
140
                        QDBusMessage::createMethodCall("test.name", "/test/path",
 
141
                                        "test.interface", "MethodName"));
 
142
        message.setArguments(QVariantList() << QVariant("input"));
 
143
        QDBusMessage reply(dbusTestRunner.sessionConnection().call(message));
 
144
        ASSERT_EQ(1, reply.arguments().size());
 
145
        EXPECT_EQ("output", reply.arguments().first().toString().toStdString());
 
146
 
 
147
        QList<NamedMethodCall> methodCalls(mockInterface.GetCalls());
 
148
        ASSERT_EQ(1, methodCalls.size());
 
149
        NamedMethodCall call;
 
150
        call = methodCalls.first();
 
151
        EXPECT_EQ("MethodName", call.methodName().toStdString());
 
152
        ASSERT_EQ(1, call.args().size());
 
153
        EXPECT_EQ("input", call.args().first().toString().toStdString());
 
154
}
 
155
 
 
156
TEST_F(TestDBusMock, AddMethods) {
 
157
        dbusMock.registerCustomMock("test.name", "/test/path", "test.interface",
 
158
                        QDBusConnection::SessionBus);
 
159
        dbusTestRunner.startServices();
 
160
 
 
161
        OrgFreedesktopDBusMockInterface &mockInterface(
 
162
                        dbusMock.mockInterface("test.name", "/test/path", "test.interface",
 
163
                                        QDBusConnection::SessionBus));
 
164
 
 
165
        Method method1;
 
166
        method1.setName("MethodName1");
 
167
        method1.setInSig("s");
 
168
        method1.setOutSig("s");
 
169
        method1.setCode("ret = 'output1'");
 
170
 
 
171
        Method methodTemp;
 
172
        methodTemp.setName("MethodName2");
 
173
        methodTemp.setInSig("u");
 
174
        methodTemp.setOutSig("s");
 
175
        methodTemp.setCode("ret = 'output2'");
 
176
 
 
177
        Method method2;
 
178
        method2 = methodTemp;
 
179
 
 
180
        mockInterface.AddMethods("test.interface",
 
181
                        QList<Method>() << method1 << method2).waitForFinished();
 
182
 
 
183
        {
 
184
                QDBusMessage message(
 
185
                                QDBusMessage::createMethodCall("test.name", "/test/path",
 
186
                                                "test.interface", "MethodName1"));
 
187
                message.setArguments(QVariantList() << QVariant("input"));
 
188
                QDBusMessage reply(dbusTestRunner.sessionConnection().call(message));
 
189
                ASSERT_EQ(1, reply.arguments().size());
 
190
                EXPECT_EQ("output1",
 
191
                                reply.arguments().first().toString().toStdString());
 
192
        }
 
193
 
 
194
        {
 
195
                QDBusMessage message(
 
196
                                QDBusMessage::createMethodCall("test.name", "/test/path",
 
197
                                                "test.interface", "MethodName2"));
 
198
                message.setArguments(QVariantList() << QVariant(123));
 
199
                QDBusMessage reply(dbusTestRunner.sessionConnection().call(message));
 
200
                ASSERT_EQ(1, reply.arguments().size());
 
201
                EXPECT_EQ("output2",
 
202
                                reply.arguments().first().toString().toStdString());
 
203
        }
 
204
 
 
205
        QList<NamedMethodCall> methodCalls(mockInterface.GetCalls());
 
206
        ASSERT_EQ(2, methodCalls.size());
 
207
        {
 
208
                NamedMethodCall call;
 
209
                call = methodCalls.first();
 
210
                EXPECT_EQ("MethodName1", call.methodName().toStdString());
 
211
                ASSERT_EQ(1, call.args().size());
 
212
                EXPECT_EQ("input", call.args().first().toString().toStdString());
 
213
        }
 
214
        {
 
215
                NamedMethodCall call;
 
216
                call = methodCalls[1];
 
217
                EXPECT_EQ("MethodName2", call.methodName().toStdString());
 
218
                ASSERT_EQ(1, call.args().size());
 
219
                EXPECT_EQ(123, call.args().first().toUInt());
 
220
        }
85
221
}
86
222
 
87
223
} // namespace