1 files changed, 145 insertions, 0 deletions
diff --git a/brillo/dbus/dbus_signal_handler_unittest.cc b/brillo/dbus/dbus_signal_handler_unittest.cc
new file mode 100644
index 0000000..e0bea10
--- /dev/null
+++ b/brillo/dbus/dbus_signal_handler_unittest.cc
@@ -0,0 +1,145 @@
+// 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.
+
+#include <brillo/dbus/dbus_signal_handler.h>
+
+#include <string>
+
+#include <brillo/bind_lambda.h>
+#include <brillo/dbus/dbus_param_writer.h>
+#include <dbus/mock_bus.h>
+#include <dbus/mock_object_proxy.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using testing::AnyNumber;
+using testing::Return;
+using testing::SaveArg;
+using testing::_;
+
+namespace brillo {
+namespace dbus_utils {
+
+const char kTestPath[] = "/test/path";
+const char kTestServiceName[] = "org.test.Object";
+const char kInterface[] = "org.test.Object.TestInterface";
+const char kSignal[] = "TestSignal";
+
+class DBusSignalHandlerTest : public testing::Test {
+ public:
+  void SetUp() override {
+    dbus::Bus::Options options;
+    options.bus_type = dbus::Bus::SYSTEM;
+    bus_ = new dbus::MockBus(options);
+    // By default, don't worry about threading assertions.
+    EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
+    EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
+    // Use a mock object proxy.
+    mock_object_proxy_ = new dbus::MockObjectProxy(
+        bus_.get(), kTestServiceName, dbus::ObjectPath(kTestPath));
+    EXPECT_CALL(*bus_,
+                GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
+        .WillRepeatedly(Return(mock_object_proxy_.get()));
+  }
+
+  void TearDown() override { bus_ = nullptr; }
+
+ protected:
+  template<typename SignalHandlerSink, typename... Args>
+  void CallSignal(SignalHandlerSink* sink, Args... args) {
+    dbus::ObjectProxy::SignalCallback signal_callback;
+    EXPECT_CALL(*mock_object_proxy_, ConnectToSignal(kInterface, kSignal, _, _))
+        .WillOnce(SaveArg<2>(&signal_callback));
+
+    brillo::dbus_utils::ConnectToSignal(
+        mock_object_proxy_.get(),
+        kInterface,
+        kSignal,
+        base::Bind(&SignalHandlerSink::Handler, base::Unretained(sink)),
+        {});
+
+    dbus::Signal signal(kInterface, kSignal);
+    dbus::MessageWriter writer(&signal);
+    DBusParamWriter::Append(&writer, args...);
+    signal_callback.Run(&signal);
+  }
+
+  scoped_refptr<dbus::MockBus> bus_;
+  scoped_refptr<dbus::MockObjectProxy> mock_object_proxy_;
+};
+
+TEST_F(DBusSignalHandlerTest, ConnectToSignal) {
+  EXPECT_CALL(*mock_object_proxy_, ConnectToSignal(kInterface, kSignal, _, _))
+      .Times(1);
+
+  brillo::dbus_utils::ConnectToSignal(
+      mock_object_proxy_.get(), kInterface, kSignal, base::Closure{}, {});
+}
+
+TEST_F(DBusSignalHandlerTest, CallSignal_3Args) {
+  class SignalHandlerSink {
+   public:
+    MOCK_METHOD3(Handler, void(int, int, double));
+  } sink;
+
+  EXPECT_CALL(sink, Handler(10, 20, 30.5)).Times(1);
+  CallSignal(&sink, 10, 20, 30.5);
+}
+
+TEST_F(DBusSignalHandlerTest, CallSignal_2Args) {
+  class SignalHandlerSink {
+   public:
+    // Take string both by reference and by value to make sure this works too.
+    MOCK_METHOD2(Handler, void(const std::string&, std::string));
+  } sink;
+
+  EXPECT_CALL(sink, Handler(std::string{"foo"}, std::string{"bar"})).Times(1);
+  CallSignal(&sink, std::string{"foo"}, std::string{"bar"});
+}
+
+TEST_F(DBusSignalHandlerTest, CallSignal_NoArgs) {
+  class SignalHandlerSink {
+   public:
+    MOCK_METHOD0(Handler, void());
+  } sink;
+
+  EXPECT_CALL(sink, Handler()).Times(1);
+  CallSignal(&sink);
+}
+
+TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooManyArgs) {
+  class SignalHandlerSink {
+   public:
+    MOCK_METHOD0(Handler, void());
+  } sink;
+
+  // Handler() expects no args, but we send an int.
+  EXPECT_CALL(sink, Handler()).Times(0);
+  CallSignal(&sink, 5);
+}
+
+TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooFewArgs) {
+  class SignalHandlerSink {
+   public:
+    MOCK_METHOD2(Handler, void(std::string, bool));
+  } sink;
+
+  // Handler() expects 2 args while we send it just one.
+  EXPECT_CALL(sink, Handler(_, _)).Times(0);
+  CallSignal(&sink, std::string{"bar"});
+}
+
+TEST_F(DBusSignalHandlerTest, CallSignal_Error_TypeMismatchArgs) {
+  class SignalHandlerSink {
+   public:
+    MOCK_METHOD2(Handler, void(std::string, bool));
+  } sink;
+
+  // Handler() expects "sb" while we send it "ii".
+  EXPECT_CALL(sink, Handler(_, _)).Times(0);
+  CallSignal(&sink, 1, 2);
+}
+
+}  // namespace dbus_utils
+}  // namespace brillo