chromeos/dbus/blocking_method_caller_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 "chromeos/dbus/blocking_method_caller.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/task_runner.h"
  11 #include "dbus/message.h"
  12 #include "dbus/mock_bus.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
  22 namespace chromeos {
  23
  24 namespace {
  25
  26 class FakeTaskRunner : public base::TaskRunner {
  27  public:
  28   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
  29                                const base::Closure& task,
  30                                base::TimeDelta delay) OVERRIDE {
  31     task.Run();
  32     return true;
  33   }
  34   virtual bool RunsTasksOnCurrentThread() const OVERRIDE { return true; }
  35
  36  protected:
  37   virtual ~FakeTaskRunner() {}
  38 };
  39
  40 }  // namespace
  41
  42 class BlockingMethodCallerTest : public testing::Test {
  43  public:
  44   BlockingMethodCallerTest() : task_runner_(new FakeTaskRunner) {
  45   }
  46
  47   virtual void SetUp() {
  48     // Create a mock bus.
  49     dbus::Bus::Options options;
  50     options.bus_type = dbus::Bus::SYSTEM;
  51     mock_bus_ = new dbus::MockBus(options);
  52
  53     // Create a mock proxy.
  54     mock_proxy_ = new dbus::MockObjectProxy(
  55         mock_bus_.get(),
  56         "org.chromium.TestService",
  57         dbus::ObjectPath("/org/chromium/TestObject"));
  58
  59     // Set an expectation so mock_proxy's CallMethodAndBlock() will use
  60     // CreateMockProxyResponse() to return responses.
  61     EXPECT_CALL(*mock_proxy_.get(), MockCallMethodAndBlock(_, _))
  62         .WillRepeatedly(
  63              Invoke(this, &BlockingMethodCallerTest::CreateMockProxyResponse));
  64
  65     // Set an expectation so mock_bus's GetObjectProxy() for the given
  66     // service name and the object path will return mock_proxy_.
  67     EXPECT_CALL(*mock_bus_.get(),
  68                 GetObjectProxy("org.chromium.TestService",
  69                                dbus::ObjectPath("/org/chromium/TestObject")))
  70         .WillOnce(Return(mock_proxy_.get()));
  71
  72     // Set an expectation so mock_bus's GetDBusTaskRunner will return the fake
  73     // task runner.
  74     EXPECT_CALL(*mock_bus_.get(), GetDBusTaskRunner())
  75         .WillRepeatedly(Return(task_runner_));
  76
  77     // ShutdownAndBlock() will be called in TearDown().
  78     EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
  79   }
  80
  81   virtual void TearDown() {
  82     mock_bus_->ShutdownAndBlock();
  83   }
  84
  85  protected:
  86   scoped_refptr<FakeTaskRunner> task_runner_;
  87   scoped_refptr<dbus::MockBus> mock_bus_;
  88   scoped_refptr<dbus::MockObjectProxy> mock_proxy_;
  89
  90  private:
  91   // Returns a response for the given method call. Used to implement
  92   // CallMethodAndBlock() for |mock_proxy_|.
  93   dbus::Response* CreateMockProxyResponse(dbus::MethodCall* method_call,
  94                                           int timeout_ms) {
  95     if (method_call->GetInterface() == "org.chromium.TestInterface" &&
  96         method_call->GetMember() == "Echo") {
  97       dbus::MessageReader reader(method_call);
  98       std::string text_message;
  99       if (reader.PopString(&text_message)) {
 100         scoped_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
 101         dbus::MessageWriter writer(response.get());
 102         writer.AppendString(text_message);
 103         return response.release();
 104       }
 105     }
 106
 107     LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
 108     return NULL;
 109   }
 110 };
 111
 112 TEST_F(BlockingMethodCallerTest, Echo) {
 113   const char kHello[] = "Hello";
 114   // Get an object proxy from the mock bus.
 115   dbus::ObjectProxy* proxy = mock_bus_->GetObjectProxy(
 116       "org.chromium.TestService",
 117       dbus::ObjectPath("/org/chromium/TestObject"));
 118
 119   // Create a method call.
 120   dbus::MethodCall method_call("org.chromium.TestInterface", "Echo");
 121   dbus::MessageWriter writer(&method_call);
 122   writer.AppendString(kHello);
 123
 124   // Call the method.
 125   BlockingMethodCaller blocking_method_caller(mock_bus_.get(), proxy);
 126   scoped_ptr<dbus::Response> response(
 127       blocking_method_caller.CallMethodAndBlock(&method_call));
 128
 129   // Check the response.
 130   ASSERT_TRUE(response.get());
 131   dbus::MessageReader reader(response.get());
 132   std::string text_message;
 133   ASSERT_TRUE(reader.PopString(&text_message));
 134   // The text message should be echo'ed back.
 135   EXPECT_EQ(kHello, text_message);
 136 }
 137
 138 }  // namespace chromeos