| /* |
| * Copyright 2010 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) |
| |
| // Unit-test the cache extender. |
| |
| #include "net/instaweb/http/public/counting_url_async_fetcher.h" |
| #include "net/instaweb/http/public/log_record.h" |
| #include "net/instaweb/http/public/logging_proto.h" |
| #include "net/instaweb/http/public/logging_proto_impl.h" |
| #include "net/instaweb/http/public/request_context.h" |
| #include "net/instaweb/rewriter/public/cache_extender.h" |
| #include "net/instaweb/rewriter/public/css_outline_filter.h" |
| #include "net/instaweb/rewriter/public/domain_lawyer.h" |
| #include "net/instaweb/rewriter/public/javascript_code_block.h" |
| #include "net/instaweb/rewriter/public/rewrite_driver.h" |
| #include "net/instaweb/rewriter/public/rewrite_options.h" |
| #include "net/instaweb/rewriter/public/rewrite_stats.h" |
| #include "net/instaweb/rewriter/public/rewrite_test_base.h" |
| #include "net/instaweb/rewriter/public/server_context.h" |
| #include "net/instaweb/rewriter/public/test_url_namer.h" |
| #include "pagespeed/kernel/base/basictypes.h" |
| #include "pagespeed/kernel/base/gmock.h" |
| #include "pagespeed/kernel/base/gtest.h" |
| #include "pagespeed/kernel/base/hasher.h" |
| #include "pagespeed/kernel/base/mock_message_handler.h" |
| #include "pagespeed/kernel/base/ref_counted_ptr.h" |
| #include "pagespeed/kernel/base/statistics.h" |
| #include "pagespeed/kernel/base/string.h" |
| #include "pagespeed/kernel/base/string_util.h" |
| #include "pagespeed/kernel/base/timer.h" |
| #include "pagespeed/kernel/cache/lru_cache.h" |
| #include "pagespeed/kernel/html/html_parse_test_base.h" |
| #include "pagespeed/kernel/http/content_type.h" |
| #include "pagespeed/kernel/http/google_url.h" |
| #include "pagespeed/kernel/http/http_names.h" |
| #include "pagespeed/kernel/http/response_headers.h" |
| #include "pagespeed/kernel/http/semantic_type.h" |
| |
| namespace net_instaweb { |
| |
| namespace { |
| |
| const char kCssFormat[] = "<link rel='stylesheet' href='%s' type='text/css'>\n"; |
| const char kHtmlFormat[] = |
| "<link rel='stylesheet' href='%s' type='text/css'>%s\n" |
| "<img src='%s'/>%s\n" |
| "<script type='text/javascript' src='%s'></script>%s\n"; |
| |
| // See Issue 295: cache_extender, which only rewrites content on |
| // fetch, failed to recognize a cache-extended CSS file specified with |
| // a query-param as CSS. It failed to recognize it because its |
| // file-extension was obscured by a query-param. Moreover, we should |
| // not be dependent on input resource extensions to determine |
| // content-type. Thus it did not run its absolutification pass. |
| // |
| // Instead we must ensure that the content-type is discovered from the |
| // input resource response headers. |
| const char kCssFile[] = "sub/a.css?v=1"; |
| const char kCssTail[] = "a.css?v=1"; |
| const char kCssSubdir[] = "sub/"; |
| const char kCssDataFormat[] = ".blue {color: blue; src: url(%sembedded.png);}"; |
| const char kFilterId[] = "ce"; |
| const char kImageData[] = "Not really JPEG but irrelevant for this test"; |
| const char kJsData[] = "alert('hello, world!')"; |
| const char kJsDataIntrospective[] = "$('script')"; |
| const char kNewDomain[] = "http://new.com/"; |
| const int kShortTtlSec = 100; |
| const int kMediumTtlSec = 100000; |
| const int kLongTtlSec = 100000000; |
| |
| class CacheExtenderTest : public RewriteTestBase { |
| protected: |
| enum InputOrOutput { kInput, kOutput, kBoth }; |
| |
| CacheExtenderTest() |
| : kCssData(CssData("")), |
| kCssPath(StrCat(kTestDomain, kCssSubdir)), |
| last_modified_on_origin_(true) { |
| num_cache_extended_ = statistics()->GetVariable( |
| CacheExtender::kCacheExtensions); |
| } |
| |
| // TODO(matterbury): Delete this method as it should be redundant. |
| virtual void SetUp() { |
| RewriteTestBase::SetUp(); |
| } |
| |
| void InitTest(int64 ttl) { |
| options()->EnableExtendCacheFilters(); |
| InitTestWithoutFilters(ttl); |
| } |
| |
| // Initializes a resource for mock fetching. Similar to |
| // RewriteTestBase::SetResponseWithDefaultHeaders(), but |
| // retains Last-Modified header as that will propagate to the output. |
| void InitResource( |
| StringPiece resource_name, |
| const ContentType& content_type, |
| StringPiece content, |
| int64 ttl_sec) { |
| if (last_modified_on_origin_) { |
| GoogleString url = AbsolutifyUrl(resource_name); |
| ResponseHeaders response_headers; |
| DefaultResponseHeaders(content_type, ttl_sec, &response_headers); |
| SetFetchResponse(url, response_headers, content); |
| } else { |
| SetResponseWithDefaultHeaders(resource_name, content_type, content, |
| ttl_sec); |
| } |
| } |
| |
| void InitTestWithoutFilters(int64 ttl) { |
| rewrite_driver()->AddFilters(); |
| InitResource(kCssFile, kContentTypeCss, kCssData, ttl); |
| InitResource("b.jpg", kContentTypeJpeg, kImageData, ttl); |
| InitResource("c.js", kContentTypeJavascript, kJsData, ttl); |
| InitResource("introspective.js", kContentTypeJavascript, |
| kJsDataIntrospective, ttl); |
| // Reset stats. |
| num_cache_extended_->Clear(); |
| } |
| |
| // Generate HTML loading 3 resources with the specified URLs |
| GoogleString GenerateHtml(const GoogleString& a, |
| const GoogleString& b, |
| const GoogleString& c, |
| InputOrOutput input_or_output) { |
| GoogleString a_debug, b_debug, c_debug; |
| if (input_or_output == kOutput) { |
| // We never generate debug messages on input html! |
| a_debug = DebugMessage(a); |
| b_debug = DebugMessage(b); |
| c_debug = DebugMessage(c); |
| } |
| return StringPrintf(kHtmlFormat, |
| a.c_str(), a_debug.c_str(), |
| b.c_str(), b_debug.c_str(), |
| c.c_str(), c_debug.c_str()); |
| } |
| |
| // Helper to test for how we handle trailing junk in URLs |
| void TestCorruptUrl(StringPiece junk, bool append_junk) { |
| InitTest(kShortTtlSec); |
| GoogleString a_ext = Encode(kCssSubdir, "ce", "0", kCssTail, "css"); |
| GoogleString b_ext = Encode("", "ce", "0", "b.jpg", "jpg"); |
| GoogleString c_ext = Encode("", "ce", "0", "c.js", "js"); |
| |
| ValidateExpected("no_ext_corrupt_fetched", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml(a_ext, b_ext, c_ext, kOutput)); |
| GoogleString output; |
| EXPECT_TRUE(FetchResourceUrl( |
| ChangeSuffix(StrCat(kTestDomain, a_ext), append_junk, ".css", junk), |
| &output)); |
| EXPECT_TRUE(FetchResourceUrl( |
| ChangeSuffix(StrCat(kTestDomain, b_ext), append_junk, ".jpg", junk), |
| &output)); |
| EXPECT_TRUE(FetchResourceUrl( |
| ChangeSuffix(StrCat(kTestDomain, c_ext), append_junk, ".js", junk), |
| &output)); |
| ValidateExpected("no_ext_corrupt_cached", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml(a_ext, b_ext, c_ext, kOutput)); |
| } |
| |
| static GoogleString CssData(StringPiece url) { |
| return StringPrintf(kCssDataFormat, url.as_string().c_str()); |
| } |
| |
| void TestExtendFromHtml() { |
| InitTest(kShortTtlSec); |
| for (int i = 0; i < 3; i++) { |
| const GoogleString input_html = |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput); |
| if (lru_cache()->IsHealthy()) { |
| AbstractLogRecord* log_record = |
| rewrite_driver()->request_context()->log_record(); |
| log_record->SetAllowLoggingUrls(true); |
| ValidateExpected( |
| "do_extend", |
| input_html, |
| GenerateHtml(Encode(kCssSubdir, "ce", "0", kCssTail, "css"), |
| Encode("", "ce", "0", "b.jpg", "jpg"), |
| Encode("", "ce", "0", "c.js", "js"), kOutput)); |
| EXPECT_EQ((i + 1) * 3, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| EXPECT_STREQ("ec,ei,es", AppliedRewriterStringFromLog()); |
| VerifyRewriterInfoEntry(log_record, "ec", 0, (i * 3), (i + 1) * 3, |
| 3, "http://test.com/sub/a.css?v=1"); |
| VerifyRewriterInfoEntry(log_record, "ei", 1, 1 + (i * 3), (i + 1) * 3, |
| 3, "http://test.com/b.jpg"); |
| VerifyRewriterInfoEntry(log_record, "es", 2, 2 + (i * 3), (i + 1) * 3, |
| 3, "http://test.com/c.js"); |
| } else { |
| ValidateNoChanges("unhealthy", input_html); |
| EXPECT_EQ(0, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| EXPECT_STREQ("", AppliedRewriterStringFromLog()); |
| } |
| } |
| } |
| |
| void TestServeFiles() { |
| GoogleString content; |
| |
| InitTest(kShortTtlSec); |
| int64 expected_last_modified_time_ms = last_modified_on_origin_ |
| ? timer()->NowMs() : 0; |
| |
| // To ensure there's no absolutification (below) of embedded.png's URL in |
| // the served CSS file, we have to serve it from test.com and not from |
| // cdn.com which TestUrlNamer does when it's being used. |
| ResponseHeaders headers; |
| AdvanceTimeMs(10 * Timer::kSecondMs); |
| ASSERT_TRUE(FetchResourceUrl( |
| EncodeNormal(kCssPath, kFilterId, "0", kCssTail, "css"), &content, |
| &headers)); |
| int64 fetch1_time_ms = timer()->NowMs(); |
| EXPECT_EQ(expected_last_modified_time_ms, headers.last_modified_time_ms()); |
| EXPECT_EQ(last_modified_on_origin_, |
| headers.Has(HttpAttributes::kLastModified)); |
| EXPECT_GT(fetch1_time_ms, expected_last_modified_time_ms); |
| // No canonical on .css |
| EXPECT_FALSE(headers.Has(HttpAttributes::kLink)); |
| |
| AdvanceTimeMs(10 * Timer::kSecondMs); |
| |
| EXPECT_EQ(kCssData, content); // no absolutification |
| headers.Clear(); |
| ASSERT_TRUE(FetchResource(kTestDomain, kFilterId, "b.jpg", "jpg", |
| &content, &headers)); |
| const char* link = headers.Lookup1(HttpAttributes::kLink); |
| ASSERT_TRUE(link != NULL); |
| // .jpg should get a canonical link. |
| EXPECT_STREQ("<http://test.com/b.jpg>; rel=\"canonical\"", link); |
| int64 fetch2_time_ms = timer()->NowMs(); |
| EXPECT_GT(fetch2_time_ms, fetch1_time_ms); |
| EXPECT_EQ(expected_last_modified_time_ms, headers.last_modified_time_ms()); |
| EXPECT_EQ(last_modified_on_origin_, |
| headers.Has(HttpAttributes::kLastModified)); |
| headers.Clear(); |
| EXPECT_EQ(GoogleString(kImageData), content); |
| ASSERT_TRUE(FetchResource(kTestDomain, kFilterId, "c.js", "js", &content, |
| &headers)); |
| EXPECT_EQ(expected_last_modified_time_ms, headers.last_modified_time_ms()); |
| EXPECT_EQ(last_modified_on_origin_, |
| headers.Has(HttpAttributes::kLastModified)); |
| // No canonical on .js |
| EXPECT_FALSE(headers.Has(HttpAttributes::kLink)); |
| headers.Clear(); |
| |
| EXPECT_EQ(GoogleString(kJsData), content); |
| } |
| |
| void VerifyUnauthorizedResourcesNotExtended() { |
| EnableDebug(); |
| SetResponseWithDefaultHeaders("http://unauth.example.com/unauth.js", |
| kContentTypeJavascript, kJsData, |
| kShortTtlSec); |
| SetResponseWithDefaultHeaders("http://unauth.example.com/unauth.css", |
| kContentTypeCss, kCssData, kShortTtlSec); |
| const char kJsReference[] = |
| "<script src='http://unauth.example.com/unauth.js'></script>"; |
| GoogleUrl gurl("http://unauth.example.com/unauth.xxx"); |
| const GoogleString kDebugMessage = StrCat( |
| "<!--", RewriteDriver::GenerateUnauthorizedDomainDebugComment(gurl), |
| "-->"); |
| const char kCssReference[] = |
| "<link rel=stylesheet href='http://unauth.example.com/unauth.css'>"; |
| ValidateExpected("dont_extend_unauth_js", |
| StrCat(kJsReference, kCssReference), |
| StrCat(kJsReference, kDebugMessage, |
| kCssReference, kDebugMessage)); |
| EXPECT_EQ(0, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| EXPECT_STREQ("", AppliedRewriterStringFromLog()); |
| } |
| |
| Variable* num_cache_extended_; |
| const GoogleString kCssData; |
| const GoogleString kCssPath; |
| bool last_modified_on_origin_; |
| }; |
| |
| TEST_F(CacheExtenderTest, DoExtend) { |
| TestExtendFromHtml(); |
| EXPECT_EQ(6, lru_cache()->num_hits()) << "3 metadata * 2 cached iterations"; |
| EXPECT_EQ(6, lru_cache()->num_misses()) << "3 metadata + 3 input resources"; |
| EXPECT_EQ(6, lru_cache()->num_inserts()) << "3 metadata + 3 input resources"; |
| EXPECT_EQ(3, counting_url_async_fetcher()->fetch_count()); |
| } |
| |
| TEST_F(CacheExtenderTest, ExtendUnhealthy) { |
| lru_cache()->set_is_healthy(false); |
| TestExtendFromHtml(); |
| EXPECT_EQ(0, lru_cache()->num_hits()); |
| EXPECT_EQ(0, lru_cache()->num_misses()); |
| EXPECT_EQ(0, lru_cache()->num_inserts()); |
| EXPECT_EQ(0, counting_url_async_fetcher()->fetch_count()); |
| } |
| |
| class CacheExtenderTestPreserveURLs : public CacheExtenderTest { |
| public: |
| virtual void SetUp() {} |
| |
| // This function should only be called once, as it sets the filters |
| // and options. |
| void TestExtend(bool img_extend, bool css_extend, bool js_extend) { |
| options()->SoftEnableFilterForTesting(RewriteOptions::kExtendCacheCss); |
| options()->SoftEnableFilterForTesting(RewriteOptions::kExtendCacheImages); |
| options()->SoftEnableFilterForTesting(RewriteOptions::kExtendCacheScripts); |
| if (!img_extend) { |
| options()->set_image_preserve_urls(true); |
| } |
| if (!css_extend) { |
| options()->set_css_preserve_urls(true); |
| } |
| if (!js_extend) { |
| options()->set_js_preserve_urls(true); |
| } |
| CacheExtenderTest::SetUp(); |
| InitTestWithoutFilters(kShortTtlSec); |
| |
| GoogleString expected_img_html = "b.jpg"; |
| GoogleString expected_css_html = kCssFile; |
| GoogleString expected_js_html = "c.js"; |
| |
| if (img_extend) { |
| expected_img_html = Encode("", "ce", "0", "b.jpg", "jpg"); |
| } |
| if (css_extend) { |
| expected_css_html = Encode(kCssSubdir, "ce", "0", kCssTail, "css"); |
| } |
| if (js_extend) { |
| expected_js_html = Encode("", "ce", "0", "c.js", "js"); |
| } |
| ValidateExpected( |
| "do_extend", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml( |
| expected_css_html, expected_img_html, expected_js_html, kOutput)); |
| } |
| }; |
| |
| TEST_F(CacheExtenderTestPreserveURLs, CacheExtenderPreserveImageURLsOn) { |
| TestExtend(false, // img_extend |
| true, // css_extend |
| true); // js_extend |
| } |
| |
| TEST_F(CacheExtenderTestPreserveURLs, CacheExtenderPreserveCssURLsOn) { |
| TestExtend(true, // img_extend |
| false, // css_extend |
| true); // js_extend |
| } |
| |
| TEST_F(CacheExtenderTestPreserveURLs, CacheExtenderPreserveJsURLsOn) { |
| TestExtend(true, // img_extend |
| true, // css_extend |
| false); // js_extend |
| } |
| |
| TEST_F(CacheExtenderTestPreserveURLs, CacheExtenderPreserveAllURLsOn) { |
| TestExtend(false, // img_extend |
| false, // css_extend |
| false); // js_extend |
| } |
| |
| TEST_F(CacheExtenderTest, DoNotExtendUnauthorizedResources) { |
| InitTest(kShortTtlSec); |
| VerifyUnauthorizedResourcesNotExtended(); |
| } |
| |
| TEST_F(CacheExtenderTest, DoNotExtendUnauthorizedResourcesWithUnauthEnabled) { |
| InitTest(kShortTtlSec); |
| options()->ClearSignatureForTesting(); |
| options()->AddInlineUnauthorizedResourceType(semantic_type::kStylesheet); |
| options()->AddInlineUnauthorizedResourceType(semantic_type::kScript); |
| server_context()->ComputeSignature(options()); |
| VerifyUnauthorizedResourcesNotExtended(); |
| } |
| |
| TEST_F(CacheExtenderTest, |
| DontExtendIntrospectiveDefault) { |
| InitTest(kShortTtlSec); |
| const char kJsTemplate[] = "<script src=\"%s\"></script>"; |
| ValidateExpected( |
| "dont_extend_introspective_js", |
| StringPrintf(kJsTemplate, "introspective.js"), |
| StringPrintf(kJsTemplate, "introspective.js")); |
| EXPECT_EQ(0, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| EXPECT_STREQ("", AppliedRewriterStringFromLog()); |
| } |
| |
| TEST_F(CacheExtenderTest, |
| DontExtendIntrospectiveDebug) { |
| options()->EnableFilter(RewriteOptions::kDebug); |
| InitTest(kShortTtlSec); |
| const char kJsTemplate[] = "<script src=\"%s\"></script>"; |
| GoogleString kInsertComment( |
| StrCat(StringPrintf(kJsTemplate, "introspective.js"), "<!--", |
| JavascriptCodeBlock::kIntrospectionComment, "-->")); |
| Parse("dont_extend_introspective_js", |
| StringPrintf(kJsTemplate, "introspective.js")); |
| EXPECT_THAT(output_buffer_, ::testing::HasSubstr(kInsertComment)); |
| EXPECT_EQ(0, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| EXPECT_STREQ("", AppliedRewriterStringFromLog()); |
| } |
| |
| TEST_F(CacheExtenderTest, DoExtendIntrospectiveJavascript) { |
| options()->ClearSignatureForTesting(); |
| options()->set_avoid_renaming_introspective_javascript(false); |
| InitTest(kShortTtlSec); |
| const char kJsTemplate[] = "<script src=\"%s\"></script>"; |
| ValidateExpected( |
| "do_extend_introspective_js", |
| StringPrintf(kJsTemplate, "introspective.js"), |
| StringPrintf(kJsTemplate, |
| Encode("", "ce", "0", "introspective.js", "js").c_str())); |
| } |
| |
| TEST_F(CacheExtenderTest, DoExtendLinkRelCaseInsensitive) { |
| InitTest(kShortTtlSec); |
| const char kMixedCaseTemplate[] = "<link rel=StyleSheet href='%s'>"; |
| ValidateExpected( |
| "extend_ci", |
| StringPrintf(kMixedCaseTemplate, kCssFile), |
| StringPrintf(kMixedCaseTemplate, |
| Encode(kCssSubdir, "ce", "0", kCssTail, "css").c_str())); |
| } |
| |
| TEST_F(CacheExtenderTest, DoExtendForImagesOnly) { |
| AddFilter(RewriteOptions::kExtendCacheImages); |
| SetResponseWithDefaultHeaders(kCssFile, kContentTypeCss, |
| kCssData, kShortTtlSec); |
| SetResponseWithDefaultHeaders("b.jpg", kContentTypeJpeg, |
| kImageData, kShortTtlSec); |
| SetResponseWithDefaultHeaders("c.js", kContentTypeJavascript, |
| kJsData, kShortTtlSec); |
| |
| for (int i = 0; i < 3; i++) { |
| ValidateExpected( |
| "do_extend", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml( |
| kCssFile, Encode("", "ce", "0", "b.jpg", "jpg"), "c.js", kOutput)); |
| EXPECT_EQ((i + 1), num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| EXPECT_STREQ("ei", AppliedRewriterStringFromLog()); |
| } |
| } |
| |
| TEST_F(CacheExtenderTest, Handle404) { |
| // Test to make sure that a missing input is handled well. |
| options()->EnableExtendCacheFilters(); |
| rewrite_driver()->AddFilters(); |
| DebugWithMessage("<!--4xx status code, preventing rewriting of %url%-->"); |
| SetFetchResponse404("404.css"); |
| static const char kLink[] = "<link rel=stylesheet href='404.css'>"; |
| for (int i = 0; i < 2; ++i) { |
| // Validate twice to make sure caching doesn't break it. |
| ValidateExpected("404", kLink, StrCat(kLink, DebugMessage("404.css"))); |
| } |
| |
| // Check with metadata cache flushed but not http cache. |
| lru_cache()->DeleteWithPrefixForTesting( |
| ServerContext::kCacheKeyResourceNamePrefix); |
| ValidateExpected("404", kLink, StrCat(kLink, DebugMessage("404.css"))); |
| } |
| |
| TEST_F(CacheExtenderTest, Handle503) { |
| // Test to make sure that a missing input is handled well. |
| options()->EnableExtendCacheFilters(); |
| rewrite_driver()->AddFilters(); |
| DebugWithMessage("<!--Fetch failure, preventing rewriting of %url%-->"); |
| GoogleString url = AbsolutifyUrl("503.css"); |
| ResponseHeaders response_headers; |
| response_headers.SetStatusAndReason(HttpStatus::kUnavailable); |
| SetFetchResponse(url, response_headers, StringPiece()); |
| static const char kLink[] = "<link rel=stylesheet href='503.css'>"; |
| for (int i = 0; i < 2; ++i) { |
| // Validate twice to make sure caching doesn't break it. |
| ValidateExpected("503", kLink, StrCat(kLink, DebugMessage(url))); |
| } |
| |
| // Check with metadata cache flushed but not http cache. |
| lru_cache()->DeleteWithPrefixForTesting( |
| ServerContext::kCacheKeyResourceNamePrefix); |
| ValidateExpected("503", kLink, StrCat(kLink, DebugMessage(url))); |
| } |
| |
| TEST_F(CacheExtenderTest, UrlTooLong) { |
| options()->EnableExtendCacheFilters(); |
| rewrite_driver()->AddFilters(); |
| |
| // Make the filename too long. |
| GoogleString long_string(options()->max_url_segment_size() + 1, 'z'); |
| |
| GoogleString css_name = StrCat("style.css?z=", long_string); |
| GoogleString jpg_name = StrCat("image.jpg?z=", long_string); |
| GoogleString js_name = StrCat("script.js?z=", long_string); |
| SetResponseWithDefaultHeaders(css_name, kContentTypeCss, |
| kCssData, kShortTtlSec); |
| SetResponseWithDefaultHeaders(jpg_name, kContentTypeJpeg, |
| kImageData, kShortTtlSec); |
| SetResponseWithDefaultHeaders(js_name, kContentTypeJavascript, |
| kJsData, kShortTtlSec); |
| |
| // If filename wasn't too long, this would be rewritten (like in DoExtend). |
| ValidateNoChanges( |
| "url_too_long", GenerateHtml(css_name, jpg_name, js_name, kBoth)); |
| EXPECT_EQ(0, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| } |
| |
| TEST_F(CacheExtenderTest, NoInputResource) { |
| InitTest(kShortTtlSec); |
| // Test for not crashing on bad/disallowed URL. |
| ValidateNoChanges("bad url", |
| GenerateHtml("swly://example.com/sub/a.css", |
| "http://evil.com/b.jpg", |
| "http://moreevil.com/c.js", kBoth)); |
| } |
| |
| TEST_F(CacheExtenderTest, NoExtendAlreadyCachedProperly) { |
| InitTest(kLongTtlSec); // cached for a long time to begin with |
| ValidateNoChanges("no_extend_cached_properly", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kBoth)); |
| EXPECT_EQ(0, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| } |
| |
| TEST_F(CacheExtenderTest, ExtendIfSharded) { |
| InitTest(kLongTtlSec); // cached for a long time to begin with |
| EXPECT_TRUE(AddShard(kTestDomain, "shard0.com,shard1.com")); |
| // shard0 is always selected in the test because of our mock hasher |
| // that always returns 0. |
| ValidateExpected( |
| "extend_if_sharded", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kOutput), |
| GenerateHtml( |
| Encode(StrCat("http://shard0.com/", kCssSubdir), |
| "ce", "0", kCssTail, "css"), |
| Encode("http://shard0.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("http://shard0.com/", "ce", "0", "c.js", "js"), kOutput)); |
| } |
| |
| TEST_F(CacheExtenderTest, ExtendIfOriginMappedHttps) { |
| InitTest(kShortTtlSec); |
| EXPECT_TRUE(AddOriginDomainMapping(kTestDomain, "https://cdn.com")); |
| ValidateExpected( |
| "extend_if_origin_mapped_https", |
| GenerateHtml("https://cdn.com/sub/a.css?v=1", |
| "https://cdn.com/b.jpg", |
| "https://cdn.com/c.js", kInput), |
| GenerateHtml( |
| Encode("https://cdn.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("https://cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("https://cdn.com/", "ce", "0", "c.js", "js"), kOutput)); |
| } |
| |
| TEST_F(CacheExtenderTest, ExtendIfRewritten) { |
| InitTest(kLongTtlSec); // cached for a long time to begin with |
| |
| EXPECT_TRUE(AddRewriteDomainMapping("cdn.com", kTestDomain)); |
| ValidateExpected( |
| "extend_if_rewritten", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml( |
| Encode("http://cdn.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("http://cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("http://cdn.com/", "ce", "0", "c.js", "js"), kOutput)); |
| EXPECT_EQ(3, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| EXPECT_STREQ("ec,ei,es", AppliedRewriterStringFromLog()); |
| } |
| |
| TEST_F(CacheExtenderTest, NoLinkCanonicalIfDomainMapComplexity) { |
| InitTest(kShortTtlSec); |
| EXPECT_TRUE(AddRewriteDomainMapping("cdn.com", kTestDomain)); |
| EXPECT_TRUE(AddOriginDomainMapping(kTestDomain, "http://cdn.com")); |
| |
| ValidateExpected( |
| "extend_if_rewritten", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml( |
| Encode("http://cdn.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("http://cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("http://cdn.com/", "ce", "0", "c.js", "js"), kOutput)); |
| |
| // Make sure the resource doesn't get a link header, due to |
| // the rewrite mapping. |
| ResponseHeaders headers; |
| GoogleString content; |
| ASSERT_TRUE(FetchResourceUrl( |
| Encode(kTestDomain, "ce", "0", "b.jpg", "jpg"), |
| &content, &headers)); |
| EXPECT_FALSE(headers.Has(HttpAttributes::kLink)); |
| |
| // Likewise for reconstruction. |
| lru_cache()->Clear(); |
| ASSERT_TRUE(FetchResourceUrl( |
| Encode("http://cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| &content, &headers)); |
| EXPECT_FALSE(headers.Has(HttpAttributes::kLink)); |
| } |
| |
| TEST_F(CacheExtenderTest, ExtendIfShardedAndRewritten) { |
| InitTest(kLongTtlSec); // cached for a long time to begin with |
| |
| EXPECT_TRUE(AddRewriteDomainMapping("cdn.com", kTestDomain)); |
| |
| // Domain-rewriting is performed first. Then we shard. |
| EXPECT_TRUE(AddShard("cdn.com", "shard0.com,shard1.com")); |
| // shard0 is always selected in the test because of our mock hasher |
| // that always returns 0. |
| ValidateExpected( |
| "extend_if_sharded_and_rewritten", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml( |
| Encode("http://shard0.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("http://shard0.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("http://shard0.com/", "ce", "0", "c.js", "js"), kOutput)); |
| } |
| |
| TEST_F(CacheExtenderTest, ExtendIfShardedToHttps) { |
| InitTest(kLongTtlSec); |
| |
| // This Origin Mapping ensures any fetches are converted to http so work. |
| EXPECT_TRUE(AddOriginDomainMapping(kTestDomain, "https://test.com")); |
| |
| EXPECT_TRUE(AddShard("https://test.com", |
| "https://shard0.com,https://shard1.com")); |
| // shard0 is always selected in the test because of our mock hasher |
| // that always returns 0. |
| ValidateExpected( |
| "extend_if_sharded_to_https", |
| GenerateHtml("https://test.com/sub/a.css?v=1", |
| "https://test.com/b.jpg", |
| "https://test.com/c.js", kInput), |
| GenerateHtml( |
| Encode("https://shard0.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("https://shard0.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("https://shard0.com/", "ce", "0", "c.js", "js"), kOutput)); |
| } |
| |
| TEST_F(CacheExtenderTest, ExtendIfShardedAndRewritingAndMappingHttps) { |
| // This test started out trying to unit test mod_pagespeed issue #400 by |
| // replicating the settings the poster used. They didn't work, basically |
| // because the wildcard directive for *test.com conflicted with the later |
| // non-wildcard ones. After much experimentation we came up with these |
| // settings (without wildcards) that seem to do what the poster wants. |
| InitTest(kLongTtlSec); |
| SetResponseWithDefaultHeaders(StrCat("http://www.test.com/", kCssFile), |
| kContentTypeCss, kCssData, kLongTtlSec); |
| SetResponseWithDefaultHeaders("http://www.test.com/b.jpg", kContentTypeJpeg, |
| kImageData, kLongTtlSec); |
| SetResponseWithDefaultHeaders("http://www.test.com/c.js", |
| kContentTypeJavascript, kJsData, kLongTtlSec); |
| |
| // Set up the mappings that -should- work for issue 400. |
| ASSERT_TRUE(AddRewriteDomainMapping("http://cdn.com", |
| "http://test.com,http://www.test.com")); |
| ASSERT_TRUE(AddRewriteDomainMapping("https://cdn.com", |
| "https://test.com,https://www.test.com")); |
| ASSERT_TRUE(AddShard("http://cdn.com", |
| "http://s1.cdn.com,http://s2.cdn.com")); |
| ASSERT_TRUE(AddShard("https://cdn.com", |
| "https://s1.cdn.com,https://s2.cdn.com")); |
| ASSERT_TRUE(AddOriginDomainMapping("http://test.com", "https://test.com")); |
| ASSERT_TRUE(AddOriginDomainMapping("http://test.com", |
| "https://www.test.com")); |
| |
| // shard0 is always selected in the test because of our mock hasher |
| // that always returns 0. |
| ValidateExpected( |
| "extend_if_sharded_rewriting_mapping_bare_domain_http", |
| GenerateHtml("http://test.com/sub/a.css?v=1", |
| "http://test.com/b.jpg", |
| "http://test.com/c.js", kInput), |
| GenerateHtml( |
| Encode("http://s1.cdn.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("http://s1.cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("http://s1.cdn.com/", "ce", "0", "c.js", "js"), kOutput)); |
| ValidateExpected( |
| "extend_if_sharded_rewriting_mapping_bare_domain_https", |
| GenerateHtml("https://test.com/sub/a.css?v=1", |
| "https://test.com/b.jpg", |
| "https://test.com/c.js", kInput), |
| GenerateHtml( |
| Encode("https://s1.cdn.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("https://s1.cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("https://s1.cdn.com/", "ce", "0", "c.js", "js"), kOutput)); |
| ValidateExpected( |
| "extend_if_sharded_rewriting_mapping_www_domain_http", |
| GenerateHtml("http://www.test.com/sub/a.css?v=1", |
| "http://www.test.com/b.jpg", |
| "http://www.test.com/c.js", kInput), |
| GenerateHtml( |
| Encode("http://s1.cdn.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("http://s1.cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("http://s1.cdn.com/", "ce", "0", "c.js", "js"), kOutput)); |
| ValidateExpected( |
| "extend_if_sharded_rewriting_mapping_www_domain_https", |
| GenerateHtml("https://www.test.com/sub/a.css?v=1", |
| "https://www.test.com/b.jpg", |
| "https://www.test.com/c.js", kInput), |
| GenerateHtml( |
| Encode("https://s1.cdn.com/sub/", "ce", "0", kCssTail, "css"), |
| Encode("https://s1.cdn.com/", "ce", "0", "b.jpg", "jpg"), |
| Encode("https://s1.cdn.com/", "ce", "0", "c.js", "js"), kOutput)); |
| } |
| |
| // TODO(jmarantz): consider implementing and testing the sharding and |
| // domain-rewriting of uncacheable resources -- just don't sign the URLs. |
| |
| TEST_F(CacheExtenderTest, NoExtendOriginUncacheable) { |
| InitTest(0); // origin not cacheable |
| DebugWithMessage("<!--Uncacheable content, preventing rewriting of %url%-->"); |
| ValidateExpected( |
| "no_extend_origin_not_cacheable", |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kInput), |
| GenerateHtml(kCssFile, "b.jpg", "c.js", kOutput)); |
| EXPECT_EQ(0, num_cache_extended_->Get()) |
| << "Number of cache extended resources is wrong"; |
| } |
| |
| TEST_F(CacheExtenderTest, ServeFiles) { |
| last_modified_on_origin_ = true; |
| TestServeFiles(); |
| } |
| |
| TEST_F(CacheExtenderTest, ServeFilesNoLastModifiedOnOrigin) { |
| last_modified_on_origin_ = false; |
| TestServeFiles(); |
| } |
| |
| TEST_F(CacheExtenderTest, ServeFilesUnhealthy) { |
| lru_cache()->set_is_healthy(false); |
| TestServeFiles(); |
| } |
| |
| TEST_F(CacheExtenderTest, ConsistentHashWithRewrite) { |
| // Since CacheExtend is an on-the-fly filter, ServeFilesWithRewrite, above, |
| // verifies that we can decode a cache-extended CSS file and properly |
| // domain-rewrite embedded images. However, we go through the exercise |
| // of generating the rewritten content in the HTML path too -- we just |
| // don't cache it. However, what we must do is generate the correct hash |
| // code. To test that we need to use the real hasher. |
| UseMd5Hasher(); |
| AddRewriteDomainMapping(kNewDomain, kTestDomain); |
| InitTest(kShortTtlSec); |
| |
| // First do the HTML rewrite. |
| GoogleString hash = hasher()->Hash(kCssData); |
| GoogleString extended_css = |
| Encode(StrCat(kNewDomain, kCssSubdir), "ce", hash, kCssTail, "css"); |
| ValidateExpected("consistent_hash", |
| StringPrintf(kCssFormat, kCssFile), |
| StringPrintf(kCssFormat, extended_css.c_str())); |
| |
| // Note that the only output that gets cached is the MetaData insert, not |
| // the rewritten content, because this is an on-the-fly filter and we |
| // elect not to add cache pressure. We do of course also cache the original, |
| // and under traditional flow also get it from the cache. |
| EXPECT_EQ(2, lru_cache()->num_inserts()); |
| EXPECT_EQ(0, lru_cache()->num_hits()); |
| |
| // TODO(jmarantz): To make this test pass we need to set up the mock |
| // fetcher so it can find the resource in new.com, not just |
| // test.com. Functionally, this wouldn't be needed with a |
| // functional installation where both test.com and new.com are the |
| // same physical server. However it does indicate that we are going |
| // to fetch the resource using its original resolved name while |
| // rewriting HTML, but then when we serve the cache-extended |
| // resource we will not have it in our cache; we will have to fetch |
| // it again using the new name. We ought to be canonicalizing the |
| // URLs we write into the cache so we don't need this. This also |
| // applies to sharding. |
| SetResponseWithDefaultHeaders(StrCat(kNewDomain, kCssFile), kContentTypeCss, |
| kCssData, kShortTtlSec); |
| |
| // Now serve the resource, as in ServeFilesWithRewrite above. |
| GoogleString content; |
| ASSERT_TRUE(FetchResourceUrl(extended_css, &content)); |
| EXPECT_EQ(kCssData, content); |
| } |
| |
| TEST_F(CacheExtenderTest, ConsistentHashWithShard) { |
| // Similar to ConsistentHashWithRewrite, except that we've added sharding, |
| // and the shard computed for the embedded image is (luckily for the test) |
| // different than that for the .css file, thus the references within the |
| // css file are rewritten as absolute. |
| UseMd5Hasher(); |
| AddRewriteDomainMapping(kNewDomain, kTestDomain); |
| AddShard(kNewDomain, "shard1.com,shard2.com"); |
| InitTest(kShortTtlSec); |
| |
| // First do the HTML rewrite. |
| const char kHash[] = "MnXHB3ChUY"; |
| GoogleString extended_css = Encode("http://shard2.com/sub/", "ce", kHash, |
| kCssTail, "css"); |
| ValidateExpected("consistent_hash", |
| StringPrintf(kCssFormat, kCssFile), |
| StringPrintf(kCssFormat, extended_css.c_str())); |
| |
| // Note that the only output that gets cached is the MetaData insert, not |
| // the rewritten content, because this is an on-the-fly filter and we |
| // elect not to add cache pressure. We do of course also cache the original, |
| // and under traditional flow also get it from the cache. |
| EXPECT_EQ(2, lru_cache()->num_inserts()); |
| EXPECT_EQ(0, lru_cache()->num_hits()); |
| |
| // TODO(jmarantz): eliminate this when we canonicalize URLs before caching. |
| SetResponseWithDefaultHeaders(StrCat("http://shard2.com/", kCssFile), |
| kContentTypeCss, kCssData, kShortTtlSec); |
| |
| // Now serve the resource, as in ServeFilesWithRewrite above. |
| GoogleString content; |
| ASSERT_TRUE(FetchResourceUrl(extended_css, &content)); |
| |
| // Note that, through the luck of hashes, we've sharded the embedded |
| // image differently than the css file. |
| EXPECT_EQ(CssData("http://shard1.com/sub/"), content); |
| EXPECT_EQ(kHash, hasher()->Hash(content)); |
| } |
| |
| TEST_F(CacheExtenderTest, ServeFilesWithRewriteDomainsEnabled) { |
| GoogleString content; |
| AddRewriteDomainMapping(kNewDomain, kTestDomain); |
| InitTest(kShortTtlSec); |
| ASSERT_TRUE(FetchResource(kCssPath, kFilterId, kCssTail, "css", &content)); |
| EXPECT_EQ(CssData("http://new.com/sub/"), content); |
| } |
| |
| TEST_F(CacheExtenderTest, ServeFilesWithRewriteDomainAndPathEnabled) { |
| GoogleString content; |
| AddRewriteDomainMapping("http://new.com/test/", kTestDomain); |
| InitTest(kShortTtlSec); |
| ASSERT_TRUE(FetchResource(kCssPath, kFilterId, kCssTail, "css", &content)); |
| EXPECT_EQ(CssData("http://new.com/test/sub/"), content); |
| } |
| |
| TEST_F(CacheExtenderTest, ServeFilesWithShard) { |
| GoogleString content; |
| AddRewriteDomainMapping(kNewDomain, kTestDomain); |
| AddShard(kNewDomain, "shard1.com,shard2.com"); |
| InitTest(kShortTtlSec); |
| ASSERT_TRUE(FetchResource(kCssPath, kFilterId, kCssTail, "css", &content)); |
| EXPECT_EQ(CssData("http://shard1.com/sub/"), content); |
| } |
| |
| TEST_F(CacheExtenderTest, ServeFilesFromDelayedFetch) { |
| InitTest(kShortTtlSec); |
| // To ensure there's no absolutification (below) of embedded.png's URL in |
| // the served CSS file, we have to serve it from test.com and not from |
| // cdn.com which TestUrlNamer does when it's being used. |
| ServeResourceFromManyContexts( |
| EncodeNormal(kCssPath, "ce", "0", kCssTail, "css"), kCssData); |
| ServeResourceFromManyContexts(Encode(kTestDomain, "ce", "0", "b.jpg", "jpg"), |
| kImageData); |
| ServeResourceFromManyContexts(Encode(kTestDomain, "ce", "0", "c.js", "js"), |
| kJsData); |
| |
| // TODO(jmarantz): make ServeResourceFromManyContexts check: |
| // 1. Gets the data from the cache, with no mock fetchers, null file system |
| // 2. Gets the data from the file system, with no cache, no mock fetchers. |
| // 3. Gets the data from the mock fetchers: no cache, no file system. |
| } |
| |
| TEST_F(CacheExtenderTest, MinimizeCacheHits) { |
| options()->EnableFilter(RewriteOptions::kOutlineCss); |
| options()->EnableFilter(RewriteOptions::kExtendCacheCss); |
| options()->set_css_outline_min_bytes(1); |
| rewrite_driver()->AddFilters(); |
| GoogleString html_input = StrCat("<style>", kCssData, "</style>"); |
| GoogleString html_output = StringPrintf( |
| "<link rel=\"stylesheet\" href=\"%s\">", |
| Encode(kTestDomain, CssOutlineFilter::kFilterId, "0", "_", |
| "css").c_str()); |
| ValidateExpected("no_extend_origin_not_cacheable", html_input, html_output); |
| |
| // The key thing about this test is that the CacheExtendFilter should |
| // not pound the cache looking to see if it's already rewritten this |
| // resource. If we try, in the cache extend filter, to this already-optimized |
| // resource from the cache, then we'll get a cache-hit and decide that |
| // it's already got a long cache lifetime. But we should know, just from |
| // the name of the resource, that it should not be cache extended. |
| // The CSS outliner also should not produce any cache misses, as it currently |
| // does not cache. |
| EXPECT_EQ(0, lru_cache()->num_hits()); |
| EXPECT_EQ(0, lru_cache()->num_misses()); |
| } |
| |
| TEST_F(CacheExtenderTest, NoExtensionCorruption) { |
| TestCorruptUrl("%22", true /* append %22 */); |
| } |
| |
| TEST_F(CacheExtenderTest, NoQueryCorruption) { |
| TestCorruptUrl("?query", true /* append ?query*/); |
| } |
| |
| TEST_F(CacheExtenderTest, NoWrongExtCorruption) { |
| TestCorruptUrl(".html", false /* replace ext with .html */); |
| } |
| |
| TEST_F(CacheExtenderTest, MadeOnTheFly) { |
| // Make sure our fetches go through on-the-fly construction and not the cache. |
| InitTest(kMediumTtlSec); |
| |
| GoogleString b_ext = Encode("", "ce", "0", "b.jpg", "jpg"); |
| ValidateExpected("and_img", "<img src=\"b.jpg\">", |
| StrCat("<img src=\"", b_ext, "\">")); |
| |
| RewriteStats* stats = server_context()->rewrite_stats(); |
| EXPECT_EQ(0, stats->cached_resource_fetches()->Get()); |
| EXPECT_EQ(0, stats->succeeded_filter_resource_fetches()->Get()); |
| GoogleString out; |
| EXPECT_TRUE(FetchResourceUrl(StrCat(kTestDomain, b_ext), &out)); |
| EXPECT_EQ(0, stats->cached_resource_fetches()->Get()); |
| EXPECT_EQ(1, stats->succeeded_filter_resource_fetches()->Get()); |
| } |
| |
| // http://code.google.com/p/modpagespeed/issues/detail?id=324 |
| TEST_F(CacheExtenderTest, RetainExtraHeaders) { |
| GoogleString url = StrCat(kTestDomain, "retain.css"); |
| SetResponseWithDefaultHeaders(url, kContentTypeCss, kCssData, 300); |
| // We must explicitly call ComputeSignature here because we are not |
| // calling InitTest in this test. |
| server_context()->ComputeSignature(options()); |
| TestRetainExtraHeaders("retain.css", "ce", "css"); |
| } |
| |
| TEST_F(CacheExtenderTest, TrimUrlInteraction) { |
| options()->EnableFilter(RewriteOptions::kLeftTrimUrls); |
| InitTest(kMediumTtlSec); |
| |
| // Force all URL encoding to use normal encoding so that the relative URL |
| // trimming logic can work and give us a relative URL result as expected. |
| TestUrlNamer::UseNormalEncoding(true); |
| |
| GoogleString a_ext = Encode(kCssSubdir, "ce", "0", kCssTail, "css"); |
| ValidateExpected("ce_then_trim", |
| StringPrintf(kCssFormat, kCssFile), |
| StringPrintf(kCssFormat, a_ext.c_str())); |
| } |
| |
| TEST_F(CacheExtenderTest, DefangHtml) { |
| options()->EnableExtendCacheFilters(); |
| rewrite_driver()->AddFilters(); |
| // Make sure that we downgrade HTML and similar executable types |
| // to text/plain if we cache extend them. This closes off XSS |
| // vectors if the domain lawyer is (mis)configured too loosely. |
| SetResponseWithDefaultHeaders("a.html", kContentTypeHtml, |
| "boo!", kShortTtlSec); |
| SetResponseWithDefaultHeaders("a.xhtml", kContentTypeXhtml, |
| "bwahahaha!", kShortTtlSec); |
| SetResponseWithDefaultHeaders("a.xml", kContentTypeXml, |
| "boo!", kShortTtlSec); |
| |
| const GoogleString css_before = StrCat(CssLinkHref("a.html"), |
| CssLinkHref("a.xhtml"), |
| CssLinkHref("a.xml")); |
| ValidateNoChanges("defang", css_before); |
| } |
| |
| // Negative test to ensure we do not cache-extend CSS that was already |
| // minified (and thus has a long cache lifetime). |
| TEST_F(CacheExtenderTest, DoNotExtendRewrittenCss) { |
| static const char kRewriteDomain[] = "http://rewrite.example.com/"; |
| static const char kShard1Domain[] = "http://shard1.example.com/"; |
| static const char kShard2Domain[] = "http://shard2.example.com/"; |
| DomainLawyer* lawyer = options()->WriteableDomainLawyer(); |
| lawyer->AddRewriteDomainMapping(kRewriteDomain, kTestDomain, |
| message_handler()); |
| lawyer->AddShard(kRewriteDomain, |
| StrCat(kShard1Domain, ",", kShard2Domain), |
| message_handler()); |
| options()->EnableFilter(RewriteOptions::kRewriteCss); |
| InitTest(kShortTtlSec); |
| ValidateExpected( |
| "do_not_extend_rewritten_css", |
| StringPrintf(kCssFormat, kCssFile), |
| StringPrintf(kCssFormat, Encode( |
| StrCat(kShard1Domain, kCssSubdir), RewriteOptions::kCssFilterId, |
| "0", kCssTail, "css").c_str())); |
| |
| // Also we shouldn't have bumped our stat mistakenly just because |
| // the CSS filter optimized the slot. |
| EXPECT_EQ(0, |
| rewrite_driver()->statistics()->GetVariable( |
| CacheExtender::kCacheExtensions)->Get()); |
| } |
| |
| // See: http://www.alistapart.com/articles/alternate/ |
| // and http://www.w3.org/TR/html4/present/styles.html#h-14.3.1 |
| TEST_F(CacheExtenderTest, AlternateStylesheet) { |
| InitTest(kMediumTtlSec); |
| |
| const char html_format[] = "<link rel='%s' href='%s' title='foo'>"; |
| const GoogleString new_url = Encode(kCssSubdir, "ce", "0", kCssTail, "css"); |
| |
| ValidateExpected("preferred_stylesheet", |
| StringPrintf(html_format, "stylesheet", kCssFile), |
| StringPrintf(html_format, "stylesheet", new_url.c_str())); |
| |
| ValidateExpected("alternate_stylesheet", |
| StringPrintf(html_format, "alternate stylesheet", kCssFile), |
| StringPrintf(html_format, "alternate stylesheet", |
| new_url.c_str())); |
| |
| ValidateExpected("alternate_stylesheet2", |
| StringPrintf(html_format, " StyleSheet alterNATE ", |
| kCssFile), |
| StringPrintf(html_format, " StyleSheet alterNATE ", |
| new_url.c_str())); |
| |
| ValidateExpected("alternate_stylesheet_and_more", |
| StringPrintf(html_format, " foo stylesheet alternate bar ", |
| kCssFile), |
| StringPrintf(html_format, " foo stylesheet alternate bar ", |
| new_url.c_str())); |
| ValidateNoChanges("alternate_not_stylesheet", |
| StringPrintf(html_format, "alternate snowflake", kCssFile)); |
| } |
| |
| TEST_F(CacheExtenderTest, PreserveUrlRelativity) { |
| options()->set_preserve_url_relativity(true); |
| InitTest(kMediumTtlSec); |
| |
| ValidateExpected("preserve_url_relativity", |
| "<img src=b.jpg>", |
| "<img src=b.jpg.pagespeed.ce.0.jpg>"); |
| } |
| |
| TEST_F(CacheExtenderTest, NoPreserveUrlRelativity) { |
| options()->set_preserve_url_relativity(false); |
| InitTest(kMediumTtlSec); |
| |
| ValidateExpected("preserve_url_relativity", |
| "<img src=b.jpg>", |
| "<img src=http://test.com/b.jpg.pagespeed.ce.0.jpg>"); |
| } |
| |
| TEST_F(CacheExtenderTest, ContentTypeValidation) { |
| ValidateFallbackHeaderSanitization("ce"); |
| } |
| |
| } // namespace |
| |
| } // namespace net_instaweb |
