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
18using ::testing::_;
19using ::testing::Invoke;
20using ::testing::Return;
21
22namespace chromeos {
23
24namespace {
25
26class 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
42class 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_.get()));
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
112TEST_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
139