Added gcdPrivate.getDeviceInfo function

chrome/browser/local_discovery/privetv3_session_unittest.cc

 // 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 "chrome/browser/local_discovery/privetv3_session.h"
 
 #include "base/base64.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/local_discovery/privet_http.h"
 #include "content/public/test/test_utils.h"
@@ skipping 62 matching lines @@
 }  // namespace
 
 class PrivetV3SessionTest : public testing::Test {
  public:
   PrivetV3SessionTest()
       : fetcher_factory_(nullptr),
         session_(make_scoped_ptr(new MockPrivetHTTPClient())) {}
 
   ~PrivetV3SessionTest() override {}
 
-  MOCK_METHOD2(OnInitialized, void(Result, const std::vector<PairingType>&));
+  void OnInitialized(Result result, const base::DictionaryValue& info) {
+    info_.MergeDictionary(&info);
+    OnInitializedMock(result, info);
+  }
+
+  MOCK_METHOD2(OnInitializedMock, void(Result, const base::DictionaryValue&));
   MOCK_METHOD1(OnPairingStarted, void(Result));
   MOCK_METHOD1(OnCodeConfirmed, void(Result));
-  MOCK_METHOD2(OnMessageSend, void(Result, const base::DictionaryValue& value));
-  MOCK_METHOD1(OnPostData, void(const base::DictionaryValue& data));
+  MOCK_METHOD2(OnMessageSend, void(Result, const base::DictionaryValue&));
+  MOCK_METHOD1(OnPostData, void(const base::DictionaryValue&));
 
  protected:
   void SetUp() override {
-    EXPECT_CALL(*this, OnInitialized(_, _)).Times(0);
+    EXPECT_CALL(*this, OnInitializedMock(_, _)).Times(0);
     EXPECT_CALL(*this, OnPairingStarted(_)).Times(0);
     EXPECT_CALL(*this, OnCodeConfirmed(_)).Times(0);
     EXPECT_CALL(*this, OnMessageSend(_, _)).Times(0);
     EXPECT_CALL(*this, OnPostData(_)).Times(0);
     session_.on_post_data_ =
         base::Bind(&PrivetV3SessionTest::OnPostData, base::Unretained(this));
   }
 
+  base::DictionaryValue info_;
   base::MessageLoop loop_;
   base::Closure quit_closure_;
   net::FakeURLFetcherFactory fetcher_factory_;
   PrivetV3Session session_;
 };
 
 TEST_F(PrivetV3SessionTest, InitError) {
-  EXPECT_CALL(*this, OnInitialized(Result::STATUS_CONNECTIONERROR, _)).Times(1);
+  EXPECT_CALL(*this, OnInitializedMock(Result::STATUS_CONNECTIONERROR, _))
+      .Times(1);
   fetcher_factory_.SetFakeResponse(GURL("http://host/privet/info"), "",
                                    net::HTTP_OK, net::URLRequestStatus::FAILED);
   session_.Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PrivetV3SessionTest, VersionError) {
   std::string response(kInfoResponse);
   ReplaceFirstSubstringAfterOffset(&response, 0, "3.0", "4.1");
 
-  EXPECT_CALL(*this, OnInitialized(Result::STATUS_SESSIONERROR, _)).Times(1);
+  EXPECT_CALL(*this, OnInitializedMock(Result::STATUS_SESSIONERROR, _))
+      .Times(1);
   fetcher_factory_.SetFakeResponse(GURL("http://host/privet/info"), response,
                                    net::HTTP_OK,
                                    net::URLRequestStatus::SUCCESS);
   session_.Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PrivetV3SessionTest, ModeError) {
   std::string response(kInfoResponse);
   ReplaceFirstSubstringAfterOffset(&response, 0, "mode", "mode_");
 
-  EXPECT_CALL(*this, OnInitialized(Result::STATUS_SESSIONERROR, _)).Times(1);
+  EXPECT_CALL(*this, OnInitializedMock(Result::STATUS_SESSIONERROR, _))
+      .Times(1);
   fetcher_factory_.SetFakeResponse(GURL("http://host/privet/info"), response,
                                    net::HTTP_OK,
                                    net::URLRequestStatus::SUCCESS);
   session_.Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PrivetV3SessionTest, Pairing) {
-  std::vector<PairingType> pairings;
-  EXPECT_CALL(*this, OnInitialized(Result::STATUS_SUCCESS, _))
-      .WillOnce(SaveArg<1>(&pairings));
+  EXPECT_CALL(*this, OnInitializedMock(Result::STATUS_SUCCESS, _))
+      .Times(1);
   fetcher_factory_.SetFakeResponse(GURL("http://host/privet/info"),
                                    kInfoResponse, net::HTTP_OK,
                                    net::URLRequestStatus::SUCCESS);
 
   session_.Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(2u, pairings.size());
-  EXPECT_EQ(PairingType::PAIRING_TYPE_PINCODE, pairings[0]);
-  EXPECT_EQ(PairingType::PAIRING_TYPE_EMBEDDEDCODE, pairings[1]);
+  const base::ListValue* pairing = nullptr;
+  ASSERT_TRUE(info_.GetList("authentication.pairing", &pairing));
+
+  std::string pairing_string;
+  ASSERT_TRUE(pairing->GetString(0, &pairing_string));
+  EXPECT_EQ("pinCode", pairing_string);
+
+  ASSERT_TRUE(pairing->GetString(1, &pairing_string));
+  EXPECT_EQ("embeddedCode", pairing_string);
 
   crypto::P224EncryptedKeyExchange spake(
       crypto::P224EncryptedKeyExchange::kPeerTypeServer, "testPin");
 
   EXPECT_CALL(*this, OnPairingStarted(Result::STATUS_SUCCESS)).Times(1);
   EXPECT_CALL(*this, OnPostData(_))
       .WillOnce(
           testing::Invoke([this, &spake](const base::DictionaryValue& data) {
             std::string pairing_type;
             EXPECT_TRUE(data.GetString("pairing", &pairing_type));
@@ skipping 81 matching lines @@
   session_.ConfirmCode("testPin",
                        base::Bind(&PrivetV3SessionTest::OnCodeConfirmed,
                                   base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(session_.fingerprint_.empty());
   EXPECT_EQ("testType 567", session_.privet_auth_token_);
 }
 
 TEST_F(PrivetV3SessionTest, Cancel) {
-  EXPECT_CALL(*this, OnInitialized(Result::STATUS_SUCCESS, _));
+  EXPECT_CALL(*this, OnInitializedMock(Result::STATUS_SUCCESS, _)).Times(1);;
   fetcher_factory_.SetFakeResponse(GURL("http://host/privet/info"),
                                    kInfoResponse, net::HTTP_OK,
                                    net::URLRequestStatus::SUCCESS);
 
   session_.Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*this, OnPairingStarted(Result::STATUS_SUCCESS)).Times(1);
   EXPECT_CALL(*this, OnPostData(_))
@@ skipping 19 matching lines @@
       .WillOnce(testing::Invoke([this](const base::DictionaryValue& data) {
         std::string session_id;
         EXPECT_TRUE(data.GetString("sessionId", &session_id));
       }));
 }
 
 // TODO(vitalybuka): replace PrivetHTTPClient with regular URL fetcher and
 // implement SendMessage test.
 
 }  // namespace local_discovery