| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "components/proximity_auth/connection.h" | |
| 6 | |
| 7 #include "base/macros.h" | |
| 8 #include "base/memory/ptr_util.h" | |
| 9 #include "components/cryptauth/remote_device.h" | |
| 10 #include "components/proximity_auth/connection_observer.h" | |
| 11 #include "components/proximity_auth/wire_message.h" | |
| 12 #include "testing/gmock/include/gmock/gmock.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 using testing::_; | |
| 16 using testing::DoAll; | |
| 17 using testing::NiceMock; | |
| 18 using testing::Return; | |
| 19 using testing::SetArgPointee; | |
| 20 using testing::StrictMock; | |
| 21 | |
| 22 namespace proximity_auth { | |
| 23 namespace { | |
| 24 | |
| 25 class MockConnection : public Connection { | |
| 26 public: | |
| 27 MockConnection() : Connection(cryptauth::RemoteDevice()) {} | |
| 28 ~MockConnection() {} | |
| 29 | |
| 30 MOCK_METHOD1(SetPaused, void(bool paused)); | |
| 31 MOCK_METHOD0(Connect, void()); | |
| 32 MOCK_METHOD0(Disconnect, void()); | |
| 33 MOCK_METHOD0(CancelConnectionAttempt, void()); | |
| 34 MOCK_METHOD1(SendMessageImplProxy, void(WireMessage* message)); | |
| 35 MOCK_METHOD1(DeserializeWireMessageProxy, | |
| 36 WireMessage*(bool* is_incomplete_message)); | |
| 37 | |
| 38 // Gmock only supports copyable types, so create simple wrapper methods for | |
| 39 // ease of mocking. | |
| 40 void SendMessageImpl(std::unique_ptr<WireMessage> message) override { | |
| 41 SendMessageImplProxy(message.get()); | |
| 42 } | |
| 43 | |
| 44 std::unique_ptr<WireMessage> DeserializeWireMessage( | |
| 45 bool* is_incomplete_message) override { | |
| 46 return base::WrapUnique(DeserializeWireMessageProxy(is_incomplete_message)); | |
| 47 } | |
| 48 | |
| 49 using Connection::status; | |
| 50 using Connection::SetStatus; | |
| 51 using Connection::OnDidSendMessage; | |
| 52 using Connection::OnBytesReceived; | |
| 53 | |
| 54 private: | |
| 55 DISALLOW_COPY_AND_ASSIGN(MockConnection); | |
| 56 }; | |
| 57 | |
| 58 class MockConnectionObserver : public ConnectionObserver { | |
| 59 public: | |
| 60 MockConnectionObserver() {} | |
| 61 virtual ~MockConnectionObserver() {} | |
| 62 | |
| 63 MOCK_METHOD3(OnConnectionStatusChanged, | |
| 64 void(Connection* connection, | |
| 65 Connection::Status old_status, | |
| 66 Connection::Status new_status)); | |
| 67 MOCK_METHOD2(OnMessageReceived, | |
| 68 void(const Connection& connection, const WireMessage& message)); | |
| 69 MOCK_METHOD3(OnSendCompleted, | |
| 70 void(const Connection& connection, | |
| 71 const WireMessage& message, | |
| 72 bool success)); | |
| 73 | |
| 74 private: | |
| 75 DISALLOW_COPY_AND_ASSIGN(MockConnectionObserver); | |
| 76 }; | |
| 77 | |
| 78 // Unlike WireMessage, offers a public constructor. | |
| 79 class TestWireMessage : public WireMessage { | |
| 80 public: | |
| 81 TestWireMessage() : WireMessage(std::string()) {} | |
| 82 ~TestWireMessage() override {} | |
| 83 | |
| 84 private: | |
| 85 DISALLOW_COPY_AND_ASSIGN(TestWireMessage); | |
| 86 }; | |
| 87 | |
| 88 } // namespace | |
| 89 | |
| 90 TEST(ProximityAuthConnectionTest, IsConnected) { | |
| 91 StrictMock<MockConnection> connection; | |
| 92 EXPECT_FALSE(connection.IsConnected()); | |
| 93 | |
| 94 connection.SetStatus(Connection::CONNECTED); | |
| 95 EXPECT_TRUE(connection.IsConnected()); | |
| 96 | |
| 97 connection.SetStatus(Connection::DISCONNECTED); | |
| 98 EXPECT_FALSE(connection.IsConnected()); | |
| 99 | |
| 100 connection.SetStatus(Connection::IN_PROGRESS); | |
| 101 EXPECT_FALSE(connection.IsConnected()); | |
| 102 } | |
| 103 | |
| 104 TEST(ProximityAuthConnectionTest, SendMessage_FailsWhenNotConnected) { | |
| 105 StrictMock<MockConnection> connection; | |
| 106 connection.SetStatus(Connection::IN_PROGRESS); | |
| 107 | |
| 108 EXPECT_CALL(connection, SendMessageImplProxy(_)).Times(0); | |
| 109 connection.SendMessage(std::unique_ptr<WireMessage>()); | |
| 110 } | |
| 111 | |
| 112 TEST(ProximityAuthConnectionTest, | |
| 113 SendMessage_FailsWhenAnotherMessageSendIsInProgress) { | |
| 114 NiceMock<MockConnection> connection; | |
| 115 connection.SetStatus(Connection::CONNECTED); | |
| 116 connection.SendMessage(std::unique_ptr<WireMessage>()); | |
| 117 | |
| 118 EXPECT_CALL(connection, SendMessageImplProxy(_)).Times(0); | |
| 119 connection.SendMessage(std::unique_ptr<WireMessage>()); | |
| 120 } | |
| 121 | |
| 122 TEST(ProximityAuthConnectionTest, SendMessage_SucceedsWhenConnected) { | |
| 123 StrictMock<MockConnection> connection; | |
| 124 connection.SetStatus(Connection::CONNECTED); | |
| 125 | |
| 126 EXPECT_CALL(connection, SendMessageImplProxy(_)); | |
| 127 connection.SendMessage(std::unique_ptr<WireMessage>()); | |
| 128 } | |
| 129 | |
| 130 TEST(ProximityAuthConnectionTest, | |
| 131 SendMessage_SucceedsAfterPreviousMessageSendCompletes) { | |
| 132 NiceMock<MockConnection> connection; | |
| 133 connection.SetStatus(Connection::CONNECTED); | |
| 134 connection.SendMessage(std::unique_ptr<WireMessage>()); | |
| 135 connection.OnDidSendMessage(TestWireMessage(), true /* success */); | |
| 136 | |
| 137 EXPECT_CALL(connection, SendMessageImplProxy(_)); | |
| 138 connection.SendMessage(std::unique_ptr<WireMessage>()); | |
| 139 } | |
| 140 | |
| 141 TEST(ProximityAuthConnectionTest, SetStatus_NotifiesObserversOfStatusChange) { | |
| 142 StrictMock<MockConnection> connection; | |
| 143 EXPECT_EQ(Connection::DISCONNECTED, connection.status()); | |
| 144 | |
| 145 StrictMock<MockConnectionObserver> observer; | |
| 146 connection.AddObserver(&observer); | |
| 147 | |
| 148 EXPECT_CALL(observer, | |
| 149 OnConnectionStatusChanged(&connection, Connection::DISCONNECTED, | |
| 150 Connection::CONNECTED)); | |
| 151 connection.SetStatus(Connection::CONNECTED); | |
| 152 } | |
| 153 | |
| 154 TEST(ProximityAuthConnectionTest, | |
| 155 SetStatus_DoesntNotifyObserversIfStatusUnchanged) { | |
| 156 StrictMock<MockConnection> connection; | |
| 157 EXPECT_EQ(Connection::DISCONNECTED, connection.status()); | |
| 158 | |
| 159 StrictMock<MockConnectionObserver> observer; | |
| 160 connection.AddObserver(&observer); | |
| 161 | |
| 162 EXPECT_CALL(observer, OnConnectionStatusChanged(_, _, _)).Times(0); | |
| 163 connection.SetStatus(Connection::DISCONNECTED); | |
| 164 } | |
| 165 | |
| 166 TEST(ProximityAuthConnectionTest, | |
| 167 OnDidSendMessage_NotifiesObserversIfMessageSendInProgress) { | |
| 168 NiceMock<MockConnection> connection; | |
| 169 connection.SetStatus(Connection::CONNECTED); | |
| 170 connection.SendMessage(std::unique_ptr<WireMessage>()); | |
| 171 | |
| 172 StrictMock<MockConnectionObserver> observer; | |
| 173 connection.AddObserver(&observer); | |
| 174 | |
| 175 EXPECT_CALL(observer, OnSendCompleted(Ref(connection), _, true)); | |
| 176 connection.OnDidSendMessage(TestWireMessage(), true /* success */); | |
| 177 } | |
| 178 | |
| 179 TEST(ProximityAuthConnectionTest, | |
| 180 OnDidSendMessage_DoesntNotifyObserversIfNoMessageSendInProgress) { | |
| 181 NiceMock<MockConnection> connection; | |
| 182 connection.SetStatus(Connection::CONNECTED); | |
| 183 | |
| 184 StrictMock<MockConnectionObserver> observer; | |
| 185 connection.AddObserver(&observer); | |
| 186 | |
| 187 EXPECT_CALL(observer, OnSendCompleted(_, _, _)).Times(0); | |
| 188 connection.OnDidSendMessage(TestWireMessage(), true /* success */); | |
| 189 } | |
| 190 | |
| 191 TEST(ProximityAuthConnectionTest, | |
| 192 OnBytesReceived_NotifiesObserversOnValidMessage) { | |
| 193 NiceMock<MockConnection> connection; | |
| 194 connection.SetStatus(Connection::CONNECTED); | |
| 195 | |
| 196 StrictMock<MockConnectionObserver> observer; | |
| 197 connection.AddObserver(&observer); | |
| 198 | |
| 199 ON_CALL(connection, DeserializeWireMessageProxy(_)) | |
| 200 .WillByDefault( | |
| 201 DoAll(SetArgPointee<0>(false), Return(new TestWireMessage))); | |
| 202 EXPECT_CALL(observer, OnMessageReceived(Ref(connection), _)); | |
| 203 connection.OnBytesReceived(std::string()); | |
| 204 } | |
| 205 | |
| 206 TEST(ProximityAuthConnectionTest, | |
| 207 OnBytesReceived_DoesntNotifyObserversIfNotConnected) { | |
| 208 StrictMock<MockConnection> connection; | |
| 209 connection.SetStatus(Connection::IN_PROGRESS); | |
| 210 | |
| 211 StrictMock<MockConnectionObserver> observer; | |
| 212 connection.AddObserver(&observer); | |
| 213 | |
| 214 EXPECT_CALL(observer, OnMessageReceived(_, _)).Times(0); | |
| 215 connection.OnBytesReceived(std::string()); | |
| 216 } | |
| 217 | |
| 218 TEST(ProximityAuthConnectionTest, | |
| 219 OnBytesReceived_DoesntNotifyObserversIfMessageIsIncomplete) { | |
| 220 NiceMock<MockConnection> connection; | |
| 221 connection.SetStatus(Connection::CONNECTED); | |
| 222 | |
| 223 StrictMock<MockConnectionObserver> observer; | |
| 224 connection.AddObserver(&observer); | |
| 225 | |
| 226 ON_CALL(connection, DeserializeWireMessageProxy(_)) | |
| 227 .WillByDefault(DoAll(SetArgPointee<0>(true), Return(nullptr))); | |
| 228 EXPECT_CALL(observer, OnMessageReceived(_, _)).Times(0); | |
| 229 connection.OnBytesReceived(std::string()); | |
| 230 } | |
| 231 | |
| 232 TEST(ProximityAuthConnectionTest, | |
| 233 OnBytesReceived_DoesntNotifyObserversIfMessageIsInvalid) { | |
| 234 NiceMock<MockConnection> connection; | |
| 235 connection.SetStatus(Connection::CONNECTED); | |
| 236 | |
| 237 StrictMock<MockConnectionObserver> observer; | |
| 238 connection.AddObserver(&observer); | |
| 239 | |
| 240 ON_CALL(connection, DeserializeWireMessageProxy(_)) | |
| 241 .WillByDefault(DoAll(SetArgPointee<0>(false), Return(nullptr))); | |
| 242 EXPECT_CALL(observer, OnMessageReceived(_, _)).Times(0); | |
| 243 connection.OnBytesReceived(std::string()); | |
| 244 } | |
| 245 | |
| 246 } // namespace proximity_auth | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2561203002:
Migrate weave-related classes from proximity_auth/ble to cryptauth/ble. (Closed)
