components/password_manager/content/renderer/credential_manager_client_browsertest.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/password_manager/content/common/credential_manager_messages.h"
   6 #include "components/password_manager/content/renderer/credential_manager_client.h"
   7 #include "content/public/test/render_view_test.h"
   8 #include "ipc/ipc_test_sink.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "third_party/WebKit/public/platform/WebCredential.h"
  11 #include "third_party/WebKit/public/platform/WebCredentialManagerClient.h"
  12 #include "third_party/WebKit/public/platform/WebCredentialManagerError.h"
  13 #include "third_party/WebKit/public/platform/WebPasswordCredential.h"
  14
  15 namespace password_manager {
  16
  17 namespace {
  18
  19 class CredentialManagerClientTest : public content::RenderViewTest {
  20  public:
  21   CredentialManagerClientTest()
  22       : callback_errored_(false), callback_succeeded_(false) {}
  23   ~CredentialManagerClientTest() override {}
  24
  25   void SetUp() override {
  26     content::RenderViewTest::SetUp();
  27     credential_.reset(new blink::WebPasswordCredential("", "", "", GURL()));
  28     client_.reset(new CredentialManagerClient(view_));
  29   }
  30
  31   void TearDown() override {
  32     credential_.reset();
  33     client_.reset();
  34     content::RenderViewTest::TearDown();
  35   }
  36
  37   IPC::TestSink& sink() { return render_thread_->sink(); }
  38
  39   blink::WebCredential* credential() { return credential_.get(); }
  40
  41   // The browser's response to any of the messages the client sends must contain
  42   // a request ID so that the client knows which request is being serviced. This
  43   // method grabs the ID from an outgoing |message_id| message, and sets the
  44   // |request_id| param to its value. If no request ID can be found, the method
  45   // returns false, and the |request_id| is set to -1.
  46   //
  47   // Clears any pending messages upon return.
  48   bool ExtractRequestId(uint32 message_id, int& request_id) {
  49     request_id = -1;
  50     const IPC::Message* message = sink().GetFirstMessageMatching(message_id);
  51     if (!message)
  52       return false;
  53
  54     switch (message_id) {
  55       case CredentialManagerHostMsg_NotifyFailedSignIn::ID: {
  56         base::Tuple<int, CredentialInfo> param;
  57         CredentialManagerHostMsg_NotifyFailedSignIn::Read(message, &param);
  58         request_id = base::get<0>(param);
  59         break;
  60       }
  61
  62       case CredentialManagerHostMsg_NotifySignedIn::ID: {
  63         base::Tuple<int, CredentialInfo> param;
  64         CredentialManagerHostMsg_NotifySignedIn::Read(message, &param);
  65         request_id = base::get<0>(param);
  66         break;
  67       }
  68
  69       case CredentialManagerHostMsg_RequireUserMediation::ID: {
  70         base::Tuple<int> param;
  71         CredentialManagerHostMsg_RequireUserMediation::Read(message, &param);
  72         request_id = base::get<0>(param);
  73         break;
  74       }
  75
  76       case CredentialManagerHostMsg_RequestCredential::ID: {
  77         base::Tuple<int, bool, std::vector<GURL>> param;
  78         CredentialManagerHostMsg_RequestCredential::Read(message, &param);
  79         request_id = base::get<0>(param);
  80         break;
  81       }
  82
  83       default:
  84         break;
  85     }
  86     sink().ClearMessages();
  87     return request_id != -1;
  88   }
  89
  90   bool callback_errored() const { return callback_errored_; }
  91   void set_callback_errored(bool state) { callback_errored_ = state; }
  92   bool callback_succeeded() const { return callback_succeeded_; }
  93   void set_callback_succeeded(bool state) { callback_succeeded_ = state; }
  94
  95  protected:
  96   scoped_ptr<CredentialManagerClient> client_;
  97
  98   // True if a message's callback's 'onSuccess'/'onError' methods were called,
  99   // false otherwise. We put these on the test object rather than on the
 100   // Test*Callbacks objects because ownership of those objects passes into the
 101   // client, which destroys the callbacks after calling them to resolve the
 102   // pending Blink-side Promise.
 103   bool callback_errored_;
 104   bool callback_succeeded_;
 105
 106   scoped_ptr<blink::WebPasswordCredential> credential_;
 107 };
 108
 109 class TestNotificationCallbacks
 110     : public blink::WebCredentialManagerClient::NotificationCallbacks {
 111  public:
 112   explicit TestNotificationCallbacks(CredentialManagerClientTest* test)
 113       : test_(test) {}
 114
 115   virtual ~TestNotificationCallbacks() {}
 116
 117   virtual void onSuccess() { test_->set_callback_succeeded(true); }
 118
 119   virtual void onError(blink::WebCredentialManagerError* reason) {
 120     test_->set_callback_errored(true);
 121   }
 122
 123  private:
 124   CredentialManagerClientTest* test_;
 125 };
 126
 127 class TestRequestCallbacks
 128     : public blink::WebCredentialManagerClient::RequestCallbacks {
 129  public:
 130   explicit TestRequestCallbacks(CredentialManagerClientTest* test)
 131       : test_(test) {}
 132
 133   virtual ~TestRequestCallbacks() {}
 134
 135   virtual void onSuccess(blink::WebCredential*) {
 136     test_->set_callback_succeeded(true);
 137   }
 138
 139   virtual void onError(blink::WebCredentialManagerError* reason) {
 140     test_->set_callback_errored(true);
 141   }
 142
 143  private:
 144   CredentialManagerClientTest* test_;
 145 };
 146
 147 }  // namespace
 148
 149 TEST_F(CredentialManagerClientTest, SendNotifyFailedSignIn) {
 150   int request_id;
 151   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_NotifyFailedSignIn::ID,
 152                                 request_id));
 153
 154   scoped_ptr<TestNotificationCallbacks> callbacks(
 155       new TestNotificationCallbacks(this));
 156   client_->dispatchFailedSignIn(*credential(), callbacks.release());
 157
 158   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_NotifyFailedSignIn::ID,
 159                                request_id));
 160
 161   client_->OnAcknowledgeFailedSignIn(request_id);
 162   EXPECT_TRUE(callback_succeeded());
 163   EXPECT_FALSE(callback_errored());
 164 }
 165
 166 TEST_F(CredentialManagerClientTest, SendNotifySignedIn) {
 167   int request_id;
 168   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_NotifySignedIn::ID,
 169                                 request_id));
 170
 171   scoped_ptr<TestNotificationCallbacks> callbacks(
 172       new TestNotificationCallbacks(this));
 173   client_->dispatchSignedIn(*credential(), callbacks.release());
 174
 175   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_NotifySignedIn::ID,
 176                                request_id));
 177
 178   client_->OnAcknowledgeSignedIn(request_id);
 179   EXPECT_TRUE(callback_succeeded());
 180   EXPECT_FALSE(callback_errored());
 181 }
 182
 183 TEST_F(CredentialManagerClientTest, SendRequestUserMediation) {
 184   int request_id;
 185   EXPECT_FALSE(ExtractRequestId(
 186       CredentialManagerHostMsg_RequireUserMediation::ID, request_id));
 187
 188   scoped_ptr<TestNotificationCallbacks> callbacks(
 189       new TestNotificationCallbacks(this));
 190   client_->dispatchRequireUserMediation(callbacks.release());
 191
 192   EXPECT_TRUE(ExtractRequestId(
 193       CredentialManagerHostMsg_RequireUserMediation::ID, request_id));
 194
 195   client_->OnAcknowledgeRequireUserMediation(request_id);
 196   EXPECT_TRUE(callback_succeeded());
 197   EXPECT_FALSE(callback_errored());
 198 }
 199
 200 TEST_F(CredentialManagerClientTest, SendRequestCredential) {
 201   int request_id;
 202   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
 203                                 request_id));
 204
 205   scoped_ptr<TestRequestCallbacks> callbacks(new TestRequestCallbacks(this));
 206   std::vector<GURL> federations;
 207   client_->dispatchRequest(false, federations, callbacks.release());
 208
 209   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
 210                                request_id));
 211
 212   CredentialInfo info;
 213   info.type = CredentialType::CREDENTIAL_TYPE_PASSWORD;
 214   client_->OnSendCredential(request_id, info);
 215   EXPECT_TRUE(callback_succeeded());
 216   EXPECT_FALSE(callback_errored());
 217 }
 218
 219 TEST_F(CredentialManagerClientTest, SendRequestCredentialEmpty) {
 220   int request_id;
 221   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
 222                                 request_id));
 223
 224   scoped_ptr<TestRequestCallbacks> callbacks(new TestRequestCallbacks(this));
 225   std::vector<GURL> federations;
 226   client_->dispatchRequest(false, federations, callbacks.release());
 227
 228   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
 229                                request_id));
 230
 231   CredentialInfo info;  // Send an empty credential in response.
 232   client_->OnSendCredential(request_id, info);
 233   EXPECT_TRUE(callback_succeeded());
 234   EXPECT_FALSE(callback_errored());
 235 }
 236
 237 }  // namespace password_manager