/*
 * Copyright 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Author: jmarantz@google.com (Joshua Marantz)

#include "net/instaweb/rewriter/public/rewrite_query.h"

#include "base/logging.h"
#include "net/instaweb/http/public/request_context.h"
#include "net/instaweb/rewriter/public/rewrite_options.h"
#include "net/instaweb/rewriter/public/rewrite_test_base.h"
#include "net/instaweb/rewriter/public/test_rewrite_driver_factory.h"
#include "pagespeed/kernel/base/google_message_handler.h"
#include "pagespeed/kernel/base/gtest.h"
#include "pagespeed/kernel/base/mock_message_handler.h"
#include "pagespeed/kernel/base/ref_counted_ptr.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/html/html_parse_test_base.h"
#include "pagespeed/kernel/http/google_url.h"
#include "pagespeed/kernel/http/http_names.h"
#include "pagespeed/kernel/http/response_headers.h"

namespace net_instaweb {

const char kHtmlUrl[] = "http://www.test.com/index.jsp";

class RewriteQueryTest : public RewriteTestBase {
 protected:
  virtual void SetUp() {
    RewriteTestBase::SetUp();
    allow_related_options_ = false;
    allow_options_to_be_set_by_cookies_ = false;
    request_option_override_ = "";
    image_url_ = Encode(kTestDomain, "ic", "0", "image.jpg", "jpg");
  }

  const RewriteOptions* ParseAndScan(const StringPiece request_url,
                                     const StringPiece& in_query,
                                     const StringPiece& in_req_string) {
    return ParseAndScan(request_url, in_query, in_req_string, NULL, NULL);
  }

  // Parses query-params &/or HTTP headers.  The HTTP headers are specified
  // as a string, with semi-colons separating attr:value pairs.
  const RewriteOptions* ParseAndScan(const StringPiece request_url,
                                     const StringPiece& in_query,
                                     const StringPiece& in_req_string,
                                     GoogleString* out_query,
                                     GoogleString* out_req_string) {
    GoogleString out_resp_string;
    RequestHeaders request_headers;
    StringPieceVector components;
    SplitStringPieceToVector(in_req_string, ";", &components, true);
    for (int i = 0, n = components.size(); i < n; ++i) {
      StringPieceVector attr_value;
      SplitStringPieceToVector(components[i], ":", &attr_value, false);
      CHECK_EQ(2, attr_value.size());
      request_headers.Add(attr_value[0], attr_value[1]);
    }
    return ParseAndScan(request_url, in_query, StringPiece(), &request_headers,
                        NULL, out_query, out_req_string, &out_resp_string);
  }

  const RewriteOptions* ParseAndScan(const StringPiece request_url,
                                     const StringPiece& in_query,
                                     const StringPiece& in_cookies,
                                     RequestHeaders* request_headers,
                                     ResponseHeaders* response_headers,
                                     GoogleString* out_query,
                                     GoogleString* out_req_string,
                                     GoogleString* out_resp_string) {
    Parse(request_url, in_query, in_cookies, request_headers,
          response_headers, out_query, out_req_string, out_resp_string);
    return rewrite_query_.options();
  }


  RewriteQuery::Status Parse(const StringPiece request_url,
                             const StringPiece& in_query,
                             const StringPiece& in_cookies,
                             RequestHeaders* request_headers,
                             ResponseHeaders* response_headers,
                             GoogleString* out_query,
                             GoogleString* out_req_string,
                             GoogleString* out_resp_string) {
    GoogleUrl url(StrCat(request_url, "?", in_query));
    if (!in_cookies.empty()) {
      // For fidelity we can put multiple cookies per header line. We limit
      // the line length to an arbitrary value to implement this.
      const int kMaxLineLength = 128;
      GoogleString header_value;
      StringPieceVector cookie_vector;
      SplitStringPieceToVector(in_cookies, ";", &cookie_vector, true);
      for (int i = 0, nc = cookie_vector.size(); i < nc; ++i) {
        if (header_value.empty() ||
            (header_value.size() + cookie_vector[i].size()) < kMaxLineLength) {
          if (!header_value.empty()) {
            StrAppend(&header_value, ";");
          }
          StrAppend(&header_value, cookie_vector[i]);
        } else {
          request_headers->Add(HttpAttributes::kCookie, header_value);
          cookie_vector[i].CopyToString(&header_value);
        }
      }
      if (!header_value.empty()) {
        request_headers->Add(HttpAttributes::kCookie, header_value);
      }
    }
    RequestContextPtr null_request_context;
    RewriteQuery::Status status = rewrite_query_.Scan(
        allow_related_options_,
        allow_options_to_be_set_by_cookies_,
        request_option_override_, null_request_context,
        factory(), server_context(), &url, request_headers,
        response_headers, &handler_);
    if (out_query != NULL) {
      out_query->assign(url.Query().data(), url.Query().size());
    }
    if (out_req_string != NULL && request_headers != NULL) {
      out_req_string->assign(request_headers->ToString());
    }
    if (out_resp_string != NULL && response_headers != NULL) {
      out_resp_string->assign(response_headers->ToString());
    }
    return status;
  }

  // Starts with image_, applies the specified image-options, and any
  // query-params and request-headers.
  const RewriteOptions* ParseAndScanImageOptions(StringPiece image_options,
                                                 StringPiece query_params,
                                                 StringPiece request_headers) {
    allow_related_options_ = true;
    GoogleString query;
    GoogleString req_string;
    GoogleString image = AddOptionsToEncodedUrl(image_url_, image_options);
    const RewriteOptions* options = ParseAndScan(image, query_params,
                                                 request_headers, &query,
                                                 &req_string);
    EXPECT_STREQ("", query);
    return options;
  }

  void CheckExtendCache(const RewriteOptions& options, bool x) {
    EXPECT_EQ(x, options.Enabled(RewriteOptions::kExtendCacheCss));
    EXPECT_EQ(x, options.Enabled(RewriteOptions::kExtendCacheImages));
    EXPECT_EQ(x, options.Enabled(RewriteOptions::kExtendCacheScripts));
  }

  // In a fashion patterned after the usage in mod_instaweb.cc, establish
  // a base configuration, and update it based on the passed-in query string.
  void Incremental(const StringPiece& query, RewriteOptions* options) {
    GoogleUrl gurl(StrCat("http://example.com/?ModPagespeedFilters=", query));
    RequestContextPtr null_request_context;
    ASSERT_EQ(RewriteQuery::kSuccess,
              rewrite_query_.Scan(
                  allow_related_options_, allow_options_to_be_set_by_cookies_,
                  request_option_override_, null_request_context, factory(),
                  server_context(), &gurl, NULL, NULL, message_handler()));
    options->Merge(*rewrite_query_.options());
  }

  void TestParseClientOptions(
      RequestHeaders* request_headers,
      bool expected_parsing_result,
      RewriteQuery::ProxyMode expected_proxy_mode,
      DeviceProperties::ImageQualityPreference expected_quality_preference) {
    RewriteQuery::ProxyMode proxy_mode;
    DeviceProperties::ImageQualityPreference quality_preference;
    const StringPiece header_value(
        request_headers->Lookup1(HttpAttributes::kXPsaClientOptions));
    bool parsing_result = RewriteQuery::ParseClientOptions(
        header_value, &proxy_mode, &quality_preference);
    EXPECT_EQ(expected_parsing_result, parsing_result);
    if (parsing_result) {
      EXPECT_EQ(expected_proxy_mode, proxy_mode);
      EXPECT_EQ(expected_quality_preference, quality_preference);
    }
  }

  void TestClientOptions(
      RequestHeaders* request_headers,
      bool expected_parsing_result,
      RewriteQuery::ProxyMode expected_proxy_mode,
      DeviceProperties::ImageQualityPreference expected_quality_preference) {
    ResponseHeaders response_headers;
    GoogleString in_query, out_query, out_req_string, out_resp_string;

    TestParseClientOptions(
        request_headers, expected_parsing_result, expected_proxy_mode,
        expected_quality_preference);

    const RewriteOptions* options = ParseAndScan(
        kHtmlUrl, in_query, StringPiece(), request_headers, &response_headers,
        &out_query, &out_req_string, &out_resp_string);
    if (!expected_parsing_result) {
      EXPECT_TRUE(options == NULL);
      return;
    }
    if (expected_proxy_mode == RewriteQuery::kProxyModeNoTransform) {
      EXPECT_EQ(RewriteOptions::kPassThrough, options->level());
      // Not a complete list. Only checks the important ones.
      EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteCss));
      EXPECT_FALSE(options->Enabled(
          RewriteOptions::kRewriteJavascriptExternal));
      EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
    }
    if (expected_proxy_mode == RewriteQuery::kProxyModeNoTransform ||
        expected_proxy_mode == RewriteQuery::kProxyModeNoImageTransform) {
      // Not a complete list. Only checks the important ones.
      EXPECT_FALSE(options->Enabled(RewriteOptions::kConvertGifToPng));
      EXPECT_FALSE(options->Enabled(RewriteOptions::kConvertPngToJpeg));
      EXPECT_FALSE(options->Enabled(RewriteOptions::kConvertJpegToProgressive));
      EXPECT_FALSE(options->Enabled(RewriteOptions::kConvertJpegToWebp));
      EXPECT_FALSE(options->Enabled(RewriteOptions::kConvertToWebpLossless));
      EXPECT_FALSE(options->Enabled(RewriteOptions::kResizeImages));
      EXPECT_FALSE(options->Enabled(RewriteOptions::kResizeMobileImages));
    } else {
      EXPECT_EQ(RewriteQuery::kProxyModeDefault, expected_proxy_mode);
      if (expected_quality_preference ==
          DeviceProperties::kImageQualityDefault) {
        EXPECT_TRUE(options == NULL);
      }
    }
    EXPECT_TRUE(
        request_headers->Lookup1(HttpAttributes::kXPsaClientOptions) == NULL);
  }

  GoogleMessageHandler handler_;
  RewriteQuery rewrite_query_;
  bool allow_related_options_;
  bool allow_options_to_be_set_by_cookies_;
  GoogleString request_option_override_;
  GoogleString image_url_;
};

TEST_F(RewriteQueryTest, Empty) {
  EXPECT_TRUE(ParseAndScan(kHtmlUrl, "", "") == NULL);
}

TEST_F(RewriteQueryTest, OffQuery) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "ModPagespeed=off", "");
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());
}

TEST_F(RewriteQueryTest, OffHeaders) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "", "ModPagespeed:off");
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());
}

TEST_F(RewriteQueryTest, OffResponseHeader) {
  RequestHeaders request_headers;
  ResponseHeaders response_headers;
  GoogleString in_query, out_query, out_req_string, out_resp_string;

  response_headers.Add("ModPagespeed", "off");
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, StringPiece(), &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());
}

TEST_F(RewriteQueryTest, OffQueryPageSpeed) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl, "PageSpeed=off", "");
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());
}

TEST_F(RewriteQueryTest, OffHeadersPageSpeed) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl, "", "PageSpeed:off");
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());
}

TEST_F(RewriteQueryTest, OffResponseHeaderPageSpeed) {
  RequestHeaders request_headers;
  ResponseHeaders response_headers;
  GoogleString in_query, out_query, out_req_string, out_resp_string;

  response_headers.Add("PageSpeed", "off");
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, StringPiece(), &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());
}

TEST_F(RewriteQueryTest, OnWithDefaultFiltersQuery) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl, "ModPagespeed=on", "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  CheckExtendCache(*options, true);
  EXPECT_FALSE(options->Enabled(RewriteOptions::kExtendCachePdfs));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, OnWithDefaultFiltersHeaders) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl, "", "ModPagespeed:on");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  CheckExtendCache(*options, true);
  EXPECT_FALSE(options->Enabled(RewriteOptions::kExtendCachePdfs));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, OnWithDefaultFiltersQueryPageSpeed) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl, "PageSpeed=on", "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  CheckExtendCache(*options, true);
  EXPECT_FALSE(options->Enabled(RewriteOptions::kExtendCachePdfs));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, OnWithDefaultFiltersHeadersPageSpeed) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl, "", "PageSpeed:on");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  CheckExtendCache(*options, true);
  EXPECT_FALSE(options->Enabled(RewriteOptions::kExtendCachePdfs));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, SetFiltersQuery) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "ModPagespeedFilters=remove_quotes", "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRemoveQuotes));
  CheckExtendCache(*options, false);
  EXPECT_FALSE(options->Enabled(RewriteOptions::kExtendCachePdfs));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, SetFiltersQueryCorePlusMinus) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl,
      "ModPagespeedFilters=core,+div_structure,-inline_css,+extend_cache_css",
      "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());

  CheckExtendCache(*options, true);
  EXPECT_TRUE(options->Enabled(RewriteOptions::kExtendCacheCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kExtendCacheImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kDivStructure));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kInlineCss));
  // Unlike above, these are true because 'core' is in the filter list.
  EXPECT_TRUE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, SetFiltersRequestHeaders) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "", "ModPagespeedFilters:remove_quotes");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRemoveQuotes));
  CheckExtendCache(*options, false);
  EXPECT_FALSE(options->Enabled(RewriteOptions::kExtendCachePdfs));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, SetFiltersResponseHeaders) {
  // Check that response headers are properly parsed.
  RequestHeaders request_headers;
  ResponseHeaders response_headers;
  GoogleString in_query, out_query, out_req_string, out_resp_string;

  response_headers.Add("ModPagespeedFilters", "remove_quotes");
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, StringPiece(), &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRemoveQuotes));
  CheckExtendCache(*options, false);
  EXPECT_FALSE(options->Enabled(RewriteOptions::kExtendCachePdfs));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kResizeImages));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteJavascriptExternal));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteJavascriptInline));
}

TEST_F(RewriteQueryTest, QueryAndRequestAndResponseAndCookies) {
  RequestHeaders request_headers;
  ResponseHeaders response_headers;
  GoogleString in_query, in_cookies, out_query, out_req_string, out_resp_string;

  in_query = ("ModPagespeedFilters=-div_structure,+extend_cache_css");

  in_cookies = (" PageSpeedCssFlattenMaxBytes   =  12345  "
                ";ModPagespeedFilters=%2binline_images"           // Needed for:
                ";ModPagespeedImageInlineMaxBytes=67890"
                ";SessionId=1234567890"                           // Not ours.
                ";PageSpeedImageRecompressionQuality=77"
                ";PageSpeedNoSuchOption=123"                      // No such.
                ";ModPagespeedImageLimitOptimizedPercent=55"      // Bad scope.
                ";PageSpeedWebpRecompressionQuality"              // No value.
                ";ModPagespeedImageJpegRecompressQuality=33oops"  // Bad value.
                ";ModPagespeedCssInlineMaxBytes=19"               // Conflicts.
                ";PageSpeedEnrollExperiment=\n1\r");              // Bad chars.

  request_headers.Add("ModPagespeedCssInlineMaxBytes", "10");
  request_headers.Add("ModPagespeedJsInlineMaxBytes", "7");
  request_headers.Add("ModPagespeedFilters",
                      "+div_structure,-inline_css,+remove_quotes");

  response_headers.Add("ModPagespeedFilters", "+inline_css,-remove_quotes");
  response_headers.Add("ModPagespeedJsInlineMaxBytes", "13");
  response_headers.Add("ModPagespeedFilters", "");

  allow_options_to_be_set_by_cookies_ = true;
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, in_cookies, &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);

  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());

  EXPECT_TRUE(options->Enabled(RewriteOptions::kInlineImages));
  EXPECT_EQ(12345, options->css_flatten_max_bytes());
  EXPECT_EQ(67890, options->ImageInlineMaxBytes());
  EXPECT_EQ(77, options->image_recompress_quality());
  EXPECT_EQ(RewriteOptions::kDefaultImageLimitOptimizedPercent,
            options->image_limit_optimized_percent());
  EXPECT_EQ(RewriteOptions::kDefaultImageWebpRecompressQuality,
            options->ImageWebpQuality());
  EXPECT_EQ(RewriteOptions::kDefaultImageLimitResizeAreaPercent,
            options->image_limit_resize_area_percent());

  // Request and cookies conflict, Request should win.
  EXPECT_EQ(10, options->css_inline_max_bytes());

  // Request and Response conflict, Response should win.
  EXPECT_EQ(13, options->js_inline_max_bytes());

  // Request/Response/Query conflicts, disabled should win over enabled
  EXPECT_FALSE(options->Enabled(RewriteOptions::kInlineCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRemoveQuotes));

  EXPECT_FALSE(options->Enabled(RewriteOptions::kDivStructure));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kExtendCacheCss));

  // PageSpeed option cookies have been squirreled away.
  EXPECT_STREQ("ModPagespeedCssInlineMaxBytes=19"  // Conflicts but still saved.
               "&ModPagespeedFilters=+inline_images"
               "&ModPagespeedImageInlineMaxBytes=67890"
               "&PageSpeedCssFlattenMaxBytes=12345"
               "&PageSpeedEnrollExperiment=1"      // The bad chars are removed.
               "&PageSpeedImageRecompressionQuality=77",
               rewrite_query_.pagespeed_option_cookies().ToEscapedString());
}

TEST_F(RewriteQueryTest, CannotSetOptionsByCookiesWhenDisabled) {
  RequestHeaders request_headers;
  ResponseHeaders response_headers;
  GoogleString in_query, in_cookies, out_query, out_req_string, out_resp_string;

  // We only do this to ensure that ParseAndScan returns non-NULL options.
  in_query = ("ModPagespeedFilters=-div_structure,+extend_cache_css");

  in_cookies = (" PageSpeedCssFlattenMaxBytes   =  12345  "
                ";ModPagespeedFilters=+inline_images"             // Needed for:
                ";ModPagespeedImageInlineMaxBytes=67890"
                ";PageSpeedImageRecompressionQuality=77"
                ";ModPagespeedCssInlineMaxBytes=19");

  allow_options_to_be_set_by_cookies_ = false;  // Default, but let's be *sure*.
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, in_cookies, &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);

  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());

  // Everything should be default value.
  EXPECT_EQ(RewriteOptions::kDefaultCssFlattenMaxBytes,
            options->css_flatten_max_bytes());
  EXPECT_EQ(RewriteOptions::kDefaultImageInlineMaxBytes,
            options->ImageInlineMaxBytes());
  EXPECT_EQ(RewriteOptions::kDefaultImageRecompressQuality,
            options->image_recompress_quality());
  EXPECT_EQ(RewriteOptions::kDefaultCssInlineMaxBytes,
            options->css_inline_max_bytes());

  // The query parameter options should still have taken effect.
  EXPECT_FALSE(options->Enabled(RewriteOptions::kDivStructure));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kExtendCacheCss));
}

// Note: In the next four tests we intentionally mix ModPagespeed* and
// PageSpeed* query params to make sure all combinations work and are respected.

TEST_F(RewriteQueryTest, MultipleQuery) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "PageSpeedFilters=inline_css&ModPagespeedCssInlineMaxBytes=10",
      "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kInlineCss));
  EXPECT_EQ(10, options->css_inline_max_bytes());
}

TEST_F(RewriteQueryTest, MultipleHeaders) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "",
      "ModPagespeedFilters:inline_css;PageSpeedCssInlineMaxBytes:10");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kInlineCss));
  EXPECT_EQ(10, options->css_inline_max_bytes());
}

TEST_F(RewriteQueryTest, MultipleQueryAndHeaders) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "ModPagespeedFilters=inline_css",
      "ModPagespeedCssInlineMaxBytes:10");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kInlineCss));
  EXPECT_EQ(10, options->css_inline_max_bytes());
}

TEST_F(RewriteQueryTest, MultipleIgnoreUnrelated) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl,
                                               "PageSpeedFilters=inline_css"
                                               "&PageSpeedCssInlineMaxBytes=10"
                                               "&Unrelated1"
                                               "&Unrelated2="
                                               "&Unrelated3=value",
                                               "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kInlineCss));
  EXPECT_EQ(10, options->css_inline_max_bytes());
}

TEST_F(RewriteQueryTest, MultipleBroken) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl,
                                               "PageSpeedFilters=inline_css"
                                               "&PageSpeedCssInlineMaxBytes=10"
                                               "&PageSpeedFilters=bogus_filter",
                                               "");
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, MultipleInt64Params) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl,
      "PageSpeedCssInlineMaxBytes=3"
      "&PageSpeedImageInlineMaxBytes=5"
      "&PageSpeedCssImageInlineMaxBytes=7"
      "&PageSpeedJsInlineMaxBytes=11"
      "&PageSpeedDomainShardCount=2",
      "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->enabled());
  EXPECT_EQ(3, options->css_inline_max_bytes());
  EXPECT_EQ(5, options->ImageInlineMaxBytes());
  EXPECT_EQ(7, options->CssImageInlineMaxBytes());
  EXPECT_EQ(11, options->js_inline_max_bytes());
  EXPECT_EQ(2, options->domain_shard_count());
}

TEST_F(RewriteQueryTest, OptionsNotArbitrary) {
  // Security sanity check: trying to set beacon URL
  // externally should not succeed.
  const RewriteOptions* options =
      ParseAndScan(kHtmlUrl, StrCat("PageSpeed", RewriteOptions::kBeaconUrl,
                                    "=", "evil.com"), "");
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, OutputQueryandHeaders) {
  GoogleString output_query, output_headers;
  ParseAndScan(kHtmlUrl, "ModPagespeedCssInlineMaxBytes=3"
               "&ModPagespeedImageInlineMaxBytes=5"
               "&ModPagespeedCssImageInlineMaxBytes=7"
               "&ModPagespeedJsInlineMaxBytes=11"
               "&ModPagespeedDomainShardCount=100"
               "&ModPagespeedCssFlattenMaxBytes=13"
               "&abc=1"
               "&def",
               "ModPagespeedFilters:inline_css;"
               "xyz:6;"
               "ModPagespeedFilters:remove_quotes",
               &output_query, &output_headers);
  EXPECT_EQ(output_query, "abc=1&def");
  EXPECT_EQ(output_headers, "GET  HTTP/1.0\r\nxyz: 6\r\n\r\n");
  ParseAndScan(kHtmlUrl, "ModPagespeedCssInlineMaxBytes=3", "",
               &output_query, &output_headers);
  EXPECT_EQ(output_query, "");
}

TEST_F(RewriteQueryTest, OutputQueryandHeadersPageSpeed) {
  GoogleString output_query, output_headers;
  ParseAndScan(kHtmlUrl, "PageSpeedCssInlineMaxBytes=3"
               "&PageSpeedImageInlineMaxBytes=5"
               "&PageSpeedCssImageInlineMaxBytes=7"
               "&PageSpeedJsInlineMaxBytes=11"
               "&PageSpeedDomainShardCount=100"
               "&PageSpeedCssFlattenMaxBytes=13"
               "&abc=1"
               "&def",
               "PageSpeedFilters:inline_css;"
               "xyz:6;"
               "PageSpeedFilters:remove_quotes",
               &output_query, &output_headers);
  EXPECT_EQ(output_query, "abc=1&def");
  EXPECT_EQ(output_headers, "GET  HTTP/1.0\r\nxyz: 6\r\n\r\n");
  ParseAndScan(kHtmlUrl, "PageSpeedCssInlineMaxBytes=3", "",
               &output_query, &output_headers);
  EXPECT_EQ(output_query, "");
}

TEST_F(RewriteQueryTest, OutputQueryandHeadersPostRequest) {
  GoogleString output_query, output_req_headers, output_resp_headers;
  RequestHeaders request_headers;
  request_headers.set_method(RequestHeaders::kPost);
  request_headers.Add("ModPagespeedFilters", "inline_css");
  request_headers.Add("xyz", "6");
  request_headers.set_message_body("pqr");

  ParseAndScan(kHtmlUrl,
               "ModPagespeedCssInlineMaxBytes=3"
               "&abc=1"
               "&def",
               StringPiece(), &request_headers, NULL, &output_query,
               &output_req_headers, &output_resp_headers);
  EXPECT_EQ(output_query, "abc=1&def");
  EXPECT_EQ(output_req_headers, "POST  HTTP/1.0\r\nxyz: 6\r\n\r\n");
  EXPECT_EQ(request_headers.message_body(), "pqr");
}

TEST_F(RewriteQueryTest, OutputQueryandHeadersPostRequestPageSpeed) {
  GoogleString output_query, output_req_headers, output_resp_headers;
  RequestHeaders request_headers;
  request_headers.set_method(RequestHeaders::kPost);
  request_headers.Add("PageSpeedFilters", "inline_css");
  request_headers.Add("xyz", "6");
  request_headers.set_message_body("pqr");

  ParseAndScan(kHtmlUrl,
               "PageSpeedCssInlineMaxBytes=3"
               "&abc=1"
               "&def",
               StringPiece(), &request_headers, NULL, &output_query,
               &output_req_headers, &output_resp_headers);
  EXPECT_EQ(output_query, "abc=1&def");
  EXPECT_EQ(output_req_headers, "POST  HTTP/1.0\r\nxyz: 6\r\n\r\n");
  EXPECT_EQ(request_headers.message_body(), "pqr");
}

// Tests the ability to add an additional filter on the command-line based
// on whatever set is already installed in the configuration.
TEST_F(RewriteQueryTest, IncrementalAdd) {
  RewriteOptions options(factory()->thread_system());
  options.SetDefaultRewriteLevel(RewriteOptions::kCoreFilters);
  options.EnableFilter(RewriteOptions::kStripScripts);
  Incremental("+debug", &options);
  EXPECT_TRUE(options.Enabled(RewriteOptions::kStripScripts));
  EXPECT_TRUE(options.Enabled(RewriteOptions::kDebug));
  EXPECT_TRUE(options.Enabled(RewriteOptions::kCombineCss));
  EXPECT_FALSE(options.Enabled(RewriteOptions::kAddBaseTag));
  EXPECT_TRUE(options.modified());
}

// Same exact test as above, except that we omit the "+".  This wipes out
// the explicitly enabled filter in the configuration and also the core
// level.
TEST_F(RewriteQueryTest, NonIncrementalAdd) {
  RewriteOptions options(factory()->thread_system());
  options.SetDefaultRewriteLevel(RewriteOptions::kCoreFilters);
  options.EnableFilter(RewriteOptions::kStripScripts);
  Incremental("debug", &options);
  EXPECT_FALSE(options.Enabled(RewriteOptions::kStripScripts));
  EXPECT_TRUE(options.Enabled(RewriteOptions::kDebug));
  EXPECT_FALSE(options.Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options.modified());
}

// In this version we specify nothing, and that should erase the filters.
TEST_F(RewriteQueryTest, IncrementalEmpty) {
  RewriteOptions options(factory()->thread_system());
  options.SetDefaultRewriteLevel(RewriteOptions::kCoreFilters);
  options.EnableFilter(RewriteOptions::kStripScripts);
  Incremental("", &options);
  EXPECT_FALSE(options.Enabled(RewriteOptions::kStripScripts));
  EXPECT_FALSE(options.Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options.modified());
}

TEST_F(RewriteQueryTest, IncrementalRemoveExplicit) {
  RewriteOptions options(factory()->thread_system());
  options.SetDefaultRewriteLevel(RewriteOptions::kCoreFilters);
  options.EnableFilter(RewriteOptions::kStripScripts);
  Incremental("-strip_scripts", &options);
  EXPECT_FALSE(options.Enabled(RewriteOptions::kStripScripts));
  EXPECT_TRUE(options.Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options.modified());
}

TEST_F(RewriteQueryTest, IncrementalRemoveFromCore) {
  RewriteOptions options(factory()->thread_system());
  options.SetDefaultRewriteLevel(RewriteOptions::kCoreFilters);
  options.EnableFilter(RewriteOptions::kStripScripts);
  Incremental("-combine_css", &options);
  EXPECT_TRUE(options.Enabled(RewriteOptions::kStripScripts));
  EXPECT_FALSE(options.Enabled(RewriteOptions::kCombineCss));
  EXPECT_TRUE(options.modified());
}

TEST_F(RewriteQueryTest, NoChangesShouldNotModify) {
  RewriteOptions options(factory()->thread_system());
  options.SetDefaultRewriteLevel(RewriteOptions::kCoreFilters);
  Incremental("+combine_css", &options);
  EXPECT_FALSE(options.Enabled(RewriteOptions::kStripScripts));
  EXPECT_TRUE(options.Enabled(RewriteOptions::kCombineCss));
  //
  // TODO(jmarantz): We would like at this point to have options show up
  // as unmodified.  However our implementation of query-params parsing
  // does not allow for this at this point, because it doesn't know
  // that it is working with the core filters.  Right now this is not
  // that important as the only usage of RewriteOptions::modified() is
  // in apache/mod_instaweb.cc which is just checking to see if there are
  // any directory-specific options set.
  //
  // EXPECT_FALSE(options.modified());
}

TEST_F(RewriteQueryTest, NoQueryValue) {
  const RewriteOptions* options = ParseAndScan(kHtmlUrl, "ModPagespeed=", "");
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, NoscriptQueryParamEmptyValue) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "PageSpeed=noscript", "");
  ASSERT_TRUE(options != NULL);
  RewriteOptions::FilterVector filter_vector;
  options->GetEnabledFiltersRequiringScriptExecution(&filter_vector);
  EXPECT_TRUE(filter_vector.empty());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kHandleNoscriptRedirect));
}

TEST_F(RewriteQueryTest, NoscriptHeader) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "", "PageSpeed:noscript");
  ASSERT_TRUE(options != NULL);
  RewriteOptions::FilterVector filter_vector;
  options->GetEnabledFiltersRequiringScriptExecution(&filter_vector);
  EXPECT_TRUE(filter_vector.empty());
  EXPECT_TRUE(options->Enabled(RewriteOptions::kHandleNoscriptRedirect));
}

TEST_F(RewriteQueryTest, NoscriptWithTrailingQuoteQueryParamEmptyValue) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl,
      "PageSpeed=noscript'", "");
  ASSERT_TRUE(options != NULL);
  RewriteOptions::FilterVector filter_vector;
  options->GetEnabledFiltersRequiringScriptExecution(&filter_vector);
  EXPECT_TRUE(filter_vector.empty());
  EXPECT_FALSE(options->Enabled(RewriteOptions::kLazyloadImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kHandleNoscriptRedirect));
}

TEST_F(RewriteQueryTest, NoscriptWithTrailingEscapedQuoteQueryParamEmptyValue) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl,
      "PageSpeed=noscript%5c%22", "");
  ASSERT_TRUE(options != NULL);
  RewriteOptions::FilterVector filter_vector;
  options->GetEnabledFiltersRequiringScriptExecution(&filter_vector);
  EXPECT_TRUE(filter_vector.empty());
  EXPECT_FALSE(options->Enabled(RewriteOptions::kLazyloadImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kHandleNoscriptRedirect));
}

TEST_F(RewriteQueryTest, NoscripWithTrailingQuotetHeader) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "",
      "PageSpeed:noscript'");
  ASSERT_TRUE(options != NULL);
  RewriteOptions::FilterVector filter_vector;
  options->GetEnabledFiltersRequiringScriptExecution(&filter_vector);
  EXPECT_TRUE(filter_vector.empty());
  EXPECT_FALSE(options->Enabled(RewriteOptions::kLazyloadImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kHandleNoscriptRedirect));
}

TEST_F(RewriteQueryTest, NoscripWithTrailingQuestionMarkHeader) {
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "",
      "PageSpeed:noscript?");
  ASSERT_TRUE(options != NULL);
  RewriteOptions::FilterVector filter_vector;
  options->GetEnabledFiltersRequiringScriptExecution(&filter_vector);
  EXPECT_TRUE(filter_vector.empty());
  EXPECT_FALSE(options->Enabled(RewriteOptions::kLazyloadImages));
  EXPECT_TRUE(options->Enabled(RewriteOptions::kHandleNoscriptRedirect));
}

TEST_F(RewriteQueryTest, JpegRecompressionQuality) {
  const char kQuery[] = "PageSpeedJpegRecompressionQuality=73";
  GoogleString query, req;
  const RewriteOptions* options = ParseAndScan(
      image_url_, kQuery, "", &query, &req);
  EXPECT_TRUE(options != NULL);
  EXPECT_STREQ("", query);
  EXPECT_EQ(73, options->ImageJpegQuality());
}

TEST_F(RewriteQueryTest, RequestOptionOverrideWithIncorrectToken) {
  const char kQuery[] =
    "PageSpeedJpegRecompressionQuality=88&PageSpeedRequestOptionOverride=def";
  GoogleString query, req;
  request_option_override_ = "abc";
  const RewriteOptions* options =
      ParseAndScan(image_url_, kQuery, "", &query, &req);
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, RequestOptionOverride) {
  const char kQuery[] =
      "PageSpeedJpegRecompressionQuality=73&PageSpeedRequestOptionOverride=abc";
  GoogleString query, req;
  request_option_override_ = "abc";
  const RewriteOptions* options =
      ParseAndScan(image_url_, kQuery, "", &query, &req);
  EXPECT_EQ(73, options->ImageJpegQuality());
}

TEST_F(RewriteQueryTest, RequestOptionOverrideProvidedWhenNotRequired) {
  const char kQuery[] =
      "PageSpeedJpegRecompressionQuality=73&PageSpeedRequestOptionOverride=abc";
  GoogleString query, req;
  const RewriteOptions* options =
      ParseAndScan(image_url_, kQuery, "", &query, &req);
  EXPECT_EQ(73, options->ImageJpegQuality());
}

TEST_F(RewriteQueryTest, RequestOptionOverrideNotProvidedWhenRequired) {
  const char kQuery[] = "PageSpeedJpegRecompressionQuality=73";
  GoogleString query, req;
  request_option_override_ = "abc";
  const RewriteOptions* options =
      ParseAndScan(image_url_, kQuery, "", &query, &req);
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, GenerateEmptyResourceOption) {
  EXPECT_EQ("", RewriteQuery::GenerateResourceOption("ic", rewrite_driver()));
}

TEST_F(RewriteQueryTest, GenerateResourceOptionRecompressImages) {
  options()->EnableFilter(RewriteOptions::kRecompressJpeg);  // relevant
  options()->EnableFilter(RewriteOptions::kCombineCss);  // not relevant
  options()->set_image_jpeg_recompress_quality(70);
  EXPECT_EQ("rj+iq=70",
            RewriteQuery::GenerateResourceOption("ic", rewrite_driver()));
  EXPECT_EQ("",
            RewriteQuery::GenerateResourceOption("jm", rewrite_driver()));

  // TODO(jmarantz): add support for CSS/JS options & test.
  // TODO(jmarantz): test all relevant filter/option combinations.
}

TEST_F(RewriteQueryTest, DontAllowArbitraryOptionsForNonPagespeedResources) {
  allow_related_options_ = true;
  // The kHtmlUrl is a .jsp, which is not .pagespeed.
  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, "PsolOpt=rj,iq:70", "");
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, DontAllowArbitraryOptionsWhenDisabled) {
  GoogleString image = AddOptionsToEncodedUrl(image_url_, "rj+iq=70");
  const RewriteOptions* options = ParseAndScan(image, "", "");
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, CanQueryRecompressImages) {
  const RewriteOptions* options = ParseAndScanImageOptions("rj+iq=70", "", "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRecompressJpeg));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_EQ(70, options->ImageJpegQuality());
}

TEST_F(RewriteQueryTest, CanOverrideRecompressImagesWithQuery) {
  const RewriteOptions* options = ParseAndScanImageOptions(
      "rj+iq=70", "PageSpeedJpegRecompressionQuality=71", "");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRecompressJpeg));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_EQ(71, options->ImageJpegQuality());
}

TEST_F(RewriteQueryTest, CanOverrideRecompressImagesWithReqHeaders) {
  const RewriteOptions* options = ParseAndScanImageOptions(
      "rj+iq=70", "", "PageSpeedJpegRecompressionQuality:72");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRecompressJpeg));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_EQ(72, options->ImageJpegQuality());
}

TEST_F(RewriteQueryTest, CanOverrideRecompressImagesWithBoth) {
  const RewriteOptions* options = ParseAndScanImageOptions(
      "rj+iq=70",
      "PageSpeedJpegRecompressionQuality=71",
      "PageSpeedJpegRecompressionQuality:72");
  ASSERT_TRUE(options != NULL);
  EXPECT_TRUE(options->Enabled(RewriteOptions::kRecompressJpeg));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kCombineCss));
  EXPECT_EQ(72, options->ImageJpegQuality()) << "req-headers win.";
}

TEST_F(RewriteQueryTest, OnlyAllowWhitelistedResources) {
  allow_related_options_ = true;

  // whitelisted by "ic"
  GoogleString image = AddOptionsToEncodedUrl(image_url_, "rj");
  EXPECT_TRUE(ParseAndScan(image, "", "") != NULL);
  image = AddOptionsToEncodedUrl(image_url_, "iq=70");
  EXPECT_TRUE(ParseAndScan(image, "", "") != NULL);

  // not whitelisted by "ic"
  image = AddOptionsToEncodedUrl(image_url_, "cc");
  EXPECT_TRUE(ParseAndScan(image_url_, "", "") == NULL);
  image = AddOptionsToEncodedUrl(image_url_, "rdm=10");
  EXPECT_TRUE(ParseAndScan(image_url_, "", "") == NULL);
}

TEST_F(RewriteQueryTest, ClientOptionsEmptyHeader) {
  RequestHeaders request_headers;

  TestClientOptions(&request_headers,
                    false, /* expected_parsing_result */
                    RewriteQuery::kProxyModeDefault,
                    DeviceProperties::kImageQualityDefault);
}

TEST_F(RewriteQueryTest, ClientOptionsMultipleHeaders) {
  RequestHeaders request_headers;

  request_headers.Add(HttpAttributes::kXPsaClientOptions, "v=1,iqp=3,m=0");
  request_headers.Add(HttpAttributes::kXPsaClientOptions, "v=1,iqp=3,m=0");
  TestClientOptions(&request_headers,
                    false, /* expected_parsing_result */
                    RewriteQuery::kProxyModeDefault,
                    DeviceProperties::kImageQualityDefault);
}

TEST_F(RewriteQueryTest, ClientOptionsOrder1) {
  RequestHeaders request_headers;

  request_headers.Replace(HttpAttributes::kXPsaClientOptions, "v=1,iqp=2,m=0");
  // Image quality is set.
  TestClientOptions(&request_headers,
                    true, /* expected_parsing_result */
                    RewriteQuery::kProxyModeDefault,
                    DeviceProperties::kImageQualityMedium);
}

TEST_F(RewriteQueryTest, ClientOptionsOrder2) {
  RequestHeaders request_headers;

  // The order of name-value pairs does not matter.
  // Not-supported parts are ignored.
  request_headers.Replace(HttpAttributes::kXPsaClientOptions,
                          "m=0,iqp=3,v=1,xyz=100,zyx=,yzx");
  TestClientOptions(&request_headers,
                    true, /* expected_parsing_result */
                    RewriteQuery::kProxyModeDefault,
                    DeviceProperties::kImageQualityHigh);
}

TEST_F(RewriteQueryTest, ClientOptionsCaseInsensitive) {
  RequestHeaders request_headers;
  GoogleString lower(HttpAttributes::kXPsaClientOptions);
  LowerString(&lower);

  request_headers.Replace(lower, "v=1,iqp=3,m=1");
  // Image quality is set.
  TestClientOptions(&request_headers,
                    true, /* expected_parsing_result */
                    RewriteQuery::kProxyModeNoImageTransform,
                    DeviceProperties::kImageQualityDefault);
}

TEST_F(RewriteQueryTest, ClientOptionsNonDefaultProxyMode) {
  RequestHeaders request_headers;

  // Image quality is ignored if mode is not Default.
  request_headers.Replace(HttpAttributes::kXPsaClientOptions, "v=1,iqp=2,m=1");
  TestClientOptions(&request_headers,
                    true, /* expected_parsing_result */
                    RewriteQuery::kProxyModeNoImageTransform,
                    DeviceProperties::kImageQualityDefault);
}

TEST_F(RewriteQueryTest, ClientOptionsValidVersionBadOptions) {
  RequestHeaders request_headers;

  // A valid version with bad options.
  request_headers.Replace(HttpAttributes::kXPsaClientOptions,
                          "v=1,iqp=2m=1,iqp=");
  TestClientOptions(&request_headers,
                    true, /* expected_parsing_result */
                    RewriteQuery::kProxyModeDefault,
                    DeviceProperties::kImageQualityDefault);
}

TEST_F(RewriteQueryTest, ClientOptionsInvalidVersion) {
  RequestHeaders request_headers;

  request_headers.Replace(HttpAttributes::kXPsaClientOptions, "iqp=2,m=1,v=2");
  TestClientOptions(&request_headers,
                    false, /* expected_parsing_result */
                    RewriteQuery::kProxyModeDefault,
                    DeviceProperties::kImageQualityDefault);
}

TEST_F(RewriteQueryTest, CacheControlNoTransform) {
  RequestHeaders request_headers;
  request_headers.Replace(HttpAttributes::kCacheControl, "no-transform");

  ResponseHeaders response_headers;
  GoogleString in_query, out_query, out_req_string, out_resp_string;

  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, StringPiece(), &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());
  EXPECT_TRUE(request_headers.Lookup1(HttpAttributes::kCacheControl) != NULL);
}

TEST_F(RewriteQueryTest, DisableFiltersWithXHR) {
  RequestHeaders request_headers;
  request_headers.Replace(HttpAttributes::kXRequestedWith,
                          HttpAttributes::kXmlHttpRequest);

  ResponseHeaders response_headers;
  GoogleString in_query, out_query, out_req_string, out_resp_string;

  EXPECT_EQ(RewriteQuery::kSuccess, Parse(
      kHtmlUrl, in_query, StringPiece(), &request_headers,
      &response_headers, &out_query, &out_req_string, &out_resp_string));
  scoped_ptr<RewriteOptions> options(rewrite_query_.options()->Clone());

  // Convert disabled -> forbidden for easier testing.
  options->set_forbid_all_disabled_filters(true);

  // defer_js, mobilize generaly require JS.
  EXPECT_TRUE(options->Forbidden(RewriteOptions::kDeferJavascript));
  EXPECT_TRUE(options->Forbidden(RewriteOptions::kMobilize));
  EXPECT_TRUE(options->Forbidden(RewriteOptions::kMoveCssToHead));
  EXPECT_TRUE(options->Forbidden(RewriteOptions::kAddInstrumentation));

  // rewrite_css doesn't, and shouldn't be defaulted on, either.
  EXPECT_FALSE(options->Forbidden(RewriteOptions::kRewriteCss));
  EXPECT_FALSE(options->Enabled(RewriteOptions::kRewriteCss));
}

TEST_F(RewriteQueryTest, CacheControlPrivateNoTransformResponse) {
  RequestHeaders request_headers;

  ResponseHeaders response_headers;
  response_headers.Replace(HttpAttributes::kCacheControl,
                           "private, no-transform");
  GoogleString in_query, out_query, out_req_string, out_resp_string;

  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, StringPiece(), &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);
  ASSERT_TRUE(options != NULL);
  EXPECT_FALSE(options->enabled());

  // Check that we don't strip either of the cache-control values.
  EXPECT_TRUE(response_headers.HasValue(HttpAttributes::kCacheControl,
                                        "private"));
  EXPECT_TRUE(response_headers.HasValue(HttpAttributes::kCacheControl,
                                        "no-transform"));
}

TEST_F(RewriteQueryTest, NoCustomOptionsWithCacheControlPrivate) {
  RequestHeaders request_headers;

  ResponseHeaders response_headers;
  response_headers.Replace(HttpAttributes::kCacheControl, "private");
  GoogleString in_query, out_query, out_req_string, out_resp_string;

  const RewriteOptions* options = ParseAndScan(
      kHtmlUrl, in_query, StringPiece(), &request_headers, &response_headers,
      &out_query, &out_req_string, &out_resp_string);
  EXPECT_TRUE(options == NULL);
}

TEST_F(RewriteQueryTest, PageSpeedQueryParamsAreExtracted) {
  GoogleUrl gurl("http://test.com/?a=b&"
                 "ModPagespeedFilters=debug&"
                 "x=y&"
                 "ModPagespeedCssFlattenMaxBytes=123");
  RequestContextPtr null_request_context;
  EXPECT_EQ(RewriteQuery::kSuccess,
            rewrite_query_.Scan(
                allow_related_options_, allow_options_to_be_set_by_cookies_,
                request_option_override_, null_request_context, factory(),
                server_context(), &gurl, NULL, NULL, message_handler()));
  EXPECT_STREQ("http://test.com/?a=b&x=y", gurl.Spec());
  EXPECT_EQ(2, rewrite_query_.pagespeed_query_params().size());
  EXPECT_STREQ("ModPagespeedFilters=debug&"
               "ModPagespeedCssFlattenMaxBytes=123",
               rewrite_query_.pagespeed_query_params().ToEscapedString());
}

TEST_F(RewriteQueryTest, PageSpeedStickyQueryParametersTokenIsExtracted) {
  // First test that no token is extracted if not specified.
  RequestContextPtr request_context(CreateRequestContext());
  GoogleUrl gurl("http://test.com/?PageSpeedFilters=debug");
  EXPECT_EQ(RewriteQuery::kSuccess,
            rewrite_query_.Scan(
                allow_related_options_, allow_options_to_be_set_by_cookies_,
                request_option_override_, request_context, factory(),
                server_context(), &gurl, NULL, NULL, message_handler()));
  EXPECT_STREQ("http://test.com/", gurl.Spec());
  EXPECT_EQ(1, rewrite_query_.pagespeed_query_params().size());
  EXPECT_STREQ("PageSpeedFilters=debug",
               rewrite_query_.pagespeed_query_params().ToEscapedString());
  EXPECT_STREQ("", request_context->sticky_query_parameters_token());
  // Then test that the token is extracted when specified.
  gurl.Reset("http://test.com/"
             "?PageSpeedFilters=debug"
             "&PageSpeedStickyQueryParameters=yadda");
  EXPECT_EQ(RewriteQuery::kSuccess,
            rewrite_query_.Scan(
                allow_related_options_, allow_options_to_be_set_by_cookies_,
                request_option_override_, request_context, factory(),
                server_context(), &gurl, NULL, NULL, message_handler()));
  EXPECT_STREQ("http://test.com/", gurl.Spec());
  EXPECT_EQ(2, rewrite_query_.pagespeed_query_params().size());
  EXPECT_STREQ("PageSpeedFilters=debug&PageSpeedStickyQueryParameters=yadda",
               rewrite_query_.pagespeed_query_params().ToEscapedString());
  EXPECT_STREQ("yadda", request_context->sticky_query_parameters_token());
}

}  // namespace net_instaweb