dbus/mock_unittest.cc

   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:
  27   MockTest() {
  28   }
  29
  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
  63   virtual void TearDown() {
  64     mock_bus_->ShutdownAndBlock();
  65   }
  66
  67   // Called when the response is received.
  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_|.
  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_|.
 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.
 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.
 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.
 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