| // Copyright (c) 2010 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 <base/logging.h> |
| #include <gtest/gtest.h> |
| #include <string> |
| |
| #include "update_engine/flimflam_proxy.h" |
| #include "update_engine/mock_dbus_interface.h" |
| |
| using ::testing::_; |
| using ::testing::AnyNumber; |
| using ::testing::Return; |
| using ::testing::SetArgumentPointee; |
| using ::testing::StrEq; |
| |
| namespace chromeos_update_engine { |
| |
| template<typename T, void F(T)> |
| class ScopedRelease { |
| public: |
| ScopedRelease(T obj) : obj_(obj) {} |
| ~ScopedRelease() { |
| F(obj_); |
| } |
| |
| private: |
| T obj_; |
| }; |
| |
| class FlimFlamProxyTest : public ::testing::Test { |
| public: |
| FlimFlamProxyTest() |
| : kMockFlimFlamManagerProxy_(NULL), |
| kMockFlimFlamServiceProxy_(NULL), |
| kServicePath_(NULL) {} |
| |
| protected: |
| void SetupMocks(const char* service_path); |
| void SetManagerReply(gconstpointer value, const GType& type); |
| void SetServiceReply(const char* service_type); |
| void TestWithServiceType( |
| const char* service_type, NetworkConnectionType expected_type); |
| |
| static const char* kGetPropertiesMethod; |
| DBusGProxy* kMockFlimFlamManagerProxy_; |
| DBusGProxy* kMockFlimFlamServiceProxy_; |
| DBusGConnection* kMockSystemBus_; |
| const char* kServicePath_; |
| MockDbusGlib dbus_iface_; |
| }; |
| |
| // static |
| const char* FlimFlamProxyTest::kGetPropertiesMethod = "GetProperties"; |
| |
| void FlimFlamProxyTest::SetupMocks(const char *service_path) { |
| int number = 1; |
| kMockSystemBus_ = reinterpret_cast<DBusGConnection*>(number++); |
| kMockFlimFlamManagerProxy_ = reinterpret_cast<DBusGProxy*>(number++); |
| kMockFlimFlamServiceProxy_ = reinterpret_cast<DBusGProxy*>(number++); |
| ASSERT_NE(kMockSystemBus_, reinterpret_cast<DBusGConnection*>(NULL)); |
| |
| kServicePath_ = service_path; |
| |
| ON_CALL(dbus_iface_, BusGet(DBUS_BUS_SYSTEM, _)) |
| .WillByDefault(Return(kMockSystemBus_)); |
| EXPECT_CALL(dbus_iface_, BusGet(DBUS_BUS_SYSTEM, _)) |
| .Times(AnyNumber()); |
| } |
| |
| void FlimFlamProxyTest::SetManagerReply(gconstpointer reply_value, |
| const GType &reply_type) { |
| // Initialize return value for D-Bus call to Manager object. |
| GHashTable* manager_hash_table = g_hash_table_new(g_str_hash, g_str_equal); |
| |
| GArray* array = g_array_new(FALSE, FALSE, sizeof(const char *)); |
| ASSERT_TRUE(array != NULL); |
| |
| EXPECT_EQ(array, g_array_append_val(array, reply_value)); |
| GValue* array_as_value = g_new0(GValue, 1); |
| EXPECT_EQ(array_as_value, |
| g_value_init(array_as_value, reply_type)); |
| g_value_take_boxed(array_as_value, array); |
| g_hash_table_insert(manager_hash_table, |
| const_cast<char*>("Services"), |
| array_as_value); |
| |
| // Plumb return value into mock object. |
| EXPECT_CALL(dbus_iface_, ProxyCall(kMockFlimFlamManagerProxy_, |
| StrEq(kGetPropertiesMethod), |
| _, |
| G_TYPE_INVALID, |
| dbus_g_type_get_map("GHashTable", |
| G_TYPE_STRING, |
| G_TYPE_VALUE), |
| _, |
| G_TYPE_INVALID)) |
| .WillOnce(DoAll(SetArgumentPointee<5>(manager_hash_table), Return(TRUE))); |
| |
| // Set other expectations. |
| EXPECT_CALL(dbus_iface_, |
| ProxyNewForNameOwner(kMockSystemBus_, |
| StrEq(kFlimFlamDbusService), |
| StrEq(kFlimFlamDbusManagerPath), |
| StrEq(kFlimFlamDbusManagerInterface), |
| _)) |
| .WillOnce(Return(kMockFlimFlamManagerProxy_)); |
| EXPECT_CALL(dbus_iface_, ProxyUnref(kMockFlimFlamManagerProxy_)); |
| EXPECT_CALL(dbus_iface_, BusGet(DBUS_BUS_SYSTEM, _)) |
| .RetiresOnSaturation(); |
| } |
| |
| void FlimFlamProxyTest::SetServiceReply(const char *service_type) { |
| // Initialize return value for D-Bus call to Service object. |
| GHashTable* service_hash_table = g_hash_table_new(g_str_hash, g_str_equal); |
| |
| GValue* service_type_value = g_new0(GValue, 1); |
| EXPECT_EQ(service_type_value, |
| g_value_init(service_type_value, G_TYPE_STRING)); |
| g_value_set_static_string(service_type_value, service_type); |
| |
| g_hash_table_insert(service_hash_table, |
| const_cast<char*>("Type"), |
| service_type_value); |
| |
| // Plumb return value into mock object. |
| EXPECT_CALL(dbus_iface_, ProxyCall(kMockFlimFlamServiceProxy_, |
| StrEq(kGetPropertiesMethod), |
| _, |
| G_TYPE_INVALID, |
| dbus_g_type_get_map("GHashTable", |
| G_TYPE_STRING, |
| G_TYPE_VALUE), |
| _, |
| G_TYPE_INVALID)) |
| .WillOnce(DoAll(SetArgumentPointee<5>(service_hash_table), Return(TRUE))); |
| |
| // Set other expectations. |
| EXPECT_CALL(dbus_iface_, |
| ProxyNewForNameOwner(kMockSystemBus_, |
| StrEq(kFlimFlamDbusService), |
| StrEq(kServicePath_), |
| StrEq(kFlimFlamDbusServiceInterface), |
| _)) |
| .WillOnce(Return(kMockFlimFlamServiceProxy_)); |
| EXPECT_CALL(dbus_iface_, ProxyUnref(kMockFlimFlamServiceProxy_)); |
| EXPECT_CALL(dbus_iface_, BusGet(DBUS_BUS_SYSTEM, _)) |
| .RetiresOnSaturation(); |
| } |
| |
| void FlimFlamProxyTest::TestWithServiceType( |
| const char* service_type, |
| NetworkConnectionType expected_type) { |
| |
| SetupMocks("/service/guest-network"); |
| SetManagerReply(kServicePath_, DBUS_TYPE_G_OBJECT_PATH_ARRAY); |
| SetServiceReply(service_type); |
| |
| NetworkConnectionType type; |
| EXPECT_TRUE(FlimFlamProxy::GetConnectionType(&dbus_iface_, &type)); |
| EXPECT_EQ(expected_type, type); |
| } |
| |
| TEST_F(FlimFlamProxyTest, SimpleTest) { |
| TestWithServiceType(kFlimFlamNetTypeEthernet, kNetEthernet); |
| TestWithServiceType(kFlimFlamNetTypeWifi, kNetWifi); |
| TestWithServiceType(kFlimFlamNetTypeWimax, kNetWimax); |
| TestWithServiceType(kFlimFlamNetTypeBluetooth, kNetBluetooth); |
| TestWithServiceType(kFlimFlamNetTypeCellular, kNetCellular); |
| } |
| |
| TEST_F(FlimFlamProxyTest, UnknownTest) { |
| TestWithServiceType("foo", kNetUnknown); |
| } |
| |
| TEST_F(FlimFlamProxyTest, ExpensiveConnectionsTest) { |
| EXPECT_FALSE(FlimFlamProxy::IsExpensiveConnectionType(kNetEthernet)); |
| EXPECT_FALSE(FlimFlamProxy::IsExpensiveConnectionType(kNetWifi)); |
| EXPECT_TRUE(FlimFlamProxy::IsExpensiveConnectionType(kNetWimax)); |
| EXPECT_TRUE(FlimFlamProxy::IsExpensiveConnectionType(kNetBluetooth)); |
| EXPECT_TRUE(FlimFlamProxy::IsExpensiveConnectionType(kNetCellular)); |
| } |
| |
| TEST_F(FlimFlamProxyTest, StringForConnectionTypeTest) { |
| EXPECT_STREQ(kFlimFlamNetTypeEthernet, |
| FlimFlamProxy::StringForConnectionType(kNetEthernet)); |
| EXPECT_STREQ(kFlimFlamNetTypeWifi, |
| FlimFlamProxy::StringForConnectionType(kNetWifi)); |
| EXPECT_STREQ(kFlimFlamNetTypeWimax, |
| FlimFlamProxy::StringForConnectionType(kNetWimax)); |
| EXPECT_STREQ(kFlimFlamNetTypeBluetooth, |
| FlimFlamProxy::StringForConnectionType(kNetBluetooth)); |
| EXPECT_STREQ(kFlimFlamNetTypeCellular, |
| FlimFlamProxy::StringForConnectionType(kNetCellular)); |
| EXPECT_STREQ("Unknown", |
| FlimFlamProxy::StringForConnectionType(kNetUnknown)); |
| EXPECT_STREQ("Unknown", |
| FlimFlamProxy::StringForConnectionType( |
| static_cast<NetworkConnectionType>(999999))); |
| } |
| |
| TEST_F(FlimFlamProxyTest, MalformedServiceList) { |
| SetupMocks("/service/guest-network"); |
| std::string service_name(kServicePath_); |
| SetManagerReply(&service_name, DBUS_TYPE_G_STRING_ARRAY); |
| |
| NetworkConnectionType type; |
| EXPECT_FALSE(FlimFlamProxy::GetConnectionType(&dbus_iface_, &type)); |
| } |
| |
| } // namespace chromeos_update_engine |