public async Task Simple_private_caching()
{
// Cache-Control: max-age=5
var client = CreateCachingEnabledClient();
var response = await client.GetAsync("/CacheableResource"); // Server round trip
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("This is cached content", await response.Content.ReadAsStringAsync());
HttpAssert.FromServer(response);
Thread.Sleep(1000); // Pause to see non-zero age
var response2 = await client.GetAsync("/CacheableResource"); // No round trip
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
Assert.Equal("This is cached content", await response2.Content.ReadAsStringAsync());
HttpAssert.FromCache(response2);
var response2a = await client.GetAsync("/CacheableResource"); // No round trip
Assert.Equal(HttpStatusCode.OK, response2a.StatusCode);
Assert.Equal("This is cached content", await response2a.Content.ReadAsStringAsync());
HttpAssert.FromCache(response2);
Thread.Sleep(7000); // Pause for resource to expire
var response3 = await client.GetAsync("/CacheableResource"); // Server round trip
Assert.Equal(HttpStatusCode.OK, response3.StatusCode);
Assert.Equal("This is cached content", await response3.Content.ReadAsStringAsync());
HttpAssert.FromServer(response3);
}
public async Task Simple_private_caching_using_query_parameter()
{
var client = CreateCachingEnabledClient();
var response = await client.GetAsync("/CacheableResource?value=10"); // Server roundtrip
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
HttpAssert.FromServer(response);
var response2 = await client.GetAsync("/CacheableResource?value=20"); // Server roundtrip
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
HttpAssert.FromServer(response2);
var response3 = await client.GetAsync("/CacheableResource?value=10"); // From cache
Assert.Equal(HttpStatusCode.OK, response3.StatusCode);
HttpAssert.FromCache(response3);
Thread.Sleep(7000); // Pause for resource to expire
var response4 = await client.GetAsync("/CacheableResource?value=10"); // Server roundtrip
Assert.Equal(HttpStatusCode.OK, response4.StatusCode);
HttpAssert.FromServer(response4);
}
public async Task Simple_private_caching_with_etag()
{
var client = CreateCachingEnabledClient();
var response = await client.GetAsync("/ResourceWithEtag"); // Server roundtrip
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
HttpAssert.FromServer(response);
var response2 = await client.GetAsync("/ResourceWithEtag"); // From cache
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
HttpAssert.FromCache(response2);
Thread.Sleep(7000); // Pause for resource to expire
var response3 = await client.GetAsync("/ResourceWithEtag"); // Server roundtrip and 304
Assert.Equal(HttpStatusCode.OK, response3.StatusCode);
HttpAssert.FromCache(response3);
var response4 = await client.GetAsync("/ResourceWithEtag"); // Server roundtrip and 304 / but should be cached
Assert.Equal(HttpStatusCode.OK, response4.StatusCode);
HttpAssert.FromCache(response4);
}
public async Task Private_caching_a_redirect()
{
// Cache-Control: max-age=5
var client = CreateCachingEnabledClient();
var response = await client.GetAsync("/PointA"); // Server round trip
Assert.Equal(HttpStatusCode.Found, response.StatusCode);
HttpAssert.FromServer(response);
var response2 = await client.GetAsync("/PointA"); // No round trip
Assert.Equal(HttpStatusCode.Found, response2.StatusCode);
HttpAssert.FromCache(response2);
Thread.Sleep(7000); // Pause for resource to expire
var response3 = await client.GetAsync("/PointA"); // Server round trip
Assert.Equal(HttpStatusCode.Found, response3.StatusCode);
HttpAssert.FromServer(response3);
}
public async Task Private_caching_with_accept_language_vary_header()
{
var client = CreateCachingEnabledClient();
var linkEnglish = new Link()
{
Target = new Uri("/VaryingCacheableResource", UriKind.Relative)
};
linkEnglish.RequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("en"));
var linkFrench = new Link()
{
Target = new Uri("/VaryingCacheableResource", UriKind.Relative)
};
linkFrench.RequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("fr"));
var response = await client.SendAsync(linkEnglish.CreateRequest());
Assert.Equal("This is cached content", await response.Content.ReadAsStringAsync());
HttpAssert.FromServer(response);
var responseExplicitEn = await client.SendAsync(linkEnglish.CreateRequest());
var content = await responseExplicitEn.Content.ReadAsStringAsync();
Assert.Equal("This is cached content", content);
HttpAssert.FromCache(responseExplicitEn);
var responseExplicitEn2 = await client.SendAsync(linkEnglish.CreateRequest());
var content2 = await responseExplicitEn2.Content.ReadAsStringAsync();
Assert.Equal("This is cached content", content2);
HttpAssert.FromCache(responseExplicitEn2);
var responseExplicitFr = await client.SendAsync(linkFrench.CreateRequest());
Assert.Equal("Ce donnée est caché", await responseExplicitFr.Content.ReadAsStringAsync());
HttpAssert.FromServer(responseExplicitFr);
var responseExplicitFr2 = await client.SendAsync(linkFrench.CreateRequest());
Assert.Equal("Ce donnée est caché", await responseExplicitFr2.Content.ReadAsStringAsync());
HttpAssert.FromCache(responseExplicitFr2);
var responseExplicitEn3 = await client.SendAsync(linkEnglish.CreateRequest());
Assert.Equal("This is cached content", await responseExplicitEn3.Content.ReadAsStringAsync());
HttpAssert.FromCache(responseExplicitEn3);
}
public async Task Private_caching_with_encoding_vary_header()
{
var client = CreateCachingEnabledClient();
var linkCompressed = new Link()
{
Target = new Uri("/VaryingCompressedContent", UriKind.Relative)
};
linkCompressed.RequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
var linkUnCompressed = new Link()
{
Target = new Uri("/VaryingCompressedContent", UriKind.Relative)
};
linkUnCompressed.RequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("identity"));
var response = await client.SendAsync(linkCompressed.CreateRequest());
var content = await response.Content.ReadAsStringAsync();
HttpAssert.FromServer(response);
var response2 = await client.SendAsync(linkCompressed.CreateRequest());
var content2 = await response2.Content.ReadAsStringAsync();
HttpAssert.FromCache(response2);
var response3 = await client.SendAsync(linkUnCompressed.CreateRequest());
var content3 = await response3.Content.ReadAsStringAsync();
HttpAssert.FromServer(response3);
var response4 = await client.SendAsync(linkUnCompressed.CreateRequest());
var content4 = await response4.Content.ReadAsStringAsync();
HttpAssert.FromCache(response4);
var response5 = await client.SendAsync(linkCompressed.CreateRequest());
var content5 = await response5.Content.ReadAsStringAsync();
HttpAssert.FromCache(response5);
}
public async Task Indicate_that_stale_requests_are_ok_with_messagehandler()
{
var client = CreateClientWithMessageHandlerCache();
var response = await client.GetAsync("/CacheableResource"); // Round trip to server
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
HttpAssert.FromServer(response);
Thread.Sleep(6000); // Stored representation is now stale by 1 second
var request = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative)
};
request.Headers.CacheControl = new CacheControlHeaderValue()
{
MaxStale = true,
MaxStaleLimit = new TimeSpan(0, 0, 3)
};
var response2 = await client.SendAsync(request); // From Cache
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
HttpAssert.FromCache(response2);
Thread.Sleep(3000); // Stored representation is now stale by 4 second
var request2 = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative)
};
request2.Headers.CacheControl = new CacheControlHeaderValue()
{
MaxStale = true,
MaxStaleLimit = new TimeSpan(0, 0, 3)
};
var response3 = await client.SendAsync(request2);
Assert.Equal(HttpStatusCode.OK, response3.StatusCode);
HttpAssert.FromServer(response3);
}
public async Task Require_minimum_freshness_with_messagehandler()
{
var client = CreateClientWithMessageHandlerCache();
var response = await client.GetAsync("/CacheableResource"); // Round trip to server
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
HttpAssert.FromServer(response);
Thread.Sleep(3000);
var request2 = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative)
};
request2.Headers.CacheControl = new CacheControlHeaderValue()
{
MinFresh = new TimeSpan(0, 0, 2)
};
var response2 = await client.SendAsync(request2);
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
HttpAssert.FromServer(response2);
Thread.Sleep(3000);
var request3 = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative)
};
request3.Headers.CacheControl = new CacheControlHeaderValue()
{
MinFresh = new TimeSpan(0, 0, 4)
};
var response3 = await client.SendAsync(request3);
Assert.Equal(HttpStatusCode.OK, response3.StatusCode);
HttpAssert.FromCache(response3);
}
public async Task Simple_private_caching_by_method()
{
var client = CreateCachingEnabledClient();
var headRequest = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative),
Method = HttpMethod.Head
};
var response = await client.SendAsync(headRequest); // Server round trip
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
HttpAssert.FromServer(response);
var response2 = await client.GetAsync("/CacheableResource"); // Server round trip
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
HttpAssert.FromServer(response2);
var headRequest2 = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative),
Method = HttpMethod.Head
};
var response3 = await client.SendAsync(headRequest2); // Local round trip
Assert.Equal(HttpStatusCode.OK, response3.StatusCode);
HttpAssert.FromCache(response3);
var response4 = await client.GetAsync("/CacheableResource"); // Local round trip
Assert.Equal(HttpStatusCode.OK, response4.StatusCode);
HttpAssert.FromCache(response4);
// Cached HEAD response != cached GET response
var content3 = await response3.Content.ReadAsStringAsync();
var content4 = await response4.Content.ReadAsStringAsync();
Assert.NotEqual(content3, content4);
}
public async Task Request_only_cached_content_with_messagehandler()
{
var client = CreateClientWithMessageHandlerCache();
var response = await client.GetAsync("/CacheableResource"); // Round trip to server
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
HttpAssert.FromServer(response);
Thread.Sleep(1000);
var request2 = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative)
};
request2.Headers.CacheControl = new CacheControlHeaderValue()
{
OnlyIfCached = true
};
var response2 = await client.SendAsync(request2);
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
HttpAssert.FromCache(response2);
Thread.Sleep(5000);
var request3 = new HttpRequestMessage()
{
RequestUri = new Uri("/CacheableResource", UriKind.Relative)
};
request3.Headers.CacheControl = new CacheControlHeaderValue()
{
OnlyIfCached = true
};
var response3 = await client.SendAsync(request3);
Assert.Equal(HttpStatusCode.GatewayTimeout, response3.StatusCode);
}
public async Task Private_caching_a_POST_response()
{
// Cache-Control: max-age=5
var client = CreateCachingEnabledClient();
var response = await client.PostAsync("/CacheablePostResponse", new StringContent("Here is a message")); // Server round trip
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
HttpAssert.FromServer(response);
var response2 = await client.GetAsync("/CacheablePostResponse"); // No round trip
Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
HttpAssert.FromCache(response2);
Thread.Sleep(7000); // Pause for resource to expire
var response3 = await client.GetAsync("/CacheablePostResponse"); // Server round trip
Assert.Equal(HttpStatusCode.OK, response3.StatusCode);
HttpAssert.FromServer(response3);
}
