Password manager internals page service: introduction

components/password_manager/core/browser/log_router_unittest.cc

Index: components/password_manager/core/browser/log_router_unittest.cc
diff --git a/components/password_manager/core/browser/log_router_unittest.cc b/components/password_manager/core/browser/log_router_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e29600eddae090d0a0b9d2ee329a7667f6dc4775
--- /dev/null
+++ b/components/password_manager/core/browser/log_router_unittest.cc
@@ -0,0 +1,127 @@
+// 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/password_manager/core/browser/log_router.h"
+
+#include "components/password_manager/core/browser/password_manager_logger.h"
+#include "components/password_manager/core/browser/stub_password_manager_client.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+
+namespace password_manager {
+
+namespace {
+
+const char kTestText[] = "abcd1234";
+const char kTestText2[] = "1234ABCD";
+const char kTestText3[] = "8765efgh";
+const char kTestText4[] = "8-6-EFGH";
+
+class MockLogReceiver : public PasswordManagerLogger {
+ public:
+  MockLogReceiver() {}
+
+  MOCK_METHOD1(LogSavePasswordProgress, void(const std::string&));
+};
+
+class MockPasswordManagerClient : public StubPasswordManagerClient {
+  // TODO(vabr): This currently does not mock anything. Once
+  // PasswordManagerClient starts to get notified about logging activity
+  // changes, do:
+  // 1) Use this mock to detect activity changes in the existing tests.
+  // 2) Write unit tests for router-client interaction using this mock.
+};
+
+}  // namespace
+
+class LogRouterTest : public testing::Test {
+ protected:
+  testing::StrictMock<MockPasswordManagerClient> client_;
+  testing::StrictMock<MockPasswordManagerClient> client2_;
+  testing::StrictMock<MockLogReceiver> receiver_;
+  testing::StrictMock<MockLogReceiver> receiver2_;
+};
+
+TEST_F(LogRouterTest, ProcessLog_OneReceiver) {
+  LogRouter router;
+
+  // When inactive, logs should not have been accumulated.
+  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText)).Times(0);
+  EXPECT_CALL(receiver2_, LogSavePasswordProgress(_)).Times(0);
+  router.ProcessLog(kTestText);

[Ilya Sherman, 2014/05/02 23:38:38]

Please split this off to a ZeroReceivers test case.

[vabr (Chromium), 2014/05/06 13:16:30]

I split that as suggested (+ modified to respect that calling ProcessLog is no
longer allowed before receiver registration).
However, the whole ProcessLog_NoReceiver test is included in
ProcessLog_OneReceiver anyway, and I can't help it (except for removing
EXPECT_EQ(std::string(),...) from router.RegisterReceiver(&receiver_), which I
don't see a good reason for).

In general, thanks for pushing to split the tests to single things to test!
I'll try to work on my tendency to lump all together in the future, to spare you
the effort of repeating this to me. :)

+
+  ASSERT_TRUE(router.RegisterReceiver(&receiver_));
+
+  // Check that only logs generated after activation are passed.

[Ilya Sherman, 2014/05/02 23:38:38]

Please test this in a separate test case as well.  Each TEST_F should ideally
correspond to a single simple test, like the one described in this sentence.

[vabr (Chromium), 2014/05/06 13:16:30]

After CHECKing against calling ProcessLog without registered receivers, the last
part of this test disappeared, so there is no need to split off the middle part
any more.

+  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText2)).Times(1);
+  router.ProcessLog(kTestText2);
+
+  ASSERT_TRUE(router.UnregisterReceiver(&receiver_));
+  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText3)).Times(0);
+  router.ProcessLog(kTestText3);
+}
+
+TEST_F(LogRouterTest, ProcessLog_TwoReceivers) {
+  LogRouter router;
+
+  ASSERT_TRUE(router.RegisterReceiver(&receiver_));
+
+  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText)).Times(1);
+  router.ProcessLog(kTestText);
+
+  // Accumulated logs get passed on registration.
+  EXPECT_CALL(receiver2_, LogSavePasswordProgress(kTestText)).Times(1);
+  ASSERT_TRUE(router.RegisterReceiver(&receiver2_));
+
+  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText2)).Times(1);
+  EXPECT_CALL(receiver2_, LogSavePasswordProgress(kTestText2)).Times(1);
+  router.ProcessLog(kTestText2);
+
+  ASSERT_TRUE(router.UnregisterReceiver(&receiver2_));
+
+  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText3)).Times(1);
+  EXPECT_CALL(receiver2_, LogSavePasswordProgress(_)).Times(0);
+  router.ProcessLog(kTestText3);
+
+  ASSERT_TRUE(router.UnregisterReceiver(&receiver_));
+  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText4)).Times(0);
+  router.ProcessLog(kTestText4);
+}
+
+// The following tests cover cases of registration and unregistration not tested

[vabr (Chromium), 2014/05/06 13:16:30]

I dropped all of the following tests, as the tested functionality is now covered
by ObserverList.

+// above.
+
+TEST_F(LogRouterTest, RegisterClient_Fail) {
+  LogRouter router;
+  EXPECT_TRUE(router.RegisterClient(&client_));
+  EXPECT_FALSE(router.RegisterClient(&client_));
+  EXPECT_TRUE(router.UnregisterClient(&client_));
+}
+
+TEST_F(LogRouterTest, UnregisterClient_Fail) {
+  LogRouter router;
+  EXPECT_TRUE(router.RegisterClient(&client_));
+  EXPECT_FALSE(router.UnregisterClient(&client2_));
+  EXPECT_TRUE(router.UnregisterClient(&client_));
+  EXPECT_FALSE(router.UnregisterClient(&client_));
+}
+
+TEST_F(LogRouterTest, RegisterReceiver_Fail) {
+  LogRouter router;
+  EXPECT_TRUE(router.RegisterReceiver(&receiver_));
+  EXPECT_FALSE(router.RegisterReceiver(&receiver_));
+  EXPECT_TRUE(router.UnregisterReceiver(&receiver_));
+}
+
+TEST_F(LogRouterTest, UnregisterReceiver_Fail) {
+  LogRouter router;
+  EXPECT_TRUE(router.RegisterReceiver(&receiver_));
+  EXPECT_FALSE(router.UnregisterReceiver(&receiver2_));
+  EXPECT_TRUE(router.UnregisterReceiver(&receiver_));
+  EXPECT_FALSE(router.UnregisterReceiver(&receiver_));
+}
+
+}  // namespace password_manager