src/components/data_reduction_proxy/common/data_reduction_proxy_headers_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
   6
   7 #include <vector>
   8
   9 #include "components/data_reduction_proxy/common/data_reduction_proxy_headers_test_utils.h"
  10 #include "net/http/http_response_headers.h"
  11 #include "net/proxy/proxy_service.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace data_reduction_proxy {
  15
  16 class DataReductionProxyHeadersTest : public testing::Test {};
  17
  18 TEST_F(DataReductionProxyHeadersTest, GetDataReductionProxyActionValue) {
  19   const struct {
  20      const char* headers;
  21      std::string action_key;
  22      bool expected_result;
  23      std::string expected_action_value;
  24   } tests[] = {
  25     { "HTTP/1.1 200 OK\n"
  26       "Content-Length: 999\n",
  27       "a",
  28       false,
  29       "",
  30     },
  31     { "HTTP/1.1 200 OK\n"
  32       "connection: keep-alive\n"
  33       "Content-Length: 999\n",
  34       "a",
  35       false,
  36       "",
  37     },
  38     { "HTTP/1.1 200 OK\n"
  39       "connection: keep-alive\n"
  40       "Chrome-Proxy: bypass=86400\n"
  41       "Content-Length: 999\n",
  42       "bypass",
  43       true,
  44       "86400",
  45     },
  46     { "HTTP/1.1 200 OK\n"
  47       "connection: keep-alive\n"
  48       "Chrome-Proxy: bypass86400\n"
  49       "Content-Length: 999\n",
  50       "bypass",
  51       false,
  52       "",
  53     },
  54     { "HTTP/1.1 200 OK\n"
  55       "connection: keep-alive\n"
  56       "Chrome-Proxy: bypass=0\n"
  57       "Content-Length: 999\n",
  58       "bypass",
  59       true,
  60       "0",
  61     },
  62     { "HTTP/1.1 200 OK\n"
  63       "connection: keep-alive\n"
  64       "Chrome-Proxy: bypass=1500\n"
  65       "Chrome-Proxy: bypass=86400\n"
  66       "Content-Length: 999\n",
  67       "bypass",
  68       true,
  69       "1500",
  70     },
  71     { "HTTP/1.1 200 OK\n"
  72       "connection: keep-alive\n"
  73       "Chrome-Proxy: block=1500, block=3600\n"
  74       "Content-Length: 999\n",
  75       "block",
  76       true,
  77       "1500",
  78     },
  79     { "HTTP/1.1 200 OK\n"
  80       "connection: proxy-bypass\n"
  81       "Chrome-Proxy:    key=123   \n"
  82       "Content-Length: 999\n",
  83       "key",
  84       true,
  85       "123",
  86     },
  87     { "HTTP/1.1 200 OK\n"
  88       "connection: proxy-bypass\n"
  89       "Chrome-Proxy: block-once\n"
  90       "Content-Length: 999\n",
  91       "block-once",
  92       false,
  93       "",
  94     },
  95   };
  96   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
  97     std::string headers(tests[i].headers);
  98     HeadersToRaw(&headers);
  99     scoped_refptr<net::HttpResponseHeaders> parsed(
 100         new net::HttpResponseHeaders(headers));
 101
 102     std::string action_value;
 103     bool has_action_key = GetDataReductionProxyActionValue(
 104         parsed.get(), tests[i].action_key, &action_value);
 105     EXPECT_EQ(tests[i].expected_result, has_action_key);
 106     if (has_action_key) {
 107       EXPECT_EQ(tests[i].expected_action_value, action_value);
 108     }
 109   }
 110 }
 111
 112 TEST_F(DataReductionProxyHeadersTest, GetProxyBypassInfo) {
 113   const struct {
 114      const char* headers;
 115      bool expected_result;
 116      int64 expected_retry_delay;
 117      bool expected_bypass_all;
 118      bool expected_mark_proxies_as_bad;
 119   } tests[] = {
 120     { "HTTP/1.1 200 OK\n"
 121       "Content-Length: 999\n",
 122       false,
 123       0,
 124       false,
 125       false,
 126     },
 127     { "HTTP/1.1 200 OK\n"
 128       "connection: keep-alive\n"
 129       "Content-Length: 999\n",
 130       false,
 131       0,
 132       false,
 133       false,
 134     },
 135     { "HTTP/1.1 200 OK\n"
 136       "connection: keep-alive\n"
 137       "Chrome-Proxy: bypass=86400\n"
 138       "Content-Length: 999\n",
 139       true,
 140       86400,
 141       false,
 142       true,
 143     },
 144     { "HTTP/1.1 200 OK\n"
 145       "connection: keep-alive\n"
 146       "Chrome-Proxy: bypass=-1\n"
 147       "Content-Length: 999\n",
 148       false,
 149       0,
 150       false,
 151       false,
 152     },
 153     { "HTTP/1.1 200 OK\n"
 154       "connection: keep-alive\n"
 155       "Chrome-Proxy: bypass=xyz\n"
 156       "Content-Length: 999\n",
 157       false,
 158       0,
 159       false,
 160       false,
 161     },
 162     { "HTTP/1.1 200 OK\n"
 163       "connection: keep-alive\n"
 164       "Chrome-Proxy: bypass\n"
 165       "Content-Length: 999\n",
 166       false,
 167       0,
 168       false,
 169       false,
 170     },
 171     { "HTTP/1.1 200 OK\n"
 172       "connection: keep-alive\n"
 173       "Chrome-Proxy: foo=abc, bypass=86400\n"
 174       "Content-Length: 999\n",
 175       true,
 176       86400,
 177       false,
 178       true,
 179     },
 180     { "HTTP/1.1 200 OK\n"
 181       "connection: keep-alive\n"
 182       "Chrome-Proxy: bypass=86400, bar=abc\n"
 183       "Content-Length: 999\n",
 184       true,
 185       86400,
 186       false,
 187       true,
 188     },
 189     { "HTTP/1.1 200 OK\n"
 190       "connection: keep-alive\n"
 191       "Chrome-Proxy: bypass=3600\n"
 192       "Chrome-Proxy: bypass=86400\n"
 193       "Content-Length: 999\n",
 194       true,
 195       3600,
 196       false,
 197       true,
 198     },
 199     { "HTTP/1.1 200 OK\n"
 200       "connection: keep-alive\n"
 201       "Chrome-Proxy: bypass=3600, bypass=86400\n"
 202       "Content-Length: 999\n",
 203       true,
 204       3600,
 205       false,
 206       true,
 207     },
 208     { "HTTP/1.1 200 OK\n"
 209       "connection: keep-alive\n"
 210       "Chrome-Proxy: bypass=, bypass=86400\n"
 211       "Content-Length: 999\n",
 212       true,
 213       86400,
 214       false,
 215       true,
 216     },
 217     { "HTTP/1.1 200 OK\n"
 218       "connection: keep-alive\n"
 219       "Chrome-Proxy: bypass\n"
 220       "Chrome-Proxy: bypass=86400\n"
 221       "Content-Length: 999\n",
 222       true,
 223       86400,
 224       false,
 225       true,
 226     },
 227     { "HTTP/1.1 200 OK\n"
 228       "connection: keep-alive\n"
 229       "Chrome-Proxy: block=, block=3600\n"
 230       "Content-Length: 999\n",
 231       true,
 232       3600,
 233       true,
 234       true,
 235     },
 236     { "HTTP/1.1 200 OK\n"
 237       "connection: keep-alive\n"
 238       "Chrome-Proxy: bypass=86400, block=3600\n"
 239       "Content-Length: 999\n",
 240       true,
 241       3600,
 242       true,
 243       true,
 244     },
 245     { "HTTP/1.1 200 OK\n"
 246       "connection: proxy-bypass\n"
 247       "Chrome-Proxy: block=, bypass=86400\n"
 248       "Content-Length: 999\n",
 249       true,
 250       86400,
 251       false,
 252       true,
 253     },
 254     { "HTTP/1.1 200 OK\n"
 255       "connection: proxy-bypass\n"
 256       "Chrome-Proxy: block=-1\n"
 257       "Content-Length: 999\n",
 258       false,
 259       0,
 260       false,
 261       false,
 262     },
 263     { "HTTP/1.1 200 OK\n"
 264       "connection: proxy-bypass\n"
 265       "Chrome-Proxy: block=99999999999999999999\n"
 266       "Content-Length: 999\n",
 267       false,
 268       0,
 269       false,
 270       false,
 271     },
 272     { "HTTP/1.1 200 OK\n"
 273       "connection: keep-alive\n"
 274       "Chrome-Proxy: block-once\n"
 275       "Content-Length: 999\n",
 276       true,
 277       0,
 278       true,
 279       false,
 280     },
 281     { "HTTP/1.1 200 OK\n"
 282       "connection: keep-alive\n"
 283       "Chrome-Proxy: block-once=\n"
 284       "Content-Length: 999\n",
 285       false,
 286       0,
 287       false,
 288       false,
 289     },
 290     { "HTTP/1.1 200 OK\n"
 291       "connection: keep-alive\n"
 292       "Chrome-Proxy: block-once=10\n"
 293       "Content-Length: 999\n",
 294       false,
 295       0,
 296       false,
 297       false,
 298     },
 299     { "HTTP/1.1 200 OK\n"
 300       "connection: keep-alive\n"
 301       "Chrome-Proxy: block-once, bypass=86400, block=3600\n"
 302       "Content-Length: 999\n",
 303       true,
 304       3600,
 305       true,
 306       true,
 307     },
 308     { "HTTP/1.1 200 OK\n"
 309       "connection: keep-alive\n"
 310       "Chrome-Proxy: block-once\n"
 311       "Chrome-Proxy: bypass=86400, block=3600\n"
 312       "Content-Length: 999\n",
 313       true,
 314       3600,
 315       true,
 316       true,
 317     },
 318     { "HTTP/1.1 200 OK\n"
 319       "connection: keep-alive\n"
 320       "Chrome-Proxy: block-once, bypass=86400\n"
 321       "Content-Length: 999\n",
 322       true,
 323       86400,
 324       false,
 325       true,
 326     },
 327     { "HTTP/1.1 200 OK\n"
 328       "connection: keep-alive\n"
 329       "Chrome-Proxy: block-once, block=3600\n"
 330       "Content-Length: 999\n",
 331       true,
 332       3600,
 333       true,
 334       true,
 335     },
 336     { "HTTP/1.1 200 OK\n"
 337       "connection: keep-alive\n"
 338       "Chrome-Proxy: bypass=, block=, block-once\n"
 339       "Content-Length: 999\n",
 340       true,
 341       0,
 342       true,
 343       false,
 344     },
 345   };
 346   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 347     std::string headers(tests[i].headers);
 348     HeadersToRaw(&headers);
 349     scoped_refptr<net::HttpResponseHeaders> parsed(
 350         new net::HttpResponseHeaders(headers));
 351
 352     DataReductionProxyInfo data_reduction_proxy_info;
 353     EXPECT_EQ(
 354         tests[i].expected_result,
 355         ParseHeadersAndSetProxyInfo(parsed.get(), &data_reduction_proxy_info));
 356     EXPECT_EQ(tests[i].expected_retry_delay,
 357               data_reduction_proxy_info.bypass_duration.InSeconds());
 358     EXPECT_EQ(tests[i].expected_bypass_all,
 359               data_reduction_proxy_info.bypass_all);
 360     EXPECT_EQ(tests[i].expected_mark_proxies_as_bad,
 361               data_reduction_proxy_info.mark_proxies_as_bad);
 362   }
 363 }
 364
 365 TEST_F(DataReductionProxyHeadersTest, ParseHeadersAndSetProxyInfo) {
 366   std::string headers =
 367       "HTTP/1.1 200 OK\n"
 368       "connection: keep-alive\n"
 369       "Chrome-Proxy: bypass=0\n"
 370       "Content-Length: 999\n";
 371   HeadersToRaw(&headers);
 372   scoped_refptr<net::HttpResponseHeaders> parsed(
 373       new net::HttpResponseHeaders(headers));
 374
 375   DataReductionProxyInfo data_reduction_proxy_info;
 376   EXPECT_TRUE(
 377       ParseHeadersAndSetProxyInfo(parsed.get(), &data_reduction_proxy_info));
 378   EXPECT_LE(60, data_reduction_proxy_info.bypass_duration.InSeconds());
 379   EXPECT_GE(5 * 60, data_reduction_proxy_info.bypass_duration.InSeconds());
 380   EXPECT_FALSE(data_reduction_proxy_info.bypass_all);
 381 }
 382
 383 TEST_F(DataReductionProxyHeadersTest, HasDataReductionProxyViaHeader) {
 384   const struct {
 385     const char* headers;
 386     bool expected_result;
 387     bool expected_has_intermediary;
 388     bool ignore_intermediary;
 389   } tests[] = {
 390     { "HTTP/1.1 200 OK\n"
 391       "Via: 1.1 Chrome-Proxy\n",
 392       false,
 393       false,
 394       false,
 395     },
 396     { "HTTP/1.1 200 OK\n"
 397       "Via: 1\n",
 398       false,
 399       false,
 400       false,
 401     },
 402     { "HTTP/1.1 200 OK\n"
 403       "Via: 1.1 Chrome-Compression-Proxy\n",
 404       true,
 405       true,
 406       false,
 407     },
 408     { "HTTP/1.1 200 OK\n"
 409       "Via: 1.0 Chrome-Compression-Proxy\n",
 410       true,
 411       true,
 412       false,
 413     },
 414     { "HTTP/1.1 200 OK\n"
 415       "Via: 1.1 Foo-Bar, 1.1 Chrome-Compression-Proxy\n",
 416       true,
 417       true,
 418       false,
 419     },
 420     { "HTTP/1.1 200 OK\n"
 421       "Via: 1.1 Chrome-Compression-Proxy, 1.1 Bar-Foo\n",
 422       true,
 423       false,
 424       false,
 425     },
 426     { "HTTP/1.1 200 OK\n"
 427       "Via: 1.1 chrome-compression-proxy\n",
 428       false,
 429       false,
 430       false,
 431     },
 432     { "HTTP/1.1 200 OK\n"
 433       "Via: 1.1 Foo-Bar\n"
 434       "Via: 1.1 Chrome-Compression-Proxy\n",
 435       true,
 436       true,
 437       false,
 438     },
 439     { "HTTP/1.1 200 OK\n"
 440       "Via: 1.1 Chrome-Compression-Proxy\n"
 441       "Via: 1.1 Foo-Bar\n",
 442       true,
 443       false,
 444       false,
 445     },
 446     { "HTTP/1.1 200 OK\n"
 447       "Via: 1.1 Chrome-Proxy\n",
 448       false,
 449       false,
 450       false,
 451     },
 452     { "HTTP/1.1 200 OK\n"
 453       "Via: 1.1 Chrome Compression Proxy\n",
 454       true,
 455       true,
 456       false,
 457     },
 458     { "HTTP/1.1 200 OK\n"
 459       "Via: 1.1 Foo-Bar, 1.1 Chrome Compression Proxy\n",
 460       true,
 461       true,
 462       false,
 463     },
 464     { "HTTP/1.1 200 OK\n"
 465       "Via: 1.1 Chrome Compression Proxy, 1.1 Bar-Foo\n",
 466       true,
 467       false,
 468       false,
 469     },
 470     { "HTTP/1.1 200 OK\n"
 471       "Via: 1.1 chrome compression proxy\n",
 472       false,
 473       false,
 474       false,
 475     },
 476     { "HTTP/1.1 200 OK\n"
 477       "Via: 1.1 Foo-Bar\n"
 478       "Via: 1.1 Chrome Compression Proxy\n",
 479       true,
 480       true,
 481       false,
 482     },
 483     { "HTTP/1.1 200 OK\n"
 484       "Via: 1.1 Chrome Compression Proxy\n"
 485       "Via: 1.1 Foo-Bar\n",
 486       true,
 487       false,
 488       false,
 489     },
 490     { "HTTP/1.1 200 OK\n"
 491       "Via: 1.1 Chrome Compression Proxy\n"
 492       "Via: 1.1 Foo-Bar\n",
 493       true,
 494       false,
 495       true,
 496     },
 497   };
 498   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 499     std::string headers(tests[i].headers);
 500     HeadersToRaw(&headers);
 501     scoped_refptr<net::HttpResponseHeaders> parsed(
 502         new net::HttpResponseHeaders(headers));
 503
 504     bool has_chrome_proxy_via_header, has_intermediary;
 505     if (tests[i].ignore_intermediary) {
 506       has_chrome_proxy_via_header =
 507           HasDataReductionProxyViaHeader(parsed.get(), NULL);
 508     }
 509     else {
 510       has_chrome_proxy_via_header =
 511           HasDataReductionProxyViaHeader(parsed.get(), &has_intermediary);
 512     }
 513     EXPECT_EQ(tests[i].expected_result, has_chrome_proxy_via_header);
 514     if (has_chrome_proxy_via_header && !tests[i].ignore_intermediary) {
 515       EXPECT_EQ(tests[i].expected_has_intermediary, has_intermediary);
 516     }
 517   }
 518 }
 519
 520 TEST_F(DataReductionProxyHeadersTest, GetDataReductionProxyBypassEventType) {
 521   const struct {
 522      const char* headers;
 523      DataReductionProxyBypassType expected_result;
 524   } tests[] = {
 525     { "HTTP/1.1 200 OK\n"
 526       "Chrome-Proxy: bypass=0\n"
 527       "Via: 1.1 Chrome-Compression-Proxy\n",
 528       BYPASS_EVENT_TYPE_MEDIUM,
 529     },
 530     { "HTTP/1.1 200 OK\n"
 531       "Chrome-Proxy: bypass=1\n"
 532       "Via: 1.1 Chrome-Compression-Proxy\n",
 533       BYPASS_EVENT_TYPE_SHORT,
 534     },
 535     { "HTTP/1.1 200 OK\n"
 536       "Chrome-Proxy: bypass=59\n"
 537       "Via: 1.1 Chrome-Compression-Proxy\n",
 538       BYPASS_EVENT_TYPE_SHORT,
 539     },
 540     { "HTTP/1.1 200 OK\n"
 541       "Chrome-Proxy: bypass=60\n"
 542       "Via: 1.1 Chrome-Compression-Proxy\n",
 543       BYPASS_EVENT_TYPE_MEDIUM,
 544     },
 545     { "HTTP/1.1 200 OK\n"
 546       "Chrome-Proxy: bypass=300\n"
 547       "Via: 1.1 Chrome-Compression-Proxy\n",
 548       BYPASS_EVENT_TYPE_MEDIUM,
 549     },
 550     { "HTTP/1.1 200 OK\n"
 551       "Chrome-Proxy: bypass=301\n"
 552       "Via: 1.1 Chrome-Compression-Proxy\n",
 553       BYPASS_EVENT_TYPE_LONG,
 554     },
 555     { "HTTP/1.1 200 OK\n"
 556       "Chrome-Proxy: block-once\n"
 557       "Via: 1.1 Chrome-Compression-Proxy\n",
 558       BYPASS_EVENT_TYPE_CURRENT,
 559     },
 560     { "HTTP/1.1 500 Internal Server Error\n"
 561       "Via: 1.1 Chrome-Compression-Proxy\n",
 562       BYPASS_EVENT_TYPE_STATUS_500_HTTP_INTERNAL_SERVER_ERROR,
 563     },
 564     { "HTTP/1.1 501 Not Implemented\n"
 565       "Via: 1.1 Chrome-Compression-Proxy\n",
 566       BYPASS_EVENT_TYPE_MAX,
 567     },
 568     { "HTTP/1.1 502 Bad Gateway\n"
 569       "Via: 1.1 Chrome-Compression-Proxy\n",
 570       BYPASS_EVENT_TYPE_STATUS_502_HTTP_BAD_GATEWAY,
 571     },
 572     { "HTTP/1.1 503 Service Unavailable\n"
 573       "Via: 1.1 Chrome-Compression-Proxy\n",
 574       BYPASS_EVENT_TYPE_STATUS_503_HTTP_SERVICE_UNAVAILABLE,
 575     },
 576     { "HTTP/1.1 504 Gateway Timeout\n"
 577       "Via: 1.1 Chrome-Compression-Proxy\n",
 578       BYPASS_EVENT_TYPE_MAX,
 579     },
 580     { "HTTP/1.1 505 HTTP Version Not Supported\n"
 581       "Via: 1.1 Chrome-Compression-Proxy\n",
 582       BYPASS_EVENT_TYPE_MAX,
 583     },
 584     { "HTTP/1.1 304 Not Modified\n",
 585         BYPASS_EVENT_TYPE_MAX,
 586     },
 587     { "HTTP/1.1 200 OK\n",
 588         BYPASS_EVENT_TYPE_MISSING_VIA_HEADER_OTHER,
 589     },
 590     { "HTTP/1.1 200 OK\n"
 591       "Chrome-Proxy: bypass=59\n",
 592       BYPASS_EVENT_TYPE_SHORT,
 593     },
 594     { "HTTP/1.1 502 Bad Gateway\n",
 595         BYPASS_EVENT_TYPE_STATUS_502_HTTP_BAD_GATEWAY,
 596     },
 597     { "HTTP/1.1 502 Bad Gateway\n"
 598       "Chrome-Proxy: bypass=59\n",
 599       BYPASS_EVENT_TYPE_SHORT,
 600     },
 601     { "HTTP/1.1 502 Bad Gateway\n"
 602       "Chrome-Proxy: bypass=59\n",
 603       BYPASS_EVENT_TYPE_SHORT,
 604     },
 605     { "HTTP/1.1 414 Request-URI Too Long\n",
 606         BYPASS_EVENT_TYPE_MISSING_VIA_HEADER_4XX,
 607     },
 608     { "HTTP/1.1 414 Request-URI Too Long\n"
 609       "Via: 1.1 Chrome-Compression-Proxy\n",
 610       BYPASS_EVENT_TYPE_MAX,
 611     },
 612     { "HTTP/1.1 407 Proxy Authentication Required\n",
 613         BYPASS_EVENT_TYPE_MALFORMED_407,
 614     },
 615     { "HTTP/1.1 407 Proxy Authentication Required\n"
 616       "Proxy-Authenticate: Basic\n"
 617       "Via: 1.1 Chrome-Compression-Proxy\n",
 618       BYPASS_EVENT_TYPE_MAX,
 619     }
 620   };
 621   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 622     std::string headers(tests[i].headers);
 623     HeadersToRaw(&headers);
 624     scoped_refptr<net::HttpResponseHeaders> parsed(
 625         new net::HttpResponseHeaders(headers));
 626     DataReductionProxyInfo chrome_proxy_info;
 627     EXPECT_EQ(
 628         tests[i].expected_result,
 629         GetDataReductionProxyBypassType(parsed.get(), &chrome_proxy_info));
 630   }
 631 }
 632
 633 TEST_F(DataReductionProxyHeadersTest,
 634        GetDataReductionProxyActionFingerprintChromeProxy) {
 635   const struct {
 636      std::string label;
 637      const char* headers;
 638      bool expected_fingerprint_exist;
 639      std::string expected_fingerprint;
 640   } tests[] = {
 641     { "fingerprint doesn't exist",
 642       "HTTP/1.1 200 OK\n"
 643       "Chrome-Proxy: bypass=0\n",
 644       false,
 645       "",
 646     },
 647     { "fingerprint occurs once",
 648       "HTTP/1.1 200 OK\n"
 649       "Chrome-Proxy: bypass=1, fcp=fp\n",
 650       true,
 651       "fp",
 652     },
 653     { "fingerprint occurs twice",
 654       "HTTP/1.1 200 OK\n"
 655       "Chrome-Proxy: bypass=2, fcp=fp1, fcp=fp2\n",
 656       true,
 657       "fp1",
 658     },
 659   };
 660   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 661     std::string headers(tests[i].headers);
 662     HeadersToRaw(&headers);
 663     scoped_refptr<net::HttpResponseHeaders> parsed(
 664         new net::HttpResponseHeaders(headers));
 665
 666     std::string fingerprint;
 667     bool fingerprint_exist = GetDataReductionProxyActionFingerprintChromeProxy(
 668         parsed.get(), &fingerprint);
 669     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
 670         << tests[i].label;
 671
 672     if (fingerprint_exist)
 673       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
 674   }
 675 }
 676
 677 TEST_F(DataReductionProxyHeadersTest,
 678        GetDataReductionProxyActionFingerprintVia) {
 679   const struct {
 680      std::string label;
 681      const char* headers;
 682      bool expected_fingerprint_exist;
 683      std::string expected_fingerprint;
 684   } tests[] = {
 685     { "fingerprint doesn't exist",
 686       "HTTP/1.1 200 OK\n"
 687       "Chrome-Proxy: bypass=0\n",
 688       false,
 689       "",
 690     },
 691     { "fingerprint occurs once",
 692       "HTTP/1.1 200 OK\n"
 693       "Chrome-Proxy: bypass=1, fvia=fvia\n",
 694       true,
 695       "fvia",
 696     },
 697     { "fingerprint occurs twice",
 698       "HTTP/1.1 200 OK\n"
 699       "Chrome-Proxy: bypass=2, fvia=fvia1, fvia=fvia2\n",
 700       true,
 701       "fvia1",
 702     },
 703   };
 704   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 705     std::string headers(tests[i].headers);
 706     HeadersToRaw(&headers);
 707     scoped_refptr<net::HttpResponseHeaders> parsed(
 708         new net::HttpResponseHeaders(headers));
 709
 710     std::string fingerprint;
 711     bool fingerprint_exist =
 712         GetDataReductionProxyActionFingerprintVia(parsed.get(), &fingerprint);
 713     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
 714         << tests[i].label;
 715
 716     if (fingerprint_exist)
 717       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
 718   }
 719 }
 720
 721 TEST_F(DataReductionProxyHeadersTest,
 722        GetDataReductionProxyActionFingerprintOtherHeaders) {
 723   const struct {
 724      std::string label;
 725      const char* headers;
 726      bool expected_fingerprint_exist;
 727      std::string expected_fingerprint;
 728   } tests[] = {
 729     { "fingerprint doesn't exist",
 730       "HTTP/1.1 200 OK\n"
 731       "Chrome-Proxy: bypass=0\n",
 732       false,
 733       "",
 734     },
 735     { "fingerprint occurs once",
 736       "HTTP/1.1 200 OK\n"
 737       "Chrome-Proxy: bypass=1, foh=foh\n",
 738       true,
 739       "foh",
 740     },
 741     { "fingerprint occurs twice",
 742       "HTTP/1.1 200 OK\n"
 743       "Chrome-Proxy: bypass=2, foh=foh1, foh=foh2\n",
 744       true,
 745       "foh1",
 746     },
 747   };
 748   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 749     std::string headers(tests[i].headers);
 750     HeadersToRaw(&headers);
 751     scoped_refptr<net::HttpResponseHeaders> parsed(
 752         new net::HttpResponseHeaders(headers));
 753
 754     std::string fingerprint;
 755     bool fingerprint_exist = GetDataReductionProxyActionFingerprintOtherHeaders(
 756         parsed.get(), &fingerprint);
 757     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
 758         << tests[i].label;
 759
 760     if (fingerprint_exist)
 761       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
 762   }
 763 }
 764
 765 TEST_F(DataReductionProxyHeadersTest,
 766        GetDataReductionProxyActionFingerprintContentLength) {
 767   const struct {
 768      std::string label;
 769      const char* headers;
 770      bool expected_fingerprint_exist;
 771      std::string expected_fingerprint;
 772   } tests[] = {
 773     { "fingerprint doesn't exist",
 774       "HTTP/1.1 200 OK\n"
 775       "Chrome-Proxy: bypass=0\n",
 776       false,
 777       "",
 778     },
 779     { "fingerprint occurs once",
 780       "HTTP/1.1 200 OK\n"
 781       "Chrome-Proxy: bypass=1, fcl=fcl\n",
 782       true,
 783       "fcl",
 784     },
 785     { "fingerprint occurs twice",
 786       "HTTP/1.1 200 OK\n"
 787       "Chrome-Proxy: bypass=2, fcl=fcl1, fcl=fcl2\n",
 788       true,
 789       "fcl1",
 790     },
 791   };
 792   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 793     std::string headers(tests[i].headers);
 794     HeadersToRaw(&headers);
 795     scoped_refptr<net::HttpResponseHeaders> parsed(
 796         new net::HttpResponseHeaders(headers));
 797
 798     std::string fingerprint;
 799     bool fingerprint_exist =
 800         GetDataReductionProxyActionFingerprintContentLength(parsed.get(),
 801                                                             &fingerprint);
 802     EXPECT_EQ(tests[i].expected_fingerprint_exist, fingerprint_exist)
 803         << tests[i].label;
 804
 805     if (fingerprint_exist)
 806       EXPECT_EQ(tests[i].expected_fingerprint, fingerprint) << tests[i].label;
 807   }
 808 }
 809
 810 TEST_F(DataReductionProxyHeadersTest,
 811        GetDataReductionProxyHeaderWithFingerprintRemoved) {
 812   const struct {
 813     std::string label;
 814     const char* headers;
 815     std::string expected_output_values_string;
 816   } test[] = {
 817     {
 818       "Checks the case that there is no Chrome-Proxy header's fingerprint.",
 819       "HTTP/1.1 200 OK\n"
 820       "Chrome-Proxy: 1,2,3,5\n",
 821       "1,2,3,5,",
 822     },
 823     {
 824       "Checks the case that there is Chrome-Proxy header's fingerprint.",
 825       "HTTP/1.1 200 OK\n"
 826       "Chrome-Proxy: 1,2,3,fcp=4,5\n",
 827       "1,2,3,5,",
 828     },
 829     {
 830       "Checks the case that there is Chrome-Proxy header's fingerprint, and it"
 831       "occurs at the end.",
 832       "HTTP/1.1 200 OK\n"
 833       "Chrome-Proxy: 1,2,3,fcp=4,",
 834       "1,2,3,",
 835     },
 836     {
 837       "Checks the case that there is Chrome-Proxy header's fingerprint, and it"
 838       "occurs at the beginning.",
 839       "HTTP/1.1 200 OK\n"
 840       "Chrome-Proxy: fcp=1,2,3,",
 841       "2,3,",
 842     },
 843     {
 844       "Checks the case that value is longer than prefix.",
 845       "HTTP/1.1 200 OK\n"
 846       "Chrome-Proxy: fcp=1,fcp!=1,fcp!=2,fcpfcp=3",
 847       "fcp!=1,fcp!=2,fcpfcp=3,",
 848     },
 849     {
 850       "Checks the case that value is shorter than prefix but similar.",
 851       "HTTP/1.1 200 OK\n"
 852       "Chrome-Proxy: fcp=1,fcp,fcp=",
 853       "fcp,fcp=,",
 854     },
 855   };
 856
 857   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test); ++i) {
 858     std::string headers(test[i].headers);
 859     HeadersToRaw(&headers);
 860     scoped_refptr<net::HttpResponseHeaders> parsed(
 861         new net::HttpResponseHeaders(headers));
 862
 863     std::vector<std::string> output_values;
 864     GetDataReductionProxyHeaderWithFingerprintRemoved(parsed.get(),
 865                                                       &output_values);
 866
 867     std::string output_values_string;
 868     for (size_t j = 0; j < output_values.size(); ++j)
 869       output_values_string += output_values[j] + ",";
 870
 871     EXPECT_EQ(test[i].expected_output_values_string, output_values_string)
 872         << test[i].label;
 873   }
 874 }
 875
 876 }  // namespace data_reduction_proxy