public void Connect()
{
var client = new CachedHttpClient(this.server.HttpClient);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public void CachedConnectMultipleUris()
{
CachedHttpClient.Cache.Remove(IndexPath);
var mockCache = new Mock <ObjectCache>();
//cache.Set(new CacheItem(requestUri, result.Content.ToString()), new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.Add(result.Headers.CacheControl.MaxAge.Value) });
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(false);
mockCache.Setup(mc => mc.Contains("/HelloWorld", null)).Returns(false);
mockCache.Setup(m => m.Set(It.IsAny <CacheItem>(), It.Is <CacheItemPolicy>(cip => cip.AbsoluteExpiration <DateTimeOffset.UtcNow.AddMilliseconds(1001) && cip.AbsoluteExpiration> DateTimeOffset.UtcNow.AddMilliseconds(900)))).Verifiable("Didn't add to cache");
It.Is <CacheItemPolicy>(cip => cip.AbsoluteExpiration <DateTimeOffset.UtcNow.AddMilliseconds(1001) && cip.AbsoluteExpiration> DateTimeOffset.UtcNow.AddMilliseconds(900));
var client = new CachedHttpClient(this.server.HttpClient);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not yet be cached.");
var result2 = client.GetAsync(new Uri("/HelloWorld", UriKind.Relative)).Result;
result2.StatusCode.Should().Be(HttpStatusCode.OK, "Should be ok");
result2.WasCached.Should().BeFalse("should not be cached");
CachedHttpClient.Cache.GetCount().Should().Be(2);
CachedHttpClient.Cache[IndexPath].Should().NotBeNull("Should contain entry");
CachedHttpClient.Cache["/HelloWorld"].Should().NotBeNull("Should contain entry");
}
public void DoNotCacheMaxAgeOfZero()
{
using (var testServer = SingleApiServer(0))
{
var mockCache = new Mock <ObjectCache>(MockBehavior.Strict);
mockCache.Setup(m => m.Contains(IndexPath, null)).Returns(false);
var client = new CachedHttpClient(testServer.HttpClient, mockCache.Object);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not be cached if time = 0.");
}
}
public async Task CachedHttpClientAttemptsCacheHit()
{
var mockedCache = new Mock <IRequestCache>();
PostcodeDetail mockOutput;
mockedCache.Setup(c => c.TryGetResponse(It.IsAny <string>(), out mockOutput))
.Returns(false);
var client = new CachedHttpClient(mockedCache.Object);
await client.GetAsync <PostcodeDetail>("http://uk-postcodes.com/postcode/SW1A0AA.json");
mockedCache.Verify(c => c.TryGetResponse(It.IsAny <string>(), out mockOutput), Times.AtLeastOnce);
}
public void CachedConnect()
{
CachedHttpClient.Cache.Remove(IndexPath);
var client = new CachedHttpClient(this.server.HttpClient);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not yet be cached.");
CachedHttpClient.Cache.GetCount().Should().Be(1);
CachedHttpClient.Cache[IndexPath].Should().NotBeNull("Should contain entry");
var result2 = client.GetAsync(IndexUri).Result;
result2.StatusCode.Should().Be(HttpStatusCode.OK, "Should be ok");
result2.WasCached.Should().BeTrue("should be cached");
}
public void CachedConnect()
{
CachedHttpClient.Cache.Remove(IndexPath);
var client = new CachedHttpClient(this.server.HttpClient);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not yet be cached.");
CachedHttpClient.Cache.GetCount().Should().Be(1);
CachedHttpClient.Cache[IndexPath].Should().NotBeNull("Should contain entry");
var result2 = client.GetAsync(IndexUri).Result;
result2.StatusCode.Should().Be(HttpStatusCode.OK, "Should be ok");
result2.WasCached.Should().BeTrue("should be cached");
}
public void PutClearsCache()
{
var mockCache = new Mock <ObjectCache>(MockBehavior.Strict);
//cache.Set(new CacheItem(requestUri, result.Content.ToString()), new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.Add(result.Headers.CacheControl.MaxAge.Value) });
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(false);
mockCache.Setup(m => m.Set(It.IsAny <CacheItem>(), It.Is <CacheItemPolicy>(cip => cip.AbsoluteExpiration <DateTimeOffset.UtcNow.AddMilliseconds(1001) && cip.AbsoluteExpiration> DateTimeOffset.UtcNow.AddMilliseconds(900)))).Verifiable("Didn't add to cache");
mockCache.Setup(m => m.Remove(IndexPath, null)).Returns(null).Verifiable("didn't delete from cache");
using (var testServer = SingleApiServer(1))
{
var client = new CachedHttpClient(testServer.HttpClient, mockCache.Object);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not yet be cached.");
var result2 = client.PutAsync(IndexUri, new StringContent("HI")).Result;
mockCache.Verify();
}
}
public async Task <IHentaiInfoModel> GetInfoAsync(string url)
{
var html = await CachedHttpClient.Method(t => t.GetStringAsync(url))
.ExpireAfter(TimeSpan.FromDays(1))
.GetValueAsync();
var model = new EHentaiInfoModel
{
Title = TitleRegex.Match(html).Value,
Id = UrlRegex.Match(url).Groups["id"].Value,
Cover = await GetCoverAsync(html)
};
foreach (var pair in await ExtractTagsAsync(html))
{
model.Tags.Add(pair);
}
return(model);
}
public async Task <IHentaiInfoModel> GetInfoAsync(string url)
{
var html = await CachedHttpClient.Method(t => t.GetStringAsync(url))
.ExpireAfter(TimeSpan.FromDays(1))
.GetValueAsync();
var htmlParser = BrowsingContext.New();
var document = await htmlParser.OpenAsync(req => req.Content(html));
var model = new NHentaiInfoModel
{
Title = string.Join("", document.QuerySelector("h2.title").Children.Select(t => t.Text())),
Id = UrlRegex.Match(url).Groups["id"].Value,
Cover = await GetCoverAsync(html)
};
foreach (var pair in await ExtractTagsAsync(html))
{
model.Tags.Add(pair);
}
return(model);
}
public void CachedConnectRespectsCacheControl()
{
using (var testServer = SingleApiServer(1))
{
var mockCache = new Mock <ObjectCache>(MockBehavior.Strict);
//cache.Set(new CacheItem(requestUri, result.Content.ToString()), new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.Add(result.Headers.CacheControl.MaxAge.Value) });
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(false);
mockCache.Setup(m => m.Set(It.IsAny <CacheItem>(), It.Is <CacheItemPolicy>(cip => cip.AbsoluteExpiration <DateTimeOffset.UtcNow.AddMilliseconds(1001) && cip.AbsoluteExpiration> DateTimeOffset.UtcNow.AddMilliseconds(900)))).Verifiable("Didn't add to cache");
var client = new CachedHttpClient(testServer.HttpClient, mockCache.Object);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK, "Should have succeeded on first request");
result.WasCached.Should().BeFalse("should not yet be cached.");
mockCache.Verify();
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(true);
mockCache.Setup(mc => mc[IndexPath]).Returns(null);
client.GetAsync(IndexUri).Wait();
result.StatusCode.Should().Be(HttpStatusCode.OK, "Should have succeeded on second request");
result.WasCached.Should().BeFalse("should not yet be cached.");
}
}
public async Task <(bool, string)> GetTranslationAsync(string row, string tag = null)
{
string url, target;
if (tag == null)
{
url = $"{DatabaseUrl}rows.md";
target = row;
}
else
{
url = $"{DatabaseUrl}{row}.md";
target = tag;
}
string markdown;
try
{
markdown = await CachedHttpClient.Method(t => t.GetStringAsync(url))
.ExpireAfter(TimeSpan.FromDays(1))
.GetValueAsync();
}
catch (Exception e)
{
_logger.LogError(e, "Get translation failed");
return(false, target.Replace("_", " "));
}
var regex = new Regex($@"\| {target.Replace("_", " ")} \| (?<translation>.+?) \|");
var match = regex.Match(markdown);
return(match.Success, match.Success
? MarkdownPicReplaceRegex.Replace(match.Groups["translation"].Value, "").Replace(@"\|", "|")
: target.Replace("_", " "));
}
public void CachedConnectMultipleUris()
{
CachedHttpClient.Cache.Remove(IndexPath);
var mockCache = new Mock<ObjectCache>();
//cache.Set(new CacheItem(requestUri, result.Content.ToString()), new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.Add(result.Headers.CacheControl.MaxAge.Value) });
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(false);
mockCache.Setup(mc => mc.Contains("/HelloWorld", null)).Returns(false);
mockCache.Setup(m => m.Set(It.IsAny<CacheItem>(), It.Is<CacheItemPolicy>(cip => cip.AbsoluteExpiration < DateTimeOffset.UtcNow.AddMilliseconds(1001) && cip.AbsoluteExpiration > DateTimeOffset.UtcNow.AddMilliseconds(900)))).Verifiable("Didn't add to cache");
It.Is<CacheItemPolicy>(cip => cip.AbsoluteExpiration < DateTimeOffset.UtcNow.AddMilliseconds(1001) && cip.AbsoluteExpiration > DateTimeOffset.UtcNow.AddMilliseconds(900));
var client = new CachedHttpClient(this.server.HttpClient);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not yet be cached.");
var result2 = client.GetAsync(new Uri("/HelloWorld", UriKind.Relative)).Result;
result2.StatusCode.Should().Be(HttpStatusCode.OK, "Should be ok");
result2.WasCached.Should().BeFalse("should not be cached");
CachedHttpClient.Cache.GetCount().Should().Be(2);
CachedHttpClient.Cache[IndexPath].Should().NotBeNull("Should contain entry");
CachedHttpClient.Cache["/HelloWorld"].Should().NotBeNull("Should contain entry");
}
public void CachedConnectRespectsCacheControl()
{
using (var testServer = SingleApiServer(1))
{
var mockCache = new Mock<ObjectCache>(MockBehavior.Strict);
//cache.Set(new CacheItem(requestUri, result.Content.ToString()), new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.Add(result.Headers.CacheControl.MaxAge.Value) });
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(false);
mockCache.Setup(m => m.Set(It.IsAny<CacheItem>(), It.Is<CacheItemPolicy>(cip => cip.AbsoluteExpiration < DateTimeOffset.UtcNow.AddMilliseconds(1001)&& cip.AbsoluteExpiration > DateTimeOffset.UtcNow.AddMilliseconds(900)))).Verifiable("Didn't add to cache");
var client = new CachedHttpClient(testServer.HttpClient, mockCache.Object);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK, "Should have succeeded on first request");
result.WasCached.Should().BeFalse("should not yet be cached.");
mockCache.Verify();
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(true);
mockCache.Setup(mc => mc[IndexPath]).Returns(null);
client.GetAsync(IndexUri).Wait();
result.StatusCode.Should().Be(HttpStatusCode.OK, "Should have succeeded on second request");
result.WasCached.Should().BeFalse("should not yet be cached.");
}
}
public Postcodes(IRequestCache cache)
{
_client = new CachedHttpClient(cache);
}
public void PutClearsCache()
{
var mockCache = new Mock<ObjectCache>(MockBehavior.Strict);
//cache.Set(new CacheItem(requestUri, result.Content.ToString()), new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.Add(result.Headers.CacheControl.MaxAge.Value) });
mockCache.Setup(mc => mc.Contains(IndexPath, null)).Returns(false);
mockCache.Setup(m => m.Set(It.IsAny<CacheItem>(), It.Is<CacheItemPolicy>(cip => cip.AbsoluteExpiration < DateTimeOffset.UtcNow.AddMilliseconds(1001) && cip.AbsoluteExpiration > DateTimeOffset.UtcNow.AddMilliseconds(900)))).Verifiable("Didn't add to cache");
mockCache.Setup(m => m.Remove(IndexPath, null)).Returns(null).Verifiable("didn't delete from cache");
using (var testServer = SingleApiServer(1))
{
var client = new CachedHttpClient(testServer.HttpClient, mockCache.Object);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not yet be cached.");
var result2 = client.PutAsync(IndexUri, new StringContent("HI")).Result;
mockCache.Verify();
}
}
public void DoNotCacheMaxAgeOfZero()
{
using (var testServer = SingleApiServer(0))
{
var mockCache = new Mock<ObjectCache>(MockBehavior.Strict);
mockCache.Setup(m => m.Contains(IndexPath, null)).Returns(false);
var client = new CachedHttpClient(testServer.HttpClient, mockCache.Object);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
result.WasCached.Should().BeFalse("should not be cached if time = 0.");
}
}
public void Connect()
{
var client = new CachedHttpClient(this.server.HttpClient);
var result = client.GetAsync(IndexUri).Result;
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
