*WIP* Mac Unittest for client cert selection with intermediate certs

net/ssl/client_cert_store_mac_unittest.cc

 // Copyright 2013 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/ssl/client_cert_store_mac.h"
 
+#include "base/files/file_util.h"
+#include "base/run_loop.h"
+#include "net/cert/test_keychain_search_list_mac.h"
 #include "net/ssl/client_cert_store_unittest-inl.h"
 
 namespace net {
 
 class ClientCertStoreMacTestDelegate {
  public:
   bool SelectClientCerts(const CertificateList& input_certs,
                          const SSLCertRequestInfo& cert_request_info,
                          CertificateList* selected_certs) {
     return store_.SelectClientCertsForTesting(
         input_certs, cert_request_info, selected_certs);
   }
 
  private:
   ClientCertStoreMac store_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(Mac,
                               ClientCertStoreTest,
                               ClientCertStoreMacTestDelegate);
 
+class ClientCertStoreChainMacTestDelegate {
+ public:
+  ClientCertStoreChainMacTestDelegate() {
+    test_keychain_search_list_ = TestKeychainSearchList::Create();
+    CHECK(test_keychain_search_list_);
+  }
+
+  scoped_refptr<X509Certificate> ImportCertAndKeychain(
+      const std::string& name) {
+    base::FilePath keychain_path(
+        GetTestCertsDirectory().AppendASCII(name + ".keychain"));
+    // SecKeychainOpen does not fail if the file doesn't exist, so assert it
+    // here
+    // for easier debugging.
+    if (!base::PathExists(keychain_path)) {
+      ADD_FAILURE() << "keychain doesn't exist:"
+                    << keychain_path.MaybeAsASCII();
+      return nullptr;
+    }
+    SecKeychainRef keychain;
+    OSStatus status =
+        SecKeychainOpen(keychain_path.MaybeAsASCII().c_str(), &keychain);
+    EXPECT_EQ(errSecSuccess, status);
+    EXPECT_TRUE(keychain);
+    if (status != errSecSuccess || !keychain)
+      return nullptr;
+    base::ScopedCFTypeRef<SecKeychainRef> scoped_keychain(keychain);
+    test_keychain_search_list_->AddKeychain(keychain);
+
+    return ImportCertFromFile(GetTestCertsDirectory(), name + ".pem");
+  }
+
+  scoped_refptr<X509Certificate> ImportClientCert(const std::string& name) {
+    return ImportCertAndKeychain(name);
+    /*return ImportClientCertAndKeyFromFile(
+        GetTestCertsDirectory(), name + ".pem", name + ".pk8",
+       test_db.slot());*/
+  }
+
+  scoped_refptr<X509Certificate> ImportClientIntermediate(
+      const std::string& name) {
+    return ImportCertAndKeychain(name);
+  }
+
+  void GetClientCerts(const SSLCertRequestInfo& cert_request_info,
+                      CertificateList* selected_certs) {
+    base::RunLoop loop;
+    store_.GetClientCerts(cert_request_info, selected_certs,
+                          loop.QuitClosure());
+    loop.Run();
+  }
+
+ protected:
+  std::unique_ptr<TestKeychainSearchList> test_keychain_search_list_;
+  ClientCertStoreMac store_;
+};
+
+INSTANTIATE_TYPED_TEST_CASE_P(Mac,
+                              ClientCertStoreChainTest,
+                              ClientCertStoreChainMacTestDelegate);
+
 class ClientCertStoreMacTest : public ::testing::Test {
  protected:
   bool SelectClientCertsGivenPreferred(
       const scoped_refptr<X509Certificate>& preferred_cert,
       const CertificateList& regular_certs,
       const SSLCertRequestInfo& request,
       CertificateList* selected_certs) {
     return store_.SelectClientCertsGivenPreferredForTesting(
         preferred_cert, regular_certs, request, selected_certs);
   }
@@ skipping 42 matching lines @@
   std::vector<scoped_refptr<X509Certificate> > selected_certs;
   bool rv = SelectClientCertsGivenPreferred(
       cert_1, certs, *request.get(), &selected_certs);
   EXPECT_TRUE(rv);
   ASSERT_EQ(2u, selected_certs.size());
   EXPECT_TRUE(selected_certs[0]->Equals(cert_1.get()));
   EXPECT_TRUE(selected_certs[1]->Equals(cert_2.get()));
 }
 
 }  // namespace net