OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "chromeos/components/tether/host_scan_device_prioritizer_impl.h" |
| 6 |
| 7 #include <memory> |
| 8 |
| 9 #include "base/test/scoped_task_environment.h" |
| 10 #include "chromeos/components/tether/device_id_tether_network_guid_map.h" |
| 11 #include "chromeos/components/tether/tether_host_response_recorder.h" |
| 12 #include "chromeos/dbus/dbus_thread_manager.h" |
| 13 #include "chromeos/network/network_state.h" |
| 14 #include "chromeos/network/network_state_handler.h" |
| 15 #include "chromeos/network/network_state_test.h" |
| 16 #include "components/cryptauth/remote_device_test_util.h" |
| 17 #include "components/prefs/testing_pref_service.h" |
| 18 #include "testing/gtest/include/gtest/gtest.h" |
| 19 |
| 20 namespace chromeos { |
| 21 |
| 22 namespace tether { |
| 23 |
| 24 class HostScanDevicePrioritizerImplTest : public NetworkStateTest { |
| 25 protected: |
| 26 HostScanDevicePrioritizerImplTest() |
| 27 : test_devices_(cryptauth::GenerateTestRemoteDevices(10)) {} |
| 28 |
| 29 void SetUp() override { |
| 30 DBusThreadManager::Initialize(); |
| 31 NetworkStateTest::SetUp(); |
| 32 |
| 33 network_state_handler()->SetTetherTechnologyState( |
| 34 NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED); |
| 35 |
| 36 pref_service_ = base::MakeUnique<TestingPrefServiceSimple>(); |
| 37 TetherHostResponseRecorder::RegisterPrefs(pref_service_->registry()); |
| 38 |
| 39 recorder_ = |
| 40 base::MakeUnique<TetherHostResponseRecorder>(pref_service_.get()); |
| 41 device_id_tether_network_guid_map_ = |
| 42 base::MakeUnique<DeviceIdTetherNetworkGuidMap>(); |
| 43 |
| 44 prioritizer_ = base::MakeUnique<HostScanDevicePrioritizerImpl>( |
| 45 network_state_handler(), recorder_.get(), |
| 46 device_id_tether_network_guid_map_.get()); |
| 47 } |
| 48 |
| 49 void TearDown() override { |
| 50 prioritizer_.reset(); |
| 51 ShutdownNetworkState(); |
| 52 NetworkStateTest::TearDown(); |
| 53 DBusThreadManager::Shutdown(); |
| 54 } |
| 55 |
| 56 void VerifyNetworksInExpectedOrder( |
| 57 std::vector<cryptauth::RemoteDevice> expected) { |
| 58 NetworkStateHandler::NetworkStateList network_list; |
| 59 |
| 60 network_state_handler()->GetVisibleNetworkListByType( |
| 61 NetworkTypePattern::Tether(), &network_list); |
| 62 EXPECT_EQ(expected.size(), network_list.size()); |
| 63 |
| 64 for (size_t i = 0; i < expected.size(); i++) { |
| 65 std::string expected_guid = |
| 66 device_id_tether_network_guid_map_->GetTetherNetworkGuidForDeviceId( |
| 67 expected[i].GetDeviceId()); |
| 68 EXPECT_EQ(expected_guid, network_list[i]->guid()); |
| 69 } |
| 70 } |
| 71 |
| 72 void AddNetworkStateForDevice(const cryptauth::RemoteDevice& remote_device) { |
| 73 std::string guid = |
| 74 device_id_tether_network_guid_map_->GetTetherNetworkGuidForDeviceId( |
| 75 remote_device.GetDeviceId()); |
| 76 network_state_handler()->AddTetherNetworkState( |
| 77 guid, "name", "carrier", 100 /* battery_percentage */, |
| 78 100 /* signal_strength */, false /* has_connected_to_host */); |
| 79 } |
| 80 |
| 81 const base::test::ScopedTaskEnvironment scoped_task_environment_; |
| 82 const std::vector<cryptauth::RemoteDevice> test_devices_; |
| 83 |
| 84 std::unique_ptr<TestingPrefServiceSimple> pref_service_; |
| 85 std::unique_ptr<TetherHostResponseRecorder> recorder_; |
| 86 // TODO(hansberry): Use a fake for this when a real mapping scheme is created. |
| 87 std::unique_ptr<DeviceIdTetherNetworkGuidMap> |
| 88 device_id_tether_network_guid_map_; |
| 89 |
| 90 std::unique_ptr<HostScanDevicePrioritizerImpl> prioritizer_; |
| 91 |
| 92 private: |
| 93 DISALLOW_COPY_AND_ASSIGN(HostScanDevicePrioritizerImplTest); |
| 94 }; |
| 95 |
| 96 TEST_F(HostScanDevicePrioritizerImplTest, |
| 97 TestOnlyTetherAvailabilityResponses_RemoteDevices) { |
| 98 // Receive TetherAvailabilityResponses from devices 0-4. |
| 99 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]); |
| 100 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[1]); |
| 101 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[2]); |
| 102 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[3]); |
| 103 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[4]); |
| 104 |
| 105 // Do not receive a ConnectTetheringResponse. |
| 106 |
| 107 std::vector<cryptauth::RemoteDevice> test_vector = |
| 108 std::vector<cryptauth::RemoteDevice>{test_devices_[6], test_devices_[5], |
| 109 test_devices_[4], test_devices_[3], |
| 110 test_devices_[2], test_devices_[1], |
| 111 test_devices_[0]}; |
| 112 |
| 113 prioritizer_->SortByHostScanOrder(&test_vector); |
| 114 EXPECT_EQ((std::vector<cryptauth::RemoteDevice>{ |
| 115 test_devices_[4], test_devices_[3], test_devices_[2], |
| 116 test_devices_[1], test_devices_[0], test_devices_[6], |
| 117 test_devices_[5]}), |
| 118 test_vector); |
| 119 } |
| 120 |
| 121 TEST_F(HostScanDevicePrioritizerImplTest, |
| 122 TestOnlyTetherAvailabilityResponses_NetworkStates) { |
| 123 // Receive TetherAvailabilityResponses from devices 0-4. |
| 124 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]); |
| 125 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[1]); |
| 126 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[2]); |
| 127 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[3]); |
| 128 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[4]); |
| 129 |
| 130 // Do not receive a ConnectTetheringResponse. |
| 131 |
| 132 AddNetworkStateForDevice(test_devices_[6]); |
| 133 AddNetworkStateForDevice(test_devices_[5]); |
| 134 AddNetworkStateForDevice(test_devices_[4]); |
| 135 AddNetworkStateForDevice(test_devices_[3]); |
| 136 AddNetworkStateForDevice(test_devices_[2]); |
| 137 AddNetworkStateForDevice(test_devices_[1]); |
| 138 AddNetworkStateForDevice(test_devices_[0]); |
| 139 |
| 140 VerifyNetworksInExpectedOrder((std::vector<cryptauth::RemoteDevice>{ |
| 141 test_devices_[4], test_devices_[3], test_devices_[2], test_devices_[1], |
| 142 test_devices_[0], test_devices_[6], test_devices_[5]})); |
| 143 } |
| 144 |
| 145 TEST_F(HostScanDevicePrioritizerImplTest, |
| 146 TestBothTypesOfResponses_RemoteDevices) { |
| 147 // Receive TetherAvailabilityResponses from devices 0-4. |
| 148 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]); |
| 149 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[1]); |
| 150 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[2]); |
| 151 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[3]); |
| 152 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[4]); |
| 153 |
| 154 // Receive ConnectTetheringResponse from device 0. |
| 155 recorder_->RecordSuccessfulConnectTetheringResponse(test_devices_[0]); |
| 156 |
| 157 std::vector<cryptauth::RemoteDevice> test_vector = |
| 158 std::vector<cryptauth::RemoteDevice>{test_devices_[6], test_devices_[5], |
| 159 test_devices_[4], test_devices_[3], |
| 160 test_devices_[2], test_devices_[1], |
| 161 test_devices_[0]}; |
| 162 |
| 163 prioritizer_->SortByHostScanOrder(&test_vector); |
| 164 EXPECT_EQ((std::vector<cryptauth::RemoteDevice>{ |
| 165 test_devices_[0], test_devices_[4], test_devices_[3], |
| 166 test_devices_[2], test_devices_[1], test_devices_[6], |
| 167 test_devices_[5]}), |
| 168 test_vector); |
| 169 } |
| 170 |
| 171 TEST_F(HostScanDevicePrioritizerImplTest, |
| 172 TestBothTypesOfResponses_NetworkStates) { |
| 173 // Receive TetherAvailabilityResponses from devices 0-4. |
| 174 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]); |
| 175 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[1]); |
| 176 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[2]); |
| 177 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[3]); |
| 178 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[4]); |
| 179 |
| 180 // Receive ConnectTetheringResponse from device 0. |
| 181 recorder_->RecordSuccessfulConnectTetheringResponse(test_devices_[0]); |
| 182 |
| 183 AddNetworkStateForDevice(test_devices_[6]); |
| 184 AddNetworkStateForDevice(test_devices_[5]); |
| 185 AddNetworkStateForDevice(test_devices_[4]); |
| 186 AddNetworkStateForDevice(test_devices_[3]); |
| 187 AddNetworkStateForDevice(test_devices_[2]); |
| 188 AddNetworkStateForDevice(test_devices_[1]); |
| 189 AddNetworkStateForDevice(test_devices_[0]); |
| 190 |
| 191 VerifyNetworksInExpectedOrder((std::vector<cryptauth::RemoteDevice>{ |
| 192 test_devices_[0], test_devices_[4], test_devices_[3], test_devices_[2], |
| 193 test_devices_[1], test_devices_[6], test_devices_[5]})); |
| 194 } |
| 195 |
| 196 TEST_F(HostScanDevicePrioritizerImplTest, |
| 197 TestBothTypesOfResponses_DifferentOrder_RemoteDevices) { |
| 198 // Receive different order. |
| 199 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]); |
| 200 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[2]); |
| 201 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[1]); |
| 202 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[4]); |
| 203 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[3]); |
| 204 |
| 205 // Receive ConnectTetheringResponse from device 1. |
| 206 recorder_->RecordSuccessfulConnectTetheringResponse(test_devices_[1]); |
| 207 |
| 208 std::vector<cryptauth::RemoteDevice> test_vector = |
| 209 std::vector<cryptauth::RemoteDevice>{test_devices_[9], test_devices_[8], |
| 210 test_devices_[7], test_devices_[6], |
| 211 test_devices_[5], test_devices_[4], |
| 212 test_devices_[3], test_devices_[2], |
| 213 test_devices_[1], test_devices_[0]}; |
| 214 |
| 215 prioritizer_->SortByHostScanOrder(&test_vector); |
| 216 EXPECT_EQ((std::vector<cryptauth::RemoteDevice>{ |
| 217 test_devices_[1], test_devices_[3], test_devices_[4], |
| 218 test_devices_[2], test_devices_[0], test_devices_[9], |
| 219 test_devices_[8], test_devices_[7], test_devices_[6], |
| 220 test_devices_[5]}), |
| 221 test_vector); |
| 222 } |
| 223 |
| 224 TEST_F(HostScanDevicePrioritizerImplTest, |
| 225 TestBothTypesOfResponses_DifferentOrder_NetworkStates) { |
| 226 // Receive different order. |
| 227 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]); |
| 228 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[2]); |
| 229 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[1]); |
| 230 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[4]); |
| 231 recorder_->RecordSuccessfulTetherAvailabilityResponse(test_devices_[3]); |
| 232 |
| 233 // Receive ConnectTetheringResponse from device 1. |
| 234 recorder_->RecordSuccessfulConnectTetheringResponse(test_devices_[1]); |
| 235 |
| 236 AddNetworkStateForDevice(test_devices_[9]); |
| 237 AddNetworkStateForDevice(test_devices_[8]); |
| 238 AddNetworkStateForDevice(test_devices_[7]); |
| 239 AddNetworkStateForDevice(test_devices_[6]); |
| 240 AddNetworkStateForDevice(test_devices_[5]); |
| 241 AddNetworkStateForDevice(test_devices_[4]); |
| 242 AddNetworkStateForDevice(test_devices_[3]); |
| 243 AddNetworkStateForDevice(test_devices_[2]); |
| 244 AddNetworkStateForDevice(test_devices_[1]); |
| 245 AddNetworkStateForDevice(test_devices_[0]); |
| 246 |
| 247 VerifyNetworksInExpectedOrder((std::vector<cryptauth::RemoteDevice>{ |
| 248 test_devices_[1], test_devices_[3], test_devices_[4], test_devices_[2], |
| 249 test_devices_[0], test_devices_[9], test_devices_[8], test_devices_[7], |
| 250 test_devices_[6], test_devices_[5]})); |
| 251 } |
| 252 |
| 253 } // namespace tether |
| 254 |
| 255 } // namespace chromeos |
OLD | NEW |