AU: Separate error codes for different OmahaRequestAction failures.

omaha_request_action_unittest.cc

 // Copyright (c) 2010 The Chromium OS 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 <string>
 #include <vector>
 
 #include <glib.h>
 
 #include "base/string_util.h"
@@ skipping 127 matching lines @@
   // Debugging/logging
   static std::string StaticType() {
     return "OutputObjectCollectorAction";
   }
   std::string Type() const { return StaticType(); }
   bool has_input_object_;
   OmahaResponse omaha_response_;
 };
 
 // Returns true iff an output response was obtained from the
-// OmahaRequestAction. |prefs| may be NULL, in which case a local
-// PrefsMock is used. out_response may be NULL.  out_post_data may be
-// null; if non-null, the post-data received by the mock HttpFetcher
-// is returned.
+// OmahaRequestAction. |prefs| may be NULL, in which case a local PrefsMock is
+// used. out_response may be NULL. If |fail_http_response_code| is
+// non-negative, the transfer will fail with that code. out_post_data may be
+// null; if non-null, the post-data received by the mock HttpFetcher is
+// returned.
 bool TestUpdateCheck(PrefsInterface* prefs,
                      const OmahaRequestParams& params,
                      const string& http_response,
+                     int fail_http_response_code,
                      ActionExitCode expected_code,
                      OmahaResponse* out_response,
                      vector<char>* out_post_data) {
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   MockHttpFetcher* fetcher = new MockHttpFetcher(http_response.data(),
                                                  http_response.size());
+  if (fail_http_response_code >= 0) {
+    fetcher->FailTransfer(fail_http_response_code);
+  }
   PrefsMock local_prefs;
   OmahaRequestAction action(prefs ? prefs : &local_prefs,
                             params,
                             NULL,
                             fetcher);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   delegate.expected_code_ = expected_code;
 
   ActionProcessor processor;
@@ skipping 38 matching lines @@
   if (out_post_data)
     *out_post_data = fetcher->post_data();
 }
 
 TEST(OmahaRequestActionTest, NoUpdateTest) {
   OmahaResponse response;
   ASSERT_TRUE(
       TestUpdateCheck(NULL,  // prefs
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
+                      -1,
                       kActionCodeSuccess,
                       &response,
                       NULL));
   EXPECT_FALSE(response.update_exists);
 }
 
 TEST(OmahaRequestActionTest, ValidUpdateTest) {
   OmahaResponse response;
   ASSERT_TRUE(
       TestUpdateCheck(NULL,  // prefs
                       kDefaultTestParams,
                       GetUpdateResponse(OmahaRequestParams::kAppId,
                                         "1.2.3.4",  // version
                                         "http://more/info",
                                         "true",  // prompt
                                         "http://code/base",  // dl url
                                         "HASH1234=",  // checksum
                                         "false",  // needs admin
                                         "123",  // size
                                         "20101020"),  // deadline
+                      -1,
                       kActionCodeSuccess,
                       &response,
                       NULL));
   EXPECT_TRUE(response.update_exists);
   EXPECT_EQ("1.2.3.4", response.display_version);
   EXPECT_EQ("http://code/base", response.codebase);
   EXPECT_EQ("http://more/info", response.more_info_url);
   EXPECT_TRUE(response.is_delta);
   EXPECT_EQ("HASH1234=", response.hash);
   EXPECT_EQ(123, response.size);
@@ skipping 22 matching lines @@
   g_main_loop_unref(loop);
   EXPECT_FALSE(processor.IsRunning());
 }
 
 TEST(OmahaRequestActionTest, InvalidXmlTest) {
   OmahaResponse response;
   ASSERT_FALSE(
       TestUpdateCheck(NULL,  // prefs
                       kDefaultTestParams,
                       "invalid xml>",
-                      kActionCodeError,
+                      -1,
+                      kActionCodeOmahaRequestXMLParseError,
                       &response,
                       NULL));
   EXPECT_FALSE(response.update_exists);
+}
+
+TEST(OmahaRequestActionTest, EmptyResponseTest) {
+  OmahaResponse response;
+  ASSERT_FALSE(
+      TestUpdateCheck(NULL,  // prefs
+                      kDefaultTestParams,
+                      "",
+                      -1,
+                      kActionCodeOmahaRequestEmptyResponseError,
+                      &response,
+                      NULL));
+  EXPECT_FALSE(response.update_exists);
 }
 
 TEST(OmahaRequestActionTest, MissingStatusTest) {
   OmahaResponse response;
   ASSERT_FALSE(TestUpdateCheck(
       NULL,  // prefs
       kDefaultTestParams,
       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
       "xmlns=\"http://www.google.com/update2/response\" protocol=\"2.0\"><app "
       "appid=\"foo\" status=\"ok\"><ping "
       "status=\"ok\"/><updatecheck/></app></gupdate>",
-      kActionCodeError,
+      -1,
+      kActionCodeOmahaRequestNoUpdateCheckStatus,
       &response,
       NULL));
   EXPECT_FALSE(response.update_exists);
 }
 
 TEST(OmahaRequestActionTest, InvalidStatusTest) {
   OmahaResponse response;
   ASSERT_FALSE(TestUpdateCheck(
       NULL,  // prefs
       kDefaultTestParams,
       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
       "xmlns=\"http://www.google.com/update2/response\" protocol=\"2.0\"><app "
       "appid=\"foo\" status=\"ok\"><ping "
       "status=\"ok\"/><updatecheck status=\"foo\"/></app></gupdate>",
-      kActionCodeError,
+      -1,
+      kActionCodeOmahaRequestBadUpdateCheckStatus,
       &response,
       NULL));
   EXPECT_FALSE(response.update_exists);
 }
 
 TEST(OmahaRequestActionTest, MissingNodesetTest) {
   OmahaResponse response;
   ASSERT_FALSE(TestUpdateCheck(
       NULL,  // prefs
       kDefaultTestParams,
       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
       "xmlns=\"http://www.google.com/update2/response\" protocol=\"2.0\"><app "
       "appid=\"foo\" status=\"ok\"><ping "
       "status=\"ok\"/></app></gupdate>",
-      kActionCodeError,
+      -1,
+      kActionCodeOmahaRequestNoUpdateCheckNode,
       &response,
       NULL));
   EXPECT_FALSE(response.update_exists);
 }
 
 TEST(OmahaRequestActionTest, MissingFieldTest) {
   OmahaResponse response;
   ASSERT_TRUE(TestUpdateCheck(NULL,  // prefs
                               kDefaultTestParams,
                               string("<?xml version=\"1.0\" "
                                      "encoding=\"UTF-8\"?><gupdate "
                                      "xmlns=\"http://www.google.com/"
                                      "update2/response\" "
                                      "protocol=\"2.0\"><app appid=\"") +
                               OmahaRequestParams::kAppId
                               + "\" status=\"ok\"><ping "
                               "status=\"ok\"/><updatecheck "
                               "DisplayVersion=\"1.2.3.4\" "
                               "Prompt=\"false\" "
                               "codebase=\"http://code/base\" hash=\"foo\" "
                               "sha256=\"HASH1234=\" needsadmin=\"true\" "
                               "size=\"123\" "
                               "status=\"ok\"/></app></gupdate>",
+                              -1,
                               kActionCodeSuccess,
                               &response,
                               NULL));
   EXPECT_TRUE(response.update_exists);
   EXPECT_EQ("1.2.3.4", response.display_version);
   EXPECT_EQ("http://code/base", response.codebase);
   EXPECT_EQ("", response.more_info_url);
   EXPECT_FALSE(response.is_delta);
   EXPECT_EQ("HASH1234=", response.hash);
   EXPECT_EQ(123, response.size);
@@ skipping 59 matching lines @@
                             "en-US",
                             "unittest_track&lt;",
                             "<OEM MODEL>",
                             false,  // delta okay
                             "http://url");
   OmahaResponse response;
   ASSERT_FALSE(
       TestUpdateCheck(NULL,  // prefs
                       params,
                       "invalid xml>",
-                      kActionCodeError,
+                      -1,
+                      kActionCodeOmahaRequestXMLParseError,
                       &response,
                       &post_data));
   // convert post_data to string
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("testtheservice_pack&gt;"), string::npos);
   EXPECT_EQ(post_str.find("testtheservice_pack>"), string::npos);
   EXPECT_NE(post_str.find("x86 generic&lt;id"), string::npos);
   EXPECT_EQ(post_str.find("x86 generic<id"), string::npos);
   EXPECT_NE(post_str.find("unittest_track&amp;lt;"), string::npos);
   EXPECT_EQ(post_str.find("unittest_track&lt;"), string::npos);
   EXPECT_NE(post_str.find("&lt;OEM MODEL&gt;"), string::npos);
   EXPECT_EQ(post_str.find("<OEM MODEL>"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, XmlDecodeTest) {
   OmahaResponse response;
   ASSERT_TRUE(
       TestUpdateCheck(NULL,  // prefs
                       kDefaultTestParams,
                       GetUpdateResponse(OmahaRequestParams::kAppId,
                                         "1.2.3.4",  // version
                                         "testthe&lt;url",  // more info
                                         "true",  // prompt
                                         "testthe&amp;codebase",  // dl url
                                         "HASH1234=", // checksum
                                         "false",  // needs admin
                                         "123",  // size
                                         "&lt;20110101"),  // deadline
+                      -1,
                       kActionCodeSuccess,
                       &response,
                       NULL));
 
   EXPECT_EQ(response.more_info_url, "testthe<url");
   EXPECT_EQ(response.codebase, "testthe&codebase");
   EXPECT_EQ(response.deadline, "<20110101");
 }
 
 TEST(OmahaRequestActionTest, ParseIntTest) {
   OmahaResponse response;
   ASSERT_TRUE(
       TestUpdateCheck(NULL,  // prefs
                       kDefaultTestParams,
                       GetUpdateResponse(OmahaRequestParams::kAppId,
                                         "1.2.3.4",  // version
                                         "theurl",  // more info
                                         "true",  // prompt
                                         "thecodebase",  // dl url
                                         "HASH1234=", // checksum
                                         "false",  // needs admin
                                         // overflows int32:
                                         "123123123123123",  // size
                                         "deadline"),
+                      -1,
                       kActionCodeSuccess,
                       &response,
                       NULL));
 
   EXPECT_EQ(response.size, 123123123123123ll);
 }
 
 TEST(OmahaRequestActionTest, FormatUpdateCheckOutputTest) {
   vector<char> post_data;
   ASSERT_FALSE(TestUpdateCheck(NULL,  // prefs
                                kDefaultTestParams,
                                "invalid xml>",
-                               kActionCodeError,
+                               -1,
+                               kActionCodeOmahaRequestXMLParseError,
                                NULL,  // response
                                &post_data));
   // convert post_data to string
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("        <o:ping a=\"-1\" r=\"-1\"></o:ping>\n"
                           "        <o:updatecheck></o:updatecheck>\n"),
             string::npos);
   EXPECT_NE(post_str.find("hardware_class=\"OEM MODEL 09235 7471\""),
             string::npos);
   EXPECT_EQ(post_str.find("o:event"), string::npos);
@@ skipping 88 matching lines @@
                               OmahaRequestParams::kAppId,
                               "0.1.0.0",
                               "en-US",
                               "unittest_track",
                               "OEM MODEL REV 1234",
                               delta_okay,
                               "http://url");
     ASSERT_FALSE(TestUpdateCheck(NULL,  // prefs
                                  params,
                                  "invalid xml>",
-                                 kActionCodeError,
+                                 -1,
+                                 kActionCodeOmahaRequestXMLParseError,
                                  NULL,
                                  &post_data));
     // convert post_data to string
     string post_str(&post_data[0], post_data.size());
     EXPECT_NE(post_str.find(StringPrintf(" delta_okay=\"%s\"", delta_okay_str)),
               string::npos)
         << "i = " << i;
   }
 }
 
@@ skipping 25 matching lines @@
       (Time::Now() - TimeDelta::FromHours(6 * 24 + 11)).ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(six_days_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(five_days_ago), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("<o:ping a=\"6\" r=\"5\"></o:ping>"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, ActivePingTest) {
   PrefsMock prefs;
   int64_t three_days_ago =
       (Time::Now() - TimeDelta::FromHours(3 * 24 + 12)).ToInternalValue();
   int64_t now = Time::Now().ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(three_days_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("<o:ping a=\"3\"></o:ping>"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, RollCallPingTest) {
   PrefsMock prefs;
   int64_t four_days_ago =
       (Time::Now() - TimeDelta::FromHours(4 * 24)).ToInternalValue();
   int64_t now = Time::Now().ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(four_days_ago), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("<o:ping r=\"4\"></o:ping>\n"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, NoPingTest) {
   PrefsMock prefs;
   int64_t one_hour_ago =
       (Time::Now() - TimeDelta::FromHours(1)).ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_EQ(post_str.find("o:ping"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, BackInTimePingTest) {
   PrefsMock prefs;
   int64_t future =
       (Time::Now() + TimeDelta::FromHours(3 * 24 + 4)).ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(future), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(future), Return(true)));
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(Return(true));
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(Return(true));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
                       "xmlns=\"http://www.google.com/update2/response\" "
                       "protocol=\"2.0\"><daystart elapsed_seconds=\"100\"/>"
                       "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
                       "<updatecheck status=\"noupdate\"/></app></gupdate>",
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_EQ(post_str.find("o:ping"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, LastPingDayUpdateTest) {
   // This test checks that the action updates the last ping day to now
   // minus 200 seconds with a slack of 5 seconds. Therefore, the test
@@ skipping 11 matching lines @@
                               AllOf(Ge(midnight), Le(midnight_slack))))
       .WillOnce(Return(true));
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
                       "xmlns=\"http://www.google.com/update2/response\" "
                       "protocol=\"2.0\"><daystart elapsed_seconds=\"200\"/>"
                       "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
                       "<updatecheck status=\"noupdate\"/></app></gupdate>",
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       NULL));
 }
 
 TEST(OmahaRequestActionTest, NoElapsedSecondsTest) {
   PrefsMock prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
                       "xmlns=\"http://www.google.com/update2/response\" "
                       "protocol=\"2.0\"><daystart blah=\"200\"/>"
                       "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
                       "<updatecheck status=\"noupdate\"/></app></gupdate>",
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       NULL));
 }
 
 TEST(OmahaRequestActionTest, BadElapsedSecondsTest) {
   PrefsMock prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
                       "xmlns=\"http://www.google.com/update2/response\" "
                       "protocol=\"2.0\"><daystart elapsed_seconds=\"x\"/>"
                       "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
                       "<updatecheck status=\"noupdate\"/></app></gupdate>",
+                      -1,
                       kActionCodeSuccess,
                       NULL,
                       NULL));
 }
 
 TEST(OmahaRequestActionTest, NoUniqueIDTest) {
   vector<char> post_data;
   ASSERT_FALSE(TestUpdateCheck(NULL,  // prefs
                                kDefaultTestParams,
                                "invalid xml>",
-                               kActionCodeError,
+                               -1,
+                               kActionCodeOmahaRequestXMLParseError,
                                NULL,  // response
                                &post_data));
   // convert post_data to string
   string post_str(&post_data[0], post_data.size());
   EXPECT_EQ(post_str.find("machineid="), string::npos);
   EXPECT_EQ(post_str.find("userid="), string::npos);
 }
 
+TEST(OmahaRequestActionTest, NetworkFailureTest) {
+  OmahaResponse response;
+  ASSERT_FALSE(
+      TestUpdateCheck(NULL,  // prefs
+                      kDefaultTestParams,
+                      "",
+                      501,
+                      static_cast<ActionExitCode>(
+                          kActionCodeOmahaRequestHTTPResponseBase + 501),
+                      &response,
+                      NULL));
+  EXPECT_FALSE(response.update_exists);
+}
+
+TEST(OmahaRequestActionTest, NetworkFailureBadHTTPCodeTest) {
+  OmahaResponse response;
+  ASSERT_FALSE(
+      TestUpdateCheck(NULL,  // prefs
+                      kDefaultTestParams,
+                      "",
+                      1500,
+                      static_cast<ActionExitCode>(
+                          kActionCodeOmahaRequestHTTPResponseBase + 999),
+                      &response,
+                      NULL));
+  EXPECT_FALSE(response.update_exists);
+}
+
 }  // namespace chromeos_update_engine