1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// Copyright 2014 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Helper utilities to simplify testing of D-Bus object implementations.
// Since the method handlers could now be asynchronous, they use callbacks to
// provide method return values. This makes it really difficult to invoke
// such handlers in unit tests (even if they are actually synchronous but
// still use DBusMethodResponse to send back the method results).
// This file provide testing-only helpers to make calling D-Bus method handlers
// easier.
#ifndef LIBCHROMEOS_BRILLO_DBUS_DBUS_OBJECT_TEST_HELPERS_H_
#define LIBCHROMEOS_BRILLO_DBUS_DBUS_OBJECT_TEST_HELPERS_H_
#include <base/bind.h>
#include <base/memory/weak_ptr.h>
#include <brillo/dbus/dbus_method_invoker.h>
#include <brillo/dbus/dbus_object.h>
namespace brillo {
namespace dbus_utils {
// Helper friend class to call DBusInterface::HandleMethodCall() since it is
// a private method of the class and we don't want to make it public.
class DBusInterfaceTestHelper final {
public:
static void HandleMethodCall(DBusInterface* itf,
dbus::MethodCall* method_call,
ResponseSender sender) {
itf->HandleMethodCall(method_call, sender);
}
};
namespace testing {
// This is a simple class that has weak pointer semantics and holds an
// instance of D-Bus method call response message. We use this in tests
// to get the response in case the handler processes a method call request
// synchronously. Otherwise the ResponseHolder object will be destroyed and
// ResponseHolder::ReceiveResponse() will not be called since we bind the
// callback to the object instance via a weak pointer.
struct ResponseHolder final : public base::SupportsWeakPtr<ResponseHolder> {
void ReceiveResponse(scoped_ptr<dbus::Response> response) {
response_.reset(response.release());
}
std::unique_ptr<dbus::Response> response_;
};
// Dispatches a D-Bus method call to the corresponding handler.
// Used mostly for testing purposes. This method is inlined so that it is
// not included in the shipping code of libchromeos, and included at the
// call sites. Returns a response from the method handler or nullptr if the
// method hasn't provided the response message immediately
// (i.e. it is asynchronous).
inline std::unique_ptr<dbus::Response> CallMethod(
const DBusObject& object, dbus::MethodCall* method_call) {
DBusInterface* itf = object.FindInterface(method_call->GetInterface());
std::unique_ptr<dbus::Response> response;
if (!itf) {
response = CreateDBusErrorResponse(
method_call,
DBUS_ERROR_UNKNOWN_INTERFACE,
"Interface you invoked a method on isn't known by the object.");
} else {
ResponseHolder response_holder;
DBusInterfaceTestHelper::HandleMethodCall(
itf, method_call, base::Bind(&ResponseHolder::ReceiveResponse,
response_holder.AsWeakPtr()));
response = std::move(response_holder.response_);
}
return response;
}
// MethodHandlerInvoker is similar to CallMethod() function above, except
// it allows the callers to invoke the method handlers directly bypassing
// the DBusObject/DBusInterface infrastructure.
// This works only on synchronous methods though. The handler must reply
// before the handler exits.
template<typename RetType>
struct MethodHandlerInvoker {
// MethodHandlerInvoker<RetType>::Call() calls a member |method| of a class
// |instance| and passes the |args| to it. The method's return value provided
// via handler's DBusMethodResponse is then extracted and returned.
// If the method handler returns an error, the error information is passed
// to the caller via the |error| object (and the method returns a default
// value of type RetType as a placeholder).
// If the method handler asynchronous and did not provide a reply (success or
// error) before the handler exits, this method aborts with a CHECK().
template<class Class, typename... Params, typename... Args>
static RetType Call(
ErrorPtr* error,
Class* instance,
void(Class::*method)(std::unique_ptr<DBusMethodResponse<RetType>>,
Params...),
Args... args) {
ResponseHolder response_holder;
dbus::MethodCall method_call("test.interface", "TestMethod");
method_call.SetSerial(123);
std::unique_ptr<DBusMethodResponse<RetType>> method_response{
new DBusMethodResponse<RetType>(
&method_call, base::Bind(&ResponseHolder::ReceiveResponse,
response_holder.AsWeakPtr()))
};
(instance->*method)(std::move(method_response), args...);
CHECK(response_holder.response_.get())
<< "No response received. Asynchronous methods are not supported.";
RetType ret_val;
ExtractMethodCallResults(response_holder.response_.get(), error, &ret_val);
return ret_val;
}
};
// Specialization of MethodHandlerInvoker for methods that do not return
// values (void methods).
template<>
struct MethodHandlerInvoker<void> {
template<class Class, typename... Params, typename... Args>
static void Call(
ErrorPtr* error,
Class* instance,
void(Class::*method)(std::unique_ptr<DBusMethodResponse<>>, Params...),
Args... args) {
ResponseHolder response_holder;
dbus::MethodCall method_call("test.interface", "TestMethod");
method_call.SetSerial(123);
std::unique_ptr<DBusMethodResponse<>> method_response{
new DBusMethodResponse<>(&method_call,
base::Bind(&ResponseHolder::ReceiveResponse,
response_holder.AsWeakPtr()))
};
(instance->*method)(std::move(method_response), args...);
CHECK(response_holder.response_.get())
<< "No response received. Asynchronous methods are not supported.";
ExtractMethodCallResults(response_holder.response_.get(), error);
}
};
} // namespace testing
} // namespace dbus_utils
} // namespace brillo
#endif // LIBCHROMEOS_BRILLO_DBUS_DBUS_OBJECT_TEST_HELPERS_H_
|
