• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "base/bind.h"
6 #include "base/logging.h"
7 #include "base/memory/ref_counted.h"
8 #include "base/memory/scoped_ptr.h"
9 #include "base/message_loop/message_loop.h"
10 #include "dbus/message.h"
11 #include "dbus/mock_bus.h"
12 #include "dbus/mock_exported_object.h"
13 #include "dbus/mock_object_proxy.h"
14 #include "dbus/object_path.h"
15 #include "testing/gmock/include/gmock/gmock.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 
18 using ::testing::_;
19 using ::testing::Invoke;
20 using ::testing::Return;
21 using ::testing::Unused;
22 
23 namespace dbus {
24 
25 class MockTest : public testing::Test {
26  public:
MockTest()27   MockTest() {
28   }
29 
SetUp()30   virtual void SetUp() {
31     // Create a mock bus.
32     Bus::Options options;
33     options.bus_type = Bus::SYSTEM;
34     mock_bus_ = new MockBus(options);
35 
36     // Create a mock proxy.
37     mock_proxy_ = new MockObjectProxy(
38         mock_bus_.get(),
39         "org.chromium.TestService",
40         ObjectPath("/org/chromium/TestObject"));
41 
42     // Set an expectation so mock_proxy's CallMethodAndBlock() will use
43     // CreateMockProxyResponse() to return responses.
44     EXPECT_CALL(*mock_proxy_.get(), MockCallMethodAndBlock(_, _))
45         .WillRepeatedly(Invoke(this, &MockTest::CreateMockProxyResponse));
46 
47     // Set an expectation so mock_proxy's CallMethod() will use
48     // HandleMockProxyResponseWithMessageLoop() to return responses.
49     EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _)).WillRepeatedly(
50         Invoke(this, &MockTest::HandleMockProxyResponseWithMessageLoop));
51 
52     // Set an expectation so mock_bus's GetObjectProxy() for the given
53     // service name and the object path will return mock_proxy_.
54     EXPECT_CALL(*mock_bus_.get(),
55                 GetObjectProxy("org.chromium.TestService",
56                                ObjectPath("/org/chromium/TestObject")))
57         .WillOnce(Return(mock_proxy_.get()));
58 
59     // ShutdownAndBlock() will be called in TearDown().
60     EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
61   }
62 
TearDown()63   virtual void TearDown() {
64     mock_bus_->ShutdownAndBlock();
65   }
66 
67   // Called when the response is received.
OnResponse(Response * response)68   void OnResponse(Response* response) {
69     // |response| will be deleted on exit of the function. Copy the
70     // payload to |response_string_|.
71     if (response) {
72       MessageReader reader(response);
73       ASSERT_TRUE(reader.PopString(&response_string_));
74     }
75     message_loop_.Quit();
76   };
77 
78  protected:
79   std::string response_string_;
80   base::MessageLoop message_loop_;
81   scoped_refptr<MockBus> mock_bus_;
82   scoped_refptr<MockObjectProxy> mock_proxy_;
83 
84  private:
85   // Returns a response for the given method call. Used to implement
86   // CallMethodAndBlock() for |mock_proxy_|.
CreateMockProxyResponse(MethodCall * method_call,int timeout_ms)87   Response* CreateMockProxyResponse(MethodCall* method_call,
88                                     int timeout_ms) {
89     if (method_call->GetInterface() == "org.chromium.TestInterface" &&
90         method_call->GetMember() == "Echo") {
91       MessageReader reader(method_call);
92       std::string text_message;
93       if (reader.PopString(&text_message)) {
94         scoped_ptr<Response> response = Response::CreateEmpty();
95         MessageWriter writer(response.get());
96         writer.AppendString(text_message);
97         return response.release();
98       }
99     }
100 
101     LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
102     return NULL;
103   }
104 
105   // Creates a response and runs the given response callback in the
106   // message loop with the response. Used to implement for |mock_proxy_|.
HandleMockProxyResponseWithMessageLoop(MethodCall * method_call,int timeout_ms,ObjectProxy::ResponseCallback response_callback)107   void HandleMockProxyResponseWithMessageLoop(
108       MethodCall* method_call,
109       int timeout_ms,
110       ObjectProxy::ResponseCallback response_callback) {
111     Response* response = CreateMockProxyResponse(method_call, timeout_ms);
112     message_loop_.PostTask(FROM_HERE,
113                            base::Bind(&MockTest::RunResponseCallback,
114                                       base::Unretained(this),
115                                       response_callback,
116                                       response));
117   }
118 
119   // Runs the given response callback with the given response.
RunResponseCallback(ObjectProxy::ResponseCallback response_callback,Response * response)120   void RunResponseCallback(
121       ObjectProxy::ResponseCallback response_callback,
122       Response* response) {
123     response_callback.Run(response);
124     delete response;
125   }
126 };
127 
128 // This test demonstrates how to mock a synchronos method call using the
129 // mock classes.
TEST_F(MockTest,CallMethodAndBlock)130 TEST_F(MockTest, CallMethodAndBlock) {
131   const char kHello[] = "Hello";
132   // Get an object proxy from the mock bus.
133   ObjectProxy* proxy = mock_bus_->GetObjectProxy(
134       "org.chromium.TestService",
135       ObjectPath("/org/chromium/TestObject"));
136 
137   // Create a method call.
138   MethodCall method_call("org.chromium.TestInterface", "Echo");
139   MessageWriter writer(&method_call);
140   writer.AppendString(kHello);
141 
142   // Call the method.
143   scoped_ptr<Response> response(
144       proxy->CallMethodAndBlock(&method_call,
145                                 ObjectProxy::TIMEOUT_USE_DEFAULT));
146 
147   // Check the response.
148   ASSERT_TRUE(response.get());
149   MessageReader reader(response.get());
150   std::string text_message;
151   ASSERT_TRUE(reader.PopString(&text_message));
152   // The text message should be echo'ed back.
153   EXPECT_EQ(kHello, text_message);
154 }
155 
156 // This test demonstrates how to mock an asynchronos method call using the
157 // mock classes.
TEST_F(MockTest,CallMethod)158 TEST_F(MockTest, CallMethod) {
159   const char kHello[] = "hello";
160 
161   // Get an object proxy from the mock bus.
162   ObjectProxy* proxy = mock_bus_->GetObjectProxy(
163       "org.chromium.TestService",
164       ObjectPath("/org/chromium/TestObject"));
165 
166   // Create a method call.
167   MethodCall method_call("org.chromium.TestInterface", "Echo");
168   MessageWriter writer(&method_call);
169   writer.AppendString(kHello);
170 
171   // Call the method.
172   proxy->CallMethod(&method_call,
173                     ObjectProxy::TIMEOUT_USE_DEFAULT,
174                     base::Bind(&MockTest::OnResponse,
175                                base::Unretained(this)));
176   // Run the message loop to let OnResponse be called.
177   message_loop_.Run();
178 
179   EXPECT_EQ(kHello, response_string_);
180 }
181 
182 }  // namespace dbus
183