Initialize session in ::SetUp method instead of constructor

chrome/browser/extensions/api/gcd_private/privet_v3_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/extensions/api/gcd_private/privet_v3_session.h"
 
 #include "base/base64.h"
+#include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/local_discovery/privet_http.h"
+#include "chrome/common/chrome_switches.h"
 #include "content/public/test/test_utils.h"
 #include "crypto/hmac.h"
 #include "crypto/p224_spake.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using local_discovery::PrivetHTTPClient;
 using local_discovery::PrivetJSONOperation;
@@ skipping 58 matching lines @@
         url, request_type, request_context_.get(), delegate));
   }
 
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 };
 
 }  // namespace
 
 class PrivetV3SessionTest : public testing::Test {
  public:
-  PrivetV3SessionTest()
-      : fetcher_factory_(nullptr),
-        http_client_(new StrictMock<MockPrivetHTTPClient>()),
-        session_(make_scoped_ptr(http_client_)) {}
+  PrivetV3SessionTest() : fetcher_factory_(nullptr) {}
 
   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&));
   MOCK_METHOD1(OnPostData, void(const base::DictionaryValue&));
 
  protected:
   void SetUp() override {
-    session_.on_post_data_ =
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnablePrivetV3);
+
+    http_client_ = new StrictMock<MockPrivetHTTPClient>();
+    session_.reset(new PrivetV3Session(make_scoped_ptr(http_client_)));
+
+    session_->on_post_data_ =
         base::Bind(&PrivetV3SessionTest::OnPostData, base::Unretained(this));
 
     EXPECT_CALL(*http_client_, IsInHttpsMode()).WillRepeatedly(Return(false));
+    EXPECT_CALL(*http_client_, GetHost()).WillRepeatedly(Return("1.1.1.1"));
   }
 
   base::MessageLoop loop_;
   net::FakeURLFetcherFactory fetcher_factory_;
-  StrictMock<MockPrivetHTTPClient>* http_client_;
+  StrictMock<MockPrivetHTTPClient>* http_client_ = nullptr;
   base::DictionaryValue info_;
   base::Closure quit_closure_;
-  PrivetV3Session session_;
+  scoped_ptr<PrivetV3Session> session_;
 };
 
 TEST_F(PrivetV3SessionTest, InitError) {
   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(
+  session_->Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PrivetV3SessionTest, VersionError) {
   std::string response(kInfoResponse);
   base::ReplaceFirstSubstringAfterOffset(&response, 0, "3.0", "4.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(
+  session_->Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PrivetV3SessionTest, ModeError) {
   std::string response(kInfoResponse);
   base::ReplaceFirstSubstringAfterOffset(&response, 0, "mode", "mode_");
 
   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(
+  session_->Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PrivetV3SessionTest, NoHttpsError) {
   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(
+  session_->Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*this, OnMessageSend(Result::STATUS_SESSIONERROR, _)).Times(1);
-  session_.SendMessage(
+  session_->SendMessage(
       "/privet/v3/state", base::DictionaryValue(),
       base::Bind(&PrivetV3SessionTest::OnMessageSend, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PrivetV3SessionTest, Pairing) {
   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(
+  session_->Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   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);
 
@@ skipping 16 matching lines @@
 
         std::string device_commitment;
         base::Base64Encode(spake.GetNextMessage(), &device_commitment);
         fetcher_factory_.SetFakeResponse(
             GURL("http://host/privet/v3/pairing/start"),
             base::StringPrintf(
                 "{\"deviceCommitment\":\"%s\",\"sessionId\":\"testId\"}",
                 device_commitment.c_str()),
             net::HTTP_OK, net::URLRequestStatus::SUCCESS);
       }));
-  session_.StartPairing(PairingType::PAIRING_TYPE_EMBEDDEDCODE,
-                        base::Bind(&PrivetV3SessionTest::OnPairingStarted,
-                                   base::Unretained(this)));
+  session_->StartPairing(PairingType::PAIRING_TYPE_EMBEDDEDCODE,
+                         base::Bind(&PrivetV3SessionTest::OnPairingStarted,
+                                    base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ("Privet anonymous", session_.privet_auth_token_);
+  EXPECT_EQ("Privet anonymous", session_->privet_auth_token_);
 
   std::string fingerprint("testFingerprint  testFingerprint");
   net::SHA256HashValue sha_fingerprint;
   ASSERT_EQ(sizeof(sha_fingerprint.data), fingerprint.size());
   memcpy(sha_fingerprint.data, fingerprint.data(), fingerprint.size());
 
   EXPECT_CALL(*http_client_,
               SwitchToHttps(443, Field(&net::SHA256HashValue::data,
                                        ElementsAreArray(sha_fingerprint.data))))
       .WillOnce(InvokeWithoutArgs([this]() {
@@ skipping 48 matching lines @@
         const std::string& key = spake.GetUnverifiedKey();
         EXPECT_TRUE(hmac.Init(key));
         EXPECT_TRUE(hmac.Verify("testId", access_token));
 
         fetcher_factory_.SetFakeResponse(
             GURL("http://host/privet/v3/auth"),
             "{\"accessToken\":\"567\",\"tokenType\":\"testType\","
             "\"scope\":\"owner\"}",
             net::HTTP_OK, net::URLRequestStatus::SUCCESS);
       }));
-  session_.ConfirmCode("testPin",
-                       base::Bind(&PrivetV3SessionTest::OnCodeConfirmed,
-                                  base::Unretained(this)));
+  session_->ConfirmCode("testPin",
+                        base::Bind(&PrivetV3SessionTest::OnCodeConfirmed,
+                                   base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(session_.client_->IsInHttpsMode());
-  EXPECT_EQ("testType 567", session_.privet_auth_token_);
+  EXPECT_TRUE(session_->client_->IsInHttpsMode());
+  EXPECT_EQ("testType 567", session_->privet_auth_token_);
 }
 
 TEST_F(PrivetV3SessionTest, Cancel) {
   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(
+  session_->Init(
       base::Bind(&PrivetV3SessionTest::OnInitialized, base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*http_client_, IsInHttpsMode()).WillRepeatedly(Return(false));
 
   EXPECT_CALL(*this, OnPairingStarted(Result::STATUS_SUCCESS)).Times(1);
   EXPECT_CALL(*this, OnPostData(_))
       .WillOnce(Invoke([this](const base::DictionaryValue& data) {
         std::string device_commitment;
         base::Base64Encode("1234", &device_commitment);
         fetcher_factory_.SetFakeResponse(
             GURL("http://host/privet/v3/pairing/start"),
             base::StringPrintf(
                 "{\"deviceCommitment\":\"%s\",\"sessionId\":\"testId\"}",
                 device_commitment.c_str()),
             net::HTTP_OK, net::URLRequestStatus::SUCCESS);
       }));
-  session_.StartPairing(PairingType::PAIRING_TYPE_EMBEDDEDCODE,
-                        base::Bind(&PrivetV3SessionTest::OnPairingStarted,
-                                   base::Unretained(this)));
+  session_->StartPairing(PairingType::PAIRING_TYPE_EMBEDDEDCODE,
+                         base::Bind(&PrivetV3SessionTest::OnPairingStarted,
+                                    base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   fetcher_factory_.SetFakeResponse(GURL("http://host/privet/v3/pairing/cancel"),
                                    kInfoResponse, net::HTTP_OK,
                                    net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*this, OnPostData(_))
       .WillOnce(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 extensions