public async Task ClientRequest_WithExpires_AddsToCache()
{
// arrange
var state = new TestState();
var expectedResponse = state.AddHttpRequest(1);
expectedResponse.Content.Headers.Expires = DateTime.UtcNow.AddDays(1);
// act
var response = await state.ExecuteRequest();
// assert
Predicate <Tuple <string, CachingHttpClient.CachedValues> > assert = AssertResult;
state.Dependencies
.Verify(x => x.Cache.Put(Match.Create(assert)), Times.Once);
bool AssertResult(Tuple <string, CachingHttpClient.CachedValues> input)
{
CustomAssert.AssertDateAlmost(
expectedResponse.Content.Headers.Expires.Value.UtcDateTime,
((Headers.CacheSettings.ExpirySettings.Soft)input.Item2.CacheSettings.ExpirySettings).Item.MustRevalidateAtUtc);
return(true);
}
}
public async Task ClientRequest_WithWeakETag_Caches()
{
// arrange
var state = new TestState();
var expectedResponse = state.AddHttpRequest(1);
expectedResponse.Headers.ETag = new EntityTagHeaderValue("\"etg\"", true);
// act
var response = await state.ExecuteRequest();
// assert
Predicate <Tuple <string, CachingHttpClient.CachedValues> > assert = AssertResult;
state.Dependencies
.Verify(x => x.Cache.Put(Match.Create(assert)), Times.Once);
bool AssertResult(Tuple <string, CachingHttpClient.CachedValues> input)
{
// if there is an ETag, expires should be now, and not the past expiry
var settings = ((Soft)input.Item2.CacheSettings.ExpirySettings).Item;
CustomAssert.AssertDateAlmost(DateTime.UtcNow, settings.MustRevalidateAtUtc);
var etag = ((Headers.CacheSettings.Validator.ETag)settings.Validator).Item;
var weak = (Headers.CacheSettings.EntityTag.Weak)etag;
Assert.AreEqual("\"etg\"", weak.Item);
return(true);
}
}
public async Task ClientRequest_WithMaxAge_AddsToCache()
{
// arrange
var state = new TestState();
var expectedResponse = state.AddHttpRequest(1);
expectedResponse.Headers.CacheControl = new CacheControlHeaderValue
{
MaxAge = TimeSpan.FromDays(1)
};
// act
var response = await state.ExecuteRequest();
// assert
Predicate <Tuple <string, CachingHttpClient.CachedValues> > assert = AssertResult;
state.Dependencies
.Verify(x => x.Cache.Put(Match.Create(assert)), Times.Once);
bool AssertResult(Tuple <string, CachingHttpClient.CachedValues> input)
{
Assert.AreEqual("G$:$:http://www.com/", input.Item1);
CustomAssert.AssertCachedResponse(1, input.Item2.HttpResponse);
CustomAssert.AssertDateAlmost(
DateTime.UtcNow.AddDays(1),
((Headers.CacheSettings.ExpirySettings.HardUtc)input.Item2.CacheSettings.ExpirySettings).Item);
return(true);
}
}
public async Task ClientRequest_UsernameHasDollar_EscapesDollarInKey()
{
// arrange
var state = new TestState();
var expectedResponse = state.AddHttpRequest(1);
expectedResponse.Headers.CacheControl = new CacheControlHeaderValue
{
MaxAge = TimeSpan.FromDays(1),
Private = true
};
// act
var response = await state.ExecuteRequest(user : "******");
// assert
Predicate <Tuple <string, CachingHttpClient.CachedValues> > assert = AssertResult;
state.Dependencies
.Verify(x => x.Cache.Put(Match.Create(assert)), Times.Once);
bool AssertResult(Tuple <string, CachingHttpClient.CachedValues> input)
{
Assert.AreEqual("G$:my$$user$:http://www.com/", input.Item1);
return(true);
}
}
public async Task ClientRequest_WithNoHeadersOrCache_ChecksUserAndSharedCache()
{
// arrange
var state = new TestState();
state.AddHttpRequest(1);
// act
var response = await state.ExecuteRequest(user : "******");
// assert
Predicate <string> assertShared = AssertShared;
Predicate <string> assertUser = AssertUser;
state.Dependencies
.Verify(x => x.Cache.Get(It.IsAny <string>()), Times.Exactly(2));
state.Dependencies
.Verify(x => x.Cache.Get(Match.Create(assertShared)), Times.Once);
state.Dependencies
.Verify(x => x.Cache.Get(Match.Create(assertUser)), Times.Once);
bool AssertShared(string input)
{
return("G$:$:http://www.com/" == input);
}
bool AssertUser(string input)
{
return("G$:my user$:http://www.com/" == input);
}
}
public async Task ClientRequest_CachedValueForUserAndShared_ReturnsUserValue()
{
// arrange
var state = new TestState();
var sharedResponse = state.AddToCache(DateTime.UtcNow.AddDays(1), addResponseContent: 1);
var userResponse = state.AddToCache(DateTime.UtcNow.AddDays(1), addResponseContent: 2, user: "******");
var serverResponse = state.AddHttpRequest(3);
// act
var response = await state.ExecuteRequest(user : "******");
// assert
await CustomAssert.AssertResponse(2, response);
}
public async Task ClientRequest_WithExpiresInThePast_StillCaches()
{
// arrange
var state = new TestState();
var expectedResponse = state.AddHttpRequest(1);
expectedResponse.Content.Headers.Expires = DateTime.UtcNow.AddDays(-1);
// act
var response = await state.ExecuteRequest();
// assert
state.Dependencies
.Verify(x => x.Cache.Put(It.IsAny <Tuple <string, CachingHttpClient.CachedValues> >()), Times.Once);
}
public async Task ClientRequest_WithNoHeadersOrCache_AvoidsCache()
{
// arrange
var state = new TestState();
state.AddHttpRequest(1);
// act
var response = await state.ExecuteRequest();
// assert
await CustomAssert.AssertResponse(1, response);
state.Dependencies
.Verify(x => x.Cache.Put(It.IsAny <Tuple <string, CachingHttpClient.CachedValues> >()), Times.Never);
}
public async Task ClientRequest_WithPreviouslyCachedValue_ReturnsCachedValue()
{
// arrange
var state = new TestState();
var cachedResponse = state.AddToCache(DateTime.UtcNow.AddDays(1), addResponseContent: 1);
var serverResponse = state.AddHttpRequest(2);
// act
var response = await state.ExecuteRequest();
// assert
await CustomAssert.AssertResponse(1, response);
state.Dependencies
.Verify(x => x.Send(It.IsAny <Tuple <HttpRequestMessage, CancellationToken> >()), Times.Never);
}
public async Task ClientRequest_WithStrongETag_ServerReturns304_ConstructsResponseCorrectly()
{
// arrange
var state = new TestState();
state.AddToCache(
DateTime.MinValue,
addResponseContent: 4,
customHeaders: new[] { KeyValuePair.Create("x-custom-header", new[] { "cached value" }) },
expiry: NewSoft(new CacheSettings.RevalidationSettings(
DateTime.MinValue,
CacheSettings.Validator.NewETag(CacheSettings.EntityTag.NewStrong("\"etg 1\"")))));
var expectedResponse = state.AddHttpRequest(null, responseCode: 304);
expectedResponse.Headers.Add("x-custom-header", new[] { "server value" });
// act
var response = await state.ExecuteRequest();
// assert
await CustomAssert.AssertResponse(4, response);
state.Dependencies
.Verify(x => x.Cache.Put(It.IsAny <Tuple <string, CachingHttpClient.CachedValues> >()), Times.Never);
Assert.AreEqual("cached value", response.Headers.GetValues("x-custom-header").First());
Predicate <Tuple <HttpRequestMessage, CancellationToken> > assertHttpSend = AssertHttpSend;
state.Dependencies
.Verify(x => x.Send(Match.Create(assertHttpSend)), Times.Once);
bool AssertHttpSend(Tuple <HttpRequestMessage, CancellationToken> input)
{
Assert.AreEqual(@"""etg 1""", input.Item1.Headers.IfNoneMatch.First().Tag);
Assert.False(input.Item1.Headers.IfNoneMatch.First().IsWeak);
return(true);
}
}
public async Task ClientRequest_WithNoHeadersOrCache_ChecksCacheFirst()
{
// arrange
var state = new TestState();
state.AddHttpRequest(1);
// act
var response = await state.ExecuteRequest();
// assert
Predicate <string> assert = AssertResult;
state.Dependencies
.Verify(x => x.Cache.Get(It.IsAny <string>()), Times.Once);
state.Dependencies
.Verify(x => x.Cache.Get(Match.Create(assert)), Times.Once);
bool AssertResult(string input)
{
Assert.AreEqual("G$:$:http://www.com/", input);
return(true);
}
}
