WIP: NSS trust store integration for path builder.

net/cert/internal/cert_issuer_source_aia_unittest.cc

 // Copyright 2016 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 "net/cert/internal/cert_issuer_source_aia.h"
 
 #include "base/bind.h"
 #include "net/cert/cert_net_fetcher.h"
+#include "net/cert/internal/cert_issuer_source_test_helpers.h"
 #include "net/cert/internal/parsed_certificate.h"
 #include "net/cert/internal/test_helpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 124 matching lines @@
     NOTREACHED();
     return nullptr;
   }
 
  private:
   std::map<GURL, std::unique_ptr<RequestManager>> request_map_;
 
   DISALLOW_COPY_AND_ASSIGN(MockCertNetFetcherImpl);
 };
 
-class MockIssuerCallback {
- public:
-  MOCK_METHOD1(Callback, void(CertIssuerSource::Request*));
-};
-
 void NotCalled(CertIssuerSource::Request* request) {
   ADD_FAILURE() << "NotCalled was called";
 }
 
 // CertIssuerSourceAia does not return results for SyncGetIssuersOf.
 TEST(CertIssuerSourceAiaTest, NoSyncResults) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_two_aia.pem", &cert));
 
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   ParsedCertificateList issuers;
   aia_source.SyncGetIssuersOf(cert.get(), &issuers);
   EXPECT_EQ(0U, issuers.size());
 }
 
 // If the AuthorityInfoAccess extension is not present, AsyncGetIssuersOf should
 // synchronously indicate no results.
 TEST(CertIssuerSourceAiaTest, NoAia) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_no_aia.pem", &cert));
 
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> request;
-  aia_source.AsyncGetIssuersOf(cert.get(), base::Bind(&NotCalled), &request);
+  aia_source.AsyncGetIssuersOf(cert, base::Bind(&NotCalled), &request);
   EXPECT_EQ(nullptr, request);
 }
 
 // If the AuthorityInfoAccess extension only contains non-HTTP URIs,
 // AsyncGetIssuersOf should create a Request object. The URL scheme check is
 // part of the specific CertNetFetcher implementation, this tests that we handle
 // ERR_DISALLOWED_URL_SCHEME properly. If FetchCaIssuers is modified to fail
 // synchronously in that case, this test will be more interesting.
 TEST(CertIssuerSourceAiaTest, FileAia) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_file_aia.pem", &cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("file:///dev/null"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 12 matching lines @@
 
 // If the AuthorityInfoAccess extension contains an invalid URL,
 // AsyncGetIssuersOf should synchronously indicate no results.
 TEST(CertIssuerSourceAiaTest, OneInvalidURL) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_invalid_url_aia.pem", &cert));
 
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> request;
-  aia_source.AsyncGetIssuersOf(cert.get(), base::Bind(&NotCalled), &request);
+  aia_source.AsyncGetIssuersOf(cert, base::Bind(&NotCalled), &request);
   EXPECT_EQ(nullptr, request);
 }
 
 // AuthorityInfoAccess with a single HTTP url pointing to a single DER cert.
 TEST(CertIssuerSourceAiaTest, OneAia) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_one_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert;
   ASSERT_TRUE(ReadTestCert("i.pem", &intermediate_cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 23 matching lines @@
 TEST(CertIssuerSourceAiaTest, OneFileOneHttpAia) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_file_and_http_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert;
   ASSERT_TRUE(ReadTestCert("i2.pem", &intermediate_cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("file:///dev/null"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 32 matching lines @@
 TEST(CertIssuerSourceAiaTest, OneInvalidOneHttpAia) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_invalid_and_http_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert;
   ASSERT_TRUE(ReadTestCert("i2.pem", &intermediate_cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia2/I2.foo"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 24 matching lines @@
   ASSERT_TRUE(ReadTestCert("target_two_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert;
   ASSERT_TRUE(ReadTestCert("i.pem", &intermediate_cert));
   scoped_refptr<ParsedCertificate> intermediate_cert2;
   ASSERT_TRUE(ReadTestCert("i2.pem", &intermediate_cert2));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 55 matching lines @@
   ASSERT_TRUE(ReadTestCert("target_two_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert;
   ASSERT_TRUE(ReadTestCert("i.pem", &intermediate_cert));
   scoped_refptr<ParsedCertificate> intermediate_cert2;
   ASSERT_TRUE(ReadTestCert("i2.pem", &intermediate_cert2));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 51 matching lines @@
   ASSERT_TRUE(ReadTestCert("i.pem", &intermediate_cert));
   scoped_refptr<ParsedCertificate> intermediate_cert2;
   ASSERT_TRUE(ReadTestCert("i2.pem", &intermediate_cert2));
   scoped_refptr<ParsedCertificate> intermediate_cert3;
   ASSERT_TRUE(ReadTestCert("i3.pem", &intermediate_cert3));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 55 matching lines @@
 // CertNetFetcher request fails.  The callback should be called to indicate the
 // request is complete, but no results should be provided.
 TEST(CertIssuerSourceAiaTest, OneAiaHttpError) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_one_aia.pem", &cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 13 matching lines @@
 // callback should be called to indicate the request is complete, but no results
 // should be provided.
 TEST(CertIssuerSourceAiaTest, OneAiaParseError) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_one_aia.pem", &cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 14 matching lines @@
 TEST(CertIssuerSourceAiaTest, TwoAiaCompletedInSeriesFirstFails) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_two_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert2;
   ASSERT_TRUE(ReadTestCert("i2.pem", &intermediate_cert2));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 33 matching lines @@
 TEST(CertIssuerSourceAiaTest, TwoAiaCompletedInSeriesSecondFails) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_two_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert;
   ASSERT_TRUE(ReadTestCert("i.pem", &intermediate_cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 37 matching lines @@
 // AuthorityInfoAccess with two HTTP urls. Request is cancelled before any HTTP
 // requests finish.
 TEST(CertIssuerSourceAiaTest, CertSourceRequestCancelled) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_two_aia.pem", &cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 15 matching lines @@
 TEST(CertIssuerSourceAiaTest, TwoAiaOneCompletedThenRequestCancelled) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_two_aia.pem", &cert));
   scoped_refptr<ParsedCertificate> intermediate_cert;
   ASSERT_TRUE(ReadTestCert("i.pem", &intermediate_cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   ASSERT_TRUE(req_manager->is_request_alive());
 
@@ skipping 30 matching lines @@
 // AuthorityInfoAccess with six HTTP URLs.  kMaxFetchesPerCert is 5, so the
 // sixth URL should be ignored.
 TEST(CertIssuerSourceAiaTest, MaxFetchesPerCert) {
   scoped_refptr<ParsedCertificate> cert;
   ASSERT_TRUE(ReadTestCert("target_six_aia.pem", &cert));
 
   StrictMock<MockIssuerCallback> mock_callback;
   StrictMock<MockCertNetFetcherImpl> mock_fetcher;
   CertIssuerSourceAia aia_source(&mock_fetcher);
   std::unique_ptr<CertIssuerSource::Request> cert_source_request;
-  aia_source.AsyncGetIssuersOf(cert.get(),
+  aia_source.AsyncGetIssuersOf(cert,
                                base::Bind(&MockIssuerCallback::Callback,
                                           base::Unretained(&mock_callback)),
                                &cert_source_request);
   ASSERT_NE(nullptr, cert_source_request);
 
   RequestManager* req_manager =
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia/I.cer"));
   ASSERT_TRUE(req_manager);
   EXPECT_TRUE(req_manager->is_request_alive());
 
@@ skipping 18 matching lines @@
   EXPECT_TRUE(req_manager5->is_request_alive());
 
   // Sixth URL should not have created a request.
   EXPECT_FALSE(
       mock_fetcher.GetRequestManagerForURL(GURL("http://url-for-aia6/I6.foo")));
 }
 
 }  // namespace
 
 }  // namespace net