[EasyUnlock] Port Connection class to native code.

components/proximity_auth/connection_unittest.cc

Index: components/proximity_auth/connection_unittest.cc
diff --git a/components/proximity_auth/connection_unittest.cc b/components/proximity_auth/connection_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..34d94a812983c2c79db47d1540d93f12ee512b1e
--- /dev/null
+++ b/components/proximity_auth/connection_unittest.cc
@@ -0,0 +1,235 @@
+// Copyright 2014 The Chromium 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 "components/proximity_auth/connection.h"
+
+#include "components/proximity_auth/connection_observer.h"
+#include "components/proximity_auth/permit_message.h"
+#include "net/base/io_buffer.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+using testing::NiceMock;
+using testing::Return;
+using testing::StrictMock;
+
+namespace proximity_auth {
+namespace {
+
+class MockConnection : public Connection {
+ public:
+  MockConnection() : Connection(RemoteDevice()) {}
+  ~MockConnection() {}
+
+  MOCK_METHOD1(SetPaused, void(bool paused));
+  MOCK_METHOD0(Connect, void());
+  MOCK_METHOD0(Disconnect, void());
+  MOCK_METHOD0(CancelConnectionAttempt, void());
+  MOCK_METHOD1(SendMessageImplProxy, void(PermitMessage* message));
+  MOCK_METHOD0(HasReceivedCompleteMessage, bool());
+  MOCK_METHOD0(DeserializePermitMessageProxy, PermitMessage*());
+
+  // Gmock only supports copyable types, so create simple wrapper methods for
+  // ease of mocking.
+  virtual void SendMessageImpl(scoped_ptr<PermitMessage> message) OVERRIDE {
+    SendMessageImplProxy(message.get());
+  }
+
+  virtual scoped_ptr<PermitMessage> DeserializePermitMessage() OVERRIDE {
+    return make_scoped_ptr(DeserializePermitMessageProxy());
+  }
+
+  using Connection::status;
+  using Connection::SetStatus;
+  using Connection::OnDidSendMessage;
+  using Connection::OnBytesReceived;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockConnection);
+};
+
+class MockConnectionObserver : public ConnectionObserver {
+ public:
+  MockConnectionObserver() {}
+  virtual ~MockConnectionObserver() {}
+
+  MOCK_METHOD3(OnConnectionStatusChanged, void(const Connection& connection,
+                                               Connection::Status old_status,
+                                               Connection::Status new_status));
+  MOCK_METHOD2(OnMessageReceived, void(const Connection& connection,
+                                       const PermitMessage& message));
+  MOCK_METHOD3(OnSendCompleted, void(const Connection& connection,
+                                     const PermitMessage& message,
+                                     bool success));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockConnectionObserver);
+};
+
+// Unlike PermitMessage, offers a public constructor.
+class TestPermitMessage : public PermitMessage {
+ public:
+  TestPermitMessage() {}
+  virtual ~TestPermitMessage() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestPermitMessage);
+};
+
+}  // namespace
+
+TEST(ConnectionTest, IsConnected) {

[Tim Song, 2014/09/05 00:30:34]

Prefix this test name with "ProximityAuth" or something similar so we can have a
gtest_filter that can run all the unit tests.

[Ilya Sherman, 2014/09/05 01:02:11]

Done.

+  StrictMock<MockConnection> connection;
+  EXPECT_EQ(false, connection.IsConnected());
+
+  connection.SetStatus(Connection::CONNECTED);
+  EXPECT_EQ(true, connection.IsConnected());
+
+  connection.SetStatus(Connection::DISCONNECTED);
+  EXPECT_EQ(false, connection.IsConnected());
+
+  connection.SetStatus(Connection::IN_PROGRESS);
+  EXPECT_EQ(false, connection.IsConnected());
+}
+
+TEST(ConnectionTest, SendMessage_FailsWhenNotConnected) {
+  StrictMock<MockConnection> connection;
+  connection.SetStatus(Connection::IN_PROGRESS);
+
+  EXPECT_CALL(connection, SendMessageImplProxy(_)).Times(0);
+  connection.SendMessage(scoped_ptr<PermitMessage>());
+}
+
+TEST(ConnectionTest, SendMessage_FailsWhenAnotherMessageSendIsInProgress) {
+  NiceMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+  connection.SendMessage(scoped_ptr<PermitMessage>());
+
+  EXPECT_CALL(connection, SendMessageImplProxy(_)).Times(0);
+  connection.SendMessage(scoped_ptr<PermitMessage>());
+}
+
+TEST(ConnectionTest, SendMessage_SucceedsWhenConnected) {
+  StrictMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+
+  EXPECT_CALL(connection, SendMessageImplProxy(_));
+  connection.SendMessage(scoped_ptr<PermitMessage>());
+}
+
+TEST(ConnectionTest, SendMessage_SucceedsAfterPreviousMessageSendCompletes) {
+  NiceMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+  connection.SendMessage(scoped_ptr<PermitMessage>());
+  connection.OnDidSendMessage(TestPermitMessage(), true /* success */);
+
+  EXPECT_CALL(connection, SendMessageImplProxy(_));
+  connection.SendMessage(scoped_ptr<PermitMessage>());
+}
+
+TEST(ConnectionTest, SetStatus_NotifiesObserversOfStatusChange) {
+  StrictMock<MockConnection> connection;
+  EXPECT_EQ(Connection::DISCONNECTED, connection.status());
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  EXPECT_CALL(observer,
+              OnConnectionStatusChanged(Ref(connection),
+                                        Connection::DISCONNECTED,
+                                        Connection::CONNECTED));
+  connection.SetStatus(Connection::CONNECTED);
+}
+
+TEST(ConnectionTest, SetStatus_DoesntNotifyObserversIfStatusUnchanged) {
+  StrictMock<MockConnection> connection;
+  EXPECT_EQ(Connection::DISCONNECTED, connection.status());
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  EXPECT_CALL(observer, OnConnectionStatusChanged(_, _, _)).Times(0);
+  connection.SetStatus(Connection::DISCONNECTED);
+}
+
+TEST(ConnectionTest,
+     OnDidSendMessage_NotifiesObserversIfMessageSendInProgress) {
+  NiceMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+  connection.SendMessage(scoped_ptr<PermitMessage>());
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  EXPECT_CALL(observer, OnSendCompleted(Ref(connection), _, true));
+  connection.OnDidSendMessage(TestPermitMessage(), true /* success */);
+}
+
+TEST(ConnectionTest,
+     OnDidSendMessage_DoesntNotifyObserversIfNoMessageSendInProgress) {
+  NiceMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  EXPECT_CALL(observer, OnSendCompleted(_, _, _)).Times(0);
+  connection.OnDidSendMessage(TestPermitMessage(), true /* success */);
+}
+
+TEST(ConnectionTest, OnBytesReceived_NotifiesObserversOnValidMessage) {
+  NiceMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  ON_CALL(connection, HasReceivedCompleteMessage()).WillByDefault(Return(true));
+  ON_CALL(connection, DeserializePermitMessageProxy()).WillByDefault(
+      Return(new TestPermitMessage));
+  EXPECT_CALL(observer, OnMessageReceived(Ref(connection), _));
+  connection.OnBytesReceived(new net::IOBuffer, 0);
+}
+
+TEST(ConnectionTest, OnBytesReceived_DoesntNotifyObserversIfNotConnected) {
+  StrictMock<MockConnection> connection;
+  connection.SetStatus(Connection::IN_PROGRESS);
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  EXPECT_CALL(observer, OnMessageReceived(_, _)).Times(0);
+  connection.OnBytesReceived(scoped_refptr<net::IOBuffer>(), 0);
+}
+
+TEST(ConnectionTest,
+     OnBytesReceived_DoesntNotifyObserversIfMessageIsIncomplete) {
+  NiceMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  ON_CALL(connection, HasReceivedCompleteMessage()).WillByDefault(
+      Return(false));
+  EXPECT_CALL(observer, OnMessageReceived(_, _)).Times(0);
+  connection.OnBytesReceived(new net::IOBuffer, 0);
+}
+
+TEST(ConnectionTest, OnBytesReceived_DoesntNotifyObserversIfMessageIsInvalid) {
+  NiceMock<MockConnection> connection;
+  connection.SetStatus(Connection::CONNECTED);
+
+  StrictMock<MockConnectionObserver> observer;
+  connection.AddObserver(&observer);
+
+  ON_CALL(connection, HasReceivedCompleteMessage()).WillByDefault(Return(true));
+  ON_CALL(connection, DeserializePermitMessageProxy()).WillByDefault(
+      Return(static_cast<PermitMessage*>(NULL)));
+  EXPECT_CALL(observer, OnMessageReceived(_, _)).Times(0);
+  connection.OnBytesReceived(new net::IOBuffer, 0);
+}
+
+}  // namespace proximity_auth