components/proximity_auth/connection_unittest.cc

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