This source file includes following definitions.
- expected_result_
- SetUp
- TearDown
- OnDelete
- OnGet
- OnList
- CheckResult
- OnConnectToSignal
- TEST_F
- TEST_F
- TEST_F
- TEST_F
#include "chromeos/dbus/gsm_sms_client.h"
#include "base/bind.h"
#include "base/message_loop/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 {
class MockSmsReceivedHandler {
public:
MOCK_METHOD2(Run, void(uint32 index, bool complete));
};
class MockDeleteCallback {
public:
MOCK_METHOD0(Run, void());
};
class MockGetCallback {
public:
MOCK_METHOD1(Run, void(const base::DictionaryValue& sms));
};
class MockListCallback {
public:
MOCK_METHOD1(Run, void(const base::ListValue& result));
};
const char kServiceName[] = "service.name";
const char kObjectPath[] = "/object/path";
const char kNumberKey[] = "number";
const char kTextKey[] = "text";
const char kExampleNumber[] = "00012345678";
const char kExampleText[] = "Hello.";
}
class GsmSMSClientTest : public testing::Test {
public:
GsmSMSClientTest() : expected_index_(0),
response_(NULL),
expected_result_(NULL) {}
virtual void SetUp() OVERRIDE {
dbus::Bus::Options options;
options.bus_type = dbus::Bus::SYSTEM;
mock_bus_ = new dbus::MockBus(options);
mock_proxy_ = new dbus::MockObjectProxy(mock_bus_.get(),
kServiceName,
dbus::ObjectPath(kObjectPath));
EXPECT_CALL(*mock_proxy_.get(),
ConnectToSignal(modemmanager::kModemManagerSMSInterface,
modemmanager::kSMSReceivedSignal,
_,
_))
.WillRepeatedly(Invoke(this, &GsmSMSClientTest::OnConnectToSignal));
EXPECT_CALL(*mock_bus_.get(),
GetObjectProxy(kServiceName, dbus::ObjectPath(kObjectPath)))
.WillOnce(Return(mock_proxy_.get()));
EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
client_.reset(GsmSMSClient::Create());
client_->Init(mock_bus_.get());
}
virtual void TearDown() OVERRIDE {
mock_bus_->ShutdownAndBlock();
}
void OnDelete(dbus::MethodCall* method_call,
int timeout_ms,
const dbus::ObjectProxy::ResponseCallback& callback) {
EXPECT_EQ(modemmanager::kModemManagerSMSInterface,
method_call->GetInterface());
EXPECT_EQ(modemmanager::kSMSDeleteFunction, method_call->GetMember());
uint32 index = 0;
dbus::MessageReader reader(method_call);
EXPECT_TRUE(reader.PopUint32(&index));
EXPECT_EQ(expected_index_, index);
EXPECT_FALSE(reader.HasMoreData());
message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
}
void OnGet(dbus::MethodCall* method_call,
int timeout_ms,
const dbus::ObjectProxy::ResponseCallback& callback) {
EXPECT_EQ(modemmanager::kModemManagerSMSInterface,
method_call->GetInterface());
EXPECT_EQ(modemmanager::kSMSGetFunction, method_call->GetMember());
uint32 index = 0;
dbus::MessageReader reader(method_call);
EXPECT_TRUE(reader.PopUint32(&index));
EXPECT_EQ(expected_index_, index);
EXPECT_FALSE(reader.HasMoreData());
message_loop_.PostTask(FROM_HERE, base::Bind(callback, response_));
}
void OnList(dbus::MethodCall* method_call,
int timeout_ms,
const dbus::ObjectProxy::ResponseCallback& callback) {
EXPECT_EQ(modemmanager::kModemManagerSMSInterface,
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_));
}
void CheckResult(const base::Value& result) {
EXPECT_TRUE(result.Equals(expected_result_));
}
protected:
scoped_ptr<GsmSMSClient> client_;
base::MessageLoop message_loop_;
scoped_refptr<dbus::MockBus> mock_bus_;
scoped_refptr<dbus::MockObjectProxy> mock_proxy_;
dbus::ObjectProxy::SignalCallback sms_received_callback_;
uint32 expected_index_;
dbus::Response* response_;
base::Value* expected_result_;
private:
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(GsmSMSClientTest, SmsReceived) {
const uint32 kIndex = 42;
const bool kComplete = true;
MockSmsReceivedHandler handler;
EXPECT_CALL(handler, Run(kIndex, kComplete)).Times(1);
client_->SetSmsReceivedHandler(kServiceName, dbus::ObjectPath(kObjectPath),
base::Bind(&MockSmsReceivedHandler::Run,
base::Unretained(&handler)));
message_loop_.RunUntilIdle();
dbus::Signal signal(modemmanager::kModemManagerSMSInterface,
modemmanager::kSMSReceivedSignal);
dbus::MessageWriter writer(&signal);
writer.AppendUint32(kIndex);
writer.AppendBool(kComplete);
ASSERT_FALSE(sms_received_callback_.is_null());
sms_received_callback_.Run(&signal);
client_->ResetSmsReceivedHandler(kServiceName, dbus::ObjectPath(kObjectPath));
sms_received_callback_.Run(&signal);
}
TEST_F(GsmSMSClientTest, Delete) {
const uint32 kIndex = 42;
expected_index_ = kIndex;
EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _))
.WillOnce(Invoke(this, &GsmSMSClientTest::OnDelete));
MockDeleteCallback callback;
EXPECT_CALL(callback, Run()).Times(1);
scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
response_ = response.get();
client_->Delete(kServiceName, dbus::ObjectPath(kObjectPath), kIndex,
base::Bind(&MockDeleteCallback::Run,
base::Unretained(&callback)));
message_loop_.RunUntilIdle();
}
TEST_F(GsmSMSClientTest, Get) {
const uint32 kIndex = 42;
expected_index_ = kIndex;
EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _))
.WillOnce(Invoke(this, &GsmSMSClientTest::OnGet));
MockGetCallback callback;
EXPECT_CALL(callback, Run(_))
.WillOnce(Invoke(this, &GsmSMSClientTest::CheckResult));
scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
dbus::MessageWriter writer(response.get());
dbus::MessageWriter array_writer(NULL);
writer.OpenArray("{sv}", &array_writer);
dbus::MessageWriter entry_writer(NULL);
array_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(kNumberKey);
entry_writer.AppendVariantOfString(kExampleNumber);
array_writer.CloseContainer(&entry_writer);
array_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(kTextKey);
entry_writer.AppendVariantOfString(kExampleText);
array_writer.CloseContainer(&entry_writer);
writer.CloseContainer(&array_writer);
response_ = response.get();
base::DictionaryValue expected_result;
expected_result.SetWithoutPathExpansion(
kNumberKey, base::Value::CreateStringValue(kExampleNumber));
expected_result.SetWithoutPathExpansion(
kTextKey, base::Value::CreateStringValue(kExampleText));
expected_result_ = &expected_result;
client_->Get(kServiceName, dbus::ObjectPath(kObjectPath), kIndex,
base::Bind(&MockGetCallback::Run, base::Unretained(&callback)));
message_loop_.RunUntilIdle();
}
TEST_F(GsmSMSClientTest, List) {
EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _))
.WillOnce(Invoke(this, &GsmSMSClientTest::OnList));
MockListCallback callback;
EXPECT_CALL(callback, Run(_))
.WillOnce(Invoke(this, &GsmSMSClientTest::CheckResult));
scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
dbus::MessageWriter writer(response.get());
dbus::MessageWriter array_writer(NULL);
writer.OpenArray("a{sv}", &array_writer);
dbus::MessageWriter sub_array_writer(NULL);
array_writer.OpenArray("{sv}", &sub_array_writer);
dbus::MessageWriter entry_writer(NULL);
sub_array_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(kNumberKey);
entry_writer.AppendVariantOfString(kExampleNumber);
sub_array_writer.CloseContainer(&entry_writer);
sub_array_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(kTextKey);
entry_writer.AppendVariantOfString(kExampleText);
sub_array_writer.CloseContainer(&entry_writer);
array_writer.CloseContainer(&sub_array_writer);
writer.CloseContainer(&array_writer);
response_ = response.get();
base::ListValue expected_result;
base::DictionaryValue* sms = new base::DictionaryValue;
sms->SetWithoutPathExpansion(
kNumberKey, base::Value::CreateStringValue(kExampleNumber));
sms->SetWithoutPathExpansion(
kTextKey, base::Value::CreateStringValue(kExampleText));
expected_result.Append(sms);
expected_result_ = &expected_result;
client_->List(kServiceName, dbus::ObjectPath(kObjectPath),
base::Bind(&MockListCallback::Run,
base::Unretained(&callback)));
message_loop_.RunUntilIdle();
}
}