| // Copyright (c) 2012 The Chromium 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 "chromeos/dbus/modem_messaging_client.h" |
| |
| #include "base/bind.h" |
| #include "base/message_loop.h" |
| #include "base/values.h" |
| #include "dbus/message.h" |
| #include "dbus/mock_bus.h" |
| #include "dbus/mock_object_proxy.h" |
| #include "dbus/object_path.h" |
| #include "dbus/values_util.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/cros_system_api/dbus/service_constants.h" |
| |
| using ::testing::_; |
| using ::testing::Invoke; |
| using ::testing::Return; |
| |
| namespace chromeos { |
| |
| namespace { |
| |
| // A mock SmsReceivedHandler. |
| class MockSmsReceivedHandler { |
| public: |
| MOCK_METHOD2(Run, void(const dbus::ObjectPath &sms, bool complete)); |
| }; |
| |
| // A mock DeleteCallback. |
| class MockDeleteCallback { |
| public: |
| MOCK_METHOD0(Run, void()); |
| }; |
| |
| // A mock ListCallback. |
| class MockListCallback { |
| public: |
| MOCK_METHOD1(Run, void(const std::vector<dbus::ObjectPath>& result)); |
| }; |
| |
| // D-Bus service name used by test. |
| const char kServiceName[] = "service.name"; |
| // D-Bus object path used by test. |
| const char kObjectPath[] = "/object/path"; |
| |
| // Keys of SMS dictionary. |
| const char kNumberKey[] = "number"; |
| const char kTextKey[] = "text"; |
| |
| // Example values of SMS dictionary. |
| const char kExampleNumber[] = "00012345678"; |
| const char kExampleText[] = "Hello."; |
| |
| } // namespace |
| |
| class ModemMessagingClientTest : public testing::Test { |
| public: |
| ModemMessagingClientTest() : response_(NULL), |
| expected_result_(NULL) {} |
| |
| virtual void SetUp() OVERRIDE { |
| // Create a mock bus. |
| dbus::Bus::Options options; |
| options.bus_type = dbus::Bus::SYSTEM; |
| mock_bus_ = new dbus::MockBus(options); |
| |
| // Create a mock proxy. |
| mock_proxy_ = new dbus::MockObjectProxy(mock_bus_.get(), |
| kServiceName, |
| dbus::ObjectPath(kObjectPath)); |
| |
| // Set an expectation so mock_proxy's ConnectToSignal() will use |
| // OnConnectToSignal() to run the callback. |
| EXPECT_CALL(*mock_proxy_.get(), |
| ConnectToSignal(modemmanager::kModemManager1MessagingInterface, |
| modemmanager::kSMSAddedSignal, |
| _, |
| _)) |
| .WillRepeatedly( |
| Invoke(this, &ModemMessagingClientTest::OnConnectToSignal)); |
| |
| // Set an expectation so mock_bus's GetObjectProxy() for the given |
| // service name and the object path will return mock_proxy_. |
| EXPECT_CALL(*mock_bus_.get(), |
| GetObjectProxy(kServiceName, dbus::ObjectPath(kObjectPath))) |
| .WillOnce(Return(mock_proxy_.get())); |
| |
| // ShutdownAndBlock() will be called in TearDown(). |
| EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return()); |
| |
| // Create a client with the mock bus. |
| client_.reset(ModemMessagingClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION, |
| mock_bus_.get())); |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| mock_bus_->ShutdownAndBlock(); |
| } |
| |
| // Handles Delete method call. |
| void OnDelete(dbus::MethodCall* method_call, |
| int timeout_ms, |
| const dbus::ObjectProxy::ResponseCallback& callback) { |
| EXPECT_EQ(modemmanager::kModemManager1MessagingInterface, |
| method_call->GetInterface()); |
| EXPECT_EQ(modemmanager::kSMSDeleteFunction, method_call->GetMember()); |
| dbus::ObjectPath sms_path; |
| dbus::MessageReader reader(method_call); |
| EXPECT_TRUE(reader.PopObjectPath(&sms_path)); |
| EXPECT_EQ(expected_sms_path_, sms_path); |
| EXPECT_FALSE(reader.HasMoreData()); |
| |
| message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_)); |
| } |
| |
| // Handles List method call. |
| void OnList(dbus::MethodCall* method_call, |
| int timeout_ms, |
| const dbus::ObjectProxy::ResponseCallback& callback) { |
| EXPECT_EQ(modemmanager::kModemManager1MessagingInterface, |
| method_call->GetInterface()); |
| EXPECT_EQ(modemmanager::kSMSListFunction, method_call->GetMember()); |
| dbus::MessageReader reader(method_call); |
| EXPECT_FALSE(reader.HasMoreData()); |
| |
| message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_)); |
| } |
| |
| // Checks the results of List. |
| void CheckResult(const std::vector<dbus::ObjectPath>& result) { |
| EXPECT_EQ(result, *expected_result_); |
| } |
| |
| protected: |
| // The client to be tested. |
| scoped_ptr<ModemMessagingClient> client_; |
| // A message loop to emulate asynchronous behavior. |
| base::MessageLoop message_loop_; |
| // The mock bus. |
| scoped_refptr<dbus::MockBus> mock_bus_; |
| // The mock object proxy. |
| scoped_refptr<dbus::MockObjectProxy> mock_proxy_; |
| // The SmsReceived signal handler given by the tested client. |
| dbus::ObjectProxy::SignalCallback sms_received_callback_; |
| // Expected argument for Delete method. |
| dbus::ObjectPath expected_sms_path_; |
| // Response returned by mock methods. |
| dbus::Response* response_; |
| // Expected result of List method. |
| std::vector<dbus::ObjectPath>* expected_result_; |
| |
| private: |
| // Used to implement the mock proxy. |
| void OnConnectToSignal( |
| const std::string& interface_name, |
| const std::string& signal_name, |
| const dbus::ObjectProxy::SignalCallback& signal_callback, |
| const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) { |
| sms_received_callback_ = signal_callback; |
| const bool success = true; |
| message_loop_.PostTask(FROM_HERE, base::Bind(on_connected_callback, |
| interface_name, |
| signal_name, |
| success)); |
| } |
| }; |
| |
| TEST_F(ModemMessagingClientTest, SmsReceived) { |
| // Set expectations. |
| const dbus::ObjectPath kSmsPath("/SMS/0"); |
| const bool kComplete = true; |
| MockSmsReceivedHandler handler; |
| EXPECT_CALL(handler, Run(kSmsPath, kComplete)).Times(1); |
| // Set handler. |
| client_->SetSmsReceivedHandler(kServiceName, dbus::ObjectPath(kObjectPath), |
| base::Bind(&MockSmsReceivedHandler::Run, |
| base::Unretained(&handler))); |
| |
| // Run the message loop to run the signal connection result callback. |
| message_loop_.RunUntilIdle(); |
| |
| // Send signal. |
| dbus::Signal signal(modemmanager::kModemManager1MessagingInterface, |
| modemmanager::kSMSAddedSignal); |
| dbus::MessageWriter writer(&signal); |
| writer.AppendObjectPath(kSmsPath); |
| writer.AppendBool(kComplete); |
| ASSERT_FALSE(sms_received_callback_.is_null()); |
| sms_received_callback_.Run(&signal); |
| // Reset handler. |
| client_->ResetSmsReceivedHandler(kServiceName, dbus::ObjectPath(kObjectPath)); |
| // Send signal again. |
| sms_received_callback_.Run(&signal); |
| } |
| |
| TEST_F(ModemMessagingClientTest, Delete) { |
| // Set expectations. |
| const dbus::ObjectPath kSmsPath("/SMS/0"); |
| expected_sms_path_ = kSmsPath; |
| EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _)) |
| .WillOnce(Invoke(this, &ModemMessagingClientTest::OnDelete)); |
| MockDeleteCallback callback; |
| EXPECT_CALL(callback, Run()).Times(1); |
| // Create response. |
| scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); |
| response_ = response.get(); |
| // Call Delete. |
| client_->Delete(kServiceName, dbus::ObjectPath(kObjectPath), kSmsPath, |
| base::Bind(&MockDeleteCallback::Run, |
| base::Unretained(&callback))); |
| |
| // Run the message loop. |
| message_loop_.RunUntilIdle(); |
| } |
| |
| TEST_F(ModemMessagingClientTest, List) { |
| // Set expectations. |
| EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _)) |
| .WillOnce(Invoke(this, &ModemMessagingClientTest::OnList)); |
| MockListCallback callback; |
| EXPECT_CALL(callback, Run(_)) |
| .WillOnce(Invoke(this, &ModemMessagingClientTest::CheckResult)); |
| // Create response. |
| scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); |
| dbus::ObjectPath path1("/SMS/1"); |
| dbus::ObjectPath path2("/SMS/2"); |
| std::vector<dbus::ObjectPath> expected_result; |
| expected_result.push_back(path1); |
| expected_result.push_back(path2); |
| |
| dbus::MessageWriter writer(response.get()); |
| writer.AppendArrayOfObjectPaths(expected_result); |
| response_ = response.get(); |
| |
| // Save expected result. |
| expected_result_ = &expected_result; |
| // Call List. |
| client_->List(kServiceName, dbus::ObjectPath(kObjectPath), |
| base::Bind(&MockListCallback::Run, |
| base::Unretained(&callback))); |
| |
| // Run the message loop. |
| message_loop_.RunUntilIdle(); |
| } |
| |
| } // namespace chromeos |