Implement CUP signing in UpdateClient.

components/update_client/update_checker_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 29 matching lines @@
 
 class UpdateCheckerTest : public testing::Test {
  public:
   UpdateCheckerTest();
   ~UpdateCheckerTest() override;
 
   // Overrides from testing::Test.
   void SetUp() override;
   void TearDown() override;
 
-  void UpdateCheckComplete(const GURL& original_url,
-                           int error,
-                           const std::string& error_message,
-                           const UpdateResponse::Results& results);
+  void UpdateCheckComplete(int error, const UpdateResponse::Results& results);
 
  protected:
   void Quit();
   void RunThreads();
   void RunThreadsUntilIdle();
 
   CrxUpdateItem BuildCrxUpdateItem();
 
   scoped_refptr<TestConfigurator> config_;
 
   scoped_ptr<UpdateChecker> update_checker_;
 
   scoped_ptr<InterceptorFactory> interceptor_factory_;
   URLRequestPostInterceptor* post_interceptor_;  // Owned by the factory.
 
-  GURL original_url_;
   int error_;
-  std::string error_message_;
   UpdateResponse::Results results_;
 
  private:
   base::MessageLoopForIO loop_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckerTest);
 };
 
 UpdateCheckerTest::UpdateCheckerTest() : post_interceptor_(NULL), error_(0) {
 }
 
 UpdateCheckerTest::~UpdateCheckerTest() {
 }
 
 void UpdateCheckerTest::SetUp() {
   config_ = new TestConfigurator(base::ThreadTaskRunnerHandle::Get(),
                                  base::ThreadTaskRunnerHandle::Get());
   interceptor_factory_.reset(
       new InterceptorFactory(base::ThreadTaskRunnerHandle::Get()));
   post_interceptor_ = interceptor_factory_->CreateInterceptor();
   EXPECT_TRUE(post_interceptor_);
 
   update_checker_.reset();
 
   error_ = 0;
-  error_message_.clear();
   results_ = UpdateResponse::Results();
 }
 
 void UpdateCheckerTest::TearDown() {
   update_checker_.reset();
 
   post_interceptor_ = NULL;
   interceptor_factory_.reset();
 
   config_ = nullptr;
@@ skipping 18 matching lines @@
 void UpdateCheckerTest::RunThreadsUntilIdle() {
   base::RunLoop().RunUntilIdle();
 }
 
 void UpdateCheckerTest::Quit() {
   if (!quit_closure_.is_null())
     quit_closure_.Run();
 }
 
 void UpdateCheckerTest::UpdateCheckComplete(
-    const GURL& original_url,
     int error,
-    const std::string& error_message,
     const UpdateResponse::Results& results) {
-  original_url_ = original_url;
   error_ = error;
-  error_message_ = error_message;
   results_ = results;
   Quit();
 }
 
 CrxUpdateItem UpdateCheckerTest::BuildCrxUpdateItem() {
   CrxComponent crx_component;
   crx_component.name = "test_jebg";
   crx_component.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
   crx_component.installer = NULL;
   crx_component.version = base::Version("0.9");
@@ skipping 38 matching lines @@
   EXPECT_NE(
       string::npos,
       post_interceptor_->GetRequests()[0].find(
           "app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"0.9\">"
           "<updatecheck /><packages><package fp=\"fp1\"/></packages></app>"));
 
   EXPECT_NE(string::npos,
             post_interceptor_->GetRequests()[0].find("<hw physmemory="));
 
   // Sanity check the arguments of the callback after parsing.
-  ASSERT_FALSE(config_->UpdateUrl().empty());
-  EXPECT_EQ(config_->UpdateUrl().front(), original_url_);
   EXPECT_EQ(0, error_);
-  EXPECT_TRUE(error_message_.empty());
   EXPECT_EQ(1ul, results_.list.size());
   EXPECT_STREQ("jebgalgnebhfojomionfpkfelancnnkf",
                results_.list[0].extension_id.c_str());
   EXPECT_STREQ("1.0", results_.list[0].manifest.version.c_str());
 }
 
 // Simulates a 403 server response error.
 TEST_F(UpdateCheckerTest, UpdateCheckError) {
   EXPECT_TRUE(
       post_interceptor_->ExpectRequest(new PartialMatch("updatecheck"), 403));
 
   update_checker_ = UpdateChecker::Create(config_);
 
   CrxUpdateItem item(BuildCrxUpdateItem());
   std::vector<CrxUpdateItem*> items_to_check;
   items_to_check.push_back(&item);
 
   update_checker_->CheckForUpdates(
       items_to_check, "", base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                                      base::Unretained(this)));
-
   RunThreads();
 
   EXPECT_EQ(1, post_interceptor_->GetHitCount())
       << post_interceptor_->GetRequestsAsString();
   EXPECT_EQ(1, post_interceptor_->GetCount())
       << post_interceptor_->GetRequestsAsString();
 
-  ASSERT_FALSE(config_->UpdateUrl().empty());
-  EXPECT_EQ(config_->UpdateUrl().front(), original_url_);
   EXPECT_EQ(403, error_);
-  EXPECT_STREQ("network error", error_message_.c_str());
   EXPECT_EQ(0ul, results_.list.size());
 }
 
 TEST_F(UpdateCheckerTest, UpdateCheckDownloadPreference) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   config_->SetDownloadPreference(string("cacheable"));
 
   update_checker_ = UpdateChecker::Create(config_);
 
   CrxUpdateItem item(BuildCrxUpdateItem());
   std::vector<CrxUpdateItem*> items_to_check;
   items_to_check.push_back(&item);
 
   update_checker_->CheckForUpdates(
       items_to_check, "extra=\"params\"",
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
 
   RunThreads();
 
   // The request must contain dlpref="cacheable".
   EXPECT_NE(string::npos,
             post_interceptor_->GetRequests()[0].find(" dlpref=\"cacheable\""));
 }
 
+// This test is checking that an update check signed with CUP fails, since there
+// is currently no entity that can respond with a valid signed response.
+// A proper CUP test requires network mocks, which are not available now.
+TEST_F(UpdateCheckerTest, UpdateCheckCupError) {
+  EXPECT_TRUE(post_interceptor_->ExpectRequest(
+      new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
+
+  config_->SetUseCupSigning(true);
+  update_checker_ = UpdateChecker::Create(config_);
+
+  CrxUpdateItem item(BuildCrxUpdateItem());
+  std::vector<CrxUpdateItem*> items_to_check;
+  items_to_check.push_back(&item);
+
+  update_checker_->CheckForUpdates(
+      items_to_check, "", base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
+                                     base::Unretained(this)));
+
+  RunThreads();
+
+  EXPECT_EQ(1, post_interceptor_->GetHitCount())
+      << post_interceptor_->GetRequestsAsString();
+  ASSERT_EQ(1, post_interceptor_->GetCount())
+      << post_interceptor_->GetRequestsAsString();
+
+  // Sanity check the request.
+  EXPECT_NE(
+      string::npos,
+      post_interceptor_->GetRequests()[0].find(
+          "app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"0.9\">"
+          "<updatecheck /><packages><package fp=\"fp1\"/></packages></app>"));
+
+  // Expect an error since the response is not trusted.
+  EXPECT_EQ(-10000, error_);
+  EXPECT_EQ(0ul, results_.list.size());
+}
+
 }  // namespace update_client