private void PrepareMockResponseHandler(MockResponseHandler mockResponseHandler, int number)
{
var uri = _baseUri + number + "/" + _infoJson;
var xkcdResponse = PrepareXkcdResponse(number);
mockResponseHandler.AddMockResponse(xkcdResponse, uri);
}
public async void Method()
{
var httpHandler = new MockHttpHandler();
var responseHandler = new MockResponseHandler<object>();
var endpoint = new HttpApiEndpoint("path/to/api", HttpMethod.Get, new Dictionary<string, IHttpArgumentHandler>(), responseHandler, Enumerable.Empty<HttpHeader>());
await endpoint.Call(httpHandler, "http://localhost", new Dictionary<string, object>());
Assert.AreEqual(HttpMethod.Get, httpHandler.Request.Method);
}
private HttpClient PrepareHttpClient(string jokeUri, string joke)
{
var mockMessageHandler = new MockResponseHandler();
var chuckResponse = new ChuckResponse("success", new ChuckJoke(joke));
mockMessageHandler.AddMockResponse(chuckResponse, jokeUri);
return(new HttpClient(mockMessageHandler));
}
private MockResponseHandler PrepareMockResponseHandlerForLatest(int number)
{
var mockResponseHandler = new MockResponseHandler();
var uri = _baseUri + _infoJson;
var xkcdResponse = PrepareXkcdResponse(number);
mockResponseHandler.AddMockResponse(xkcdResponse, uri);
return(mockResponseHandler);
}
public void ThrottledConcurrentRequestHandler_SendRequestAsync_ThrottlesRequests()
{
var mockHandler = new MockMessageHandler();
DateTime timeToStart = DateTime.Now.AddSeconds(1);
var requestHandler = new MockResponseHandler()
{
CanHandleRequest = (request) => request.Method.Method == "GET" && request.RequestUri.ToString() == "http://testsite.com/test",
HandleRequest = async(request) =>
{
try
{
System.Diagnostics.Debug.WriteLine(System.Threading.Interlocked.Increment(ref concurrentRequests));
var timeToWait = timeToStart.Subtract(DateTime.Now);
if (timeToWait.TotalMilliseconds > 0)
{
await Task.Delay(timeToWait).ConfigureAwait(false);
}
if (concurrentRequests > 4)
{
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError));
}
else
{
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.NoContent));
}
}
finally
{
System.Threading.Interlocked.Decrement(ref concurrentRequests);
}
}
};
mockHandler.AddDynamicResponse(requestHandler);
var handler = new ThrottledConcurrentRequestHandler(mockHandler);
using (var client = new System.Net.Http.HttpClient(handler))
{
var requests = new List <Task <System.Net.Http.HttpResponseMessage> >();
for (int cnt = 0; cnt < 100; cnt++)
{
requests.Add(client.GetAsync("http://testsite.com/test"));
}
Task.WaitAll(requests.ToArray());
Assert.IsFalse((from r in requests where r.Result.StatusCode == System.Net.HttpStatusCode.InternalServerError select r).Any());
}
}
private HttpClient PrepareHttpClient()
{
var baseUri = "https://dog.ceo/api/";
var breedsUri = $"{baseUri}breeds/image/random";
var mockMessageHandler = new MockResponseHandler();
var dogBreedResponse = new DogResponse("success", "https://images.dog.ceo/breeds/random.jpg");
mockMessageHandler.AddMockResponse(dogBreedResponse, breedsUri);
return(new HttpClient(mockMessageHandler));
}
public void GetSearchSuggestions_NoMatch_ReturnsEmptyList()
{
var mockResponseHandler = new MockResponseHandler();
mockResponseHandler.AddFakeResponse(
"http://l.stoffi.io/search/suggestions.json?q=",
"SearchSuggestions_Empty.json");
var httpClient = new HttpClient(mockResponseHandler);
var searchService = new SearchService(httpClient);
var suggestions = searchService.GetSearchSuggestionsAsync("").Result;
Assert.AreEqual(0, suggestions.Count);
}
private HttpClient PrepareHttpClient(List <string> breeds)
{
var baseUri = "https://dog.ceo/api/";
var breedsUri = $"{baseUri}breeds/list/all";
var mockMessageHandler = new MockResponseHandler();
var dogBreedResponse = new DogBreedsResponse("success", breeds.ToDictionary(k => k, k => Enumerable.Empty <string>().ToList()));
mockMessageHandler.AddMockResponse(dogBreedResponse, breedsUri);
return(new HttpClient(mockMessageHandler));
}
public void GetFilteredSongs_NoMatch_ReturnsEmptyObject()
{
var mockResponseHandler = new MockResponseHandler();
mockResponseHandler.AddFakeResponse(
"http://l.stoffi.io/search.json?q=&limit=3&c=songs",
"SearchResult_Empty.json");
var httpClient = new HttpClient(mockResponseHandler);
var searchService = new SearchService(httpClient);
var searchResults = searchService.GetFilteredSongsAsync("", 3).Result;
Assert.AreEqual(0, searchResults.TotalHits);
Assert.AreEqual(0, searchResults.Hits.Count);
}
public async Task SharePointRestRetryTest(HttpStatusCode statusCode)
{
MockResponseHandler responseHandler = new MockResponseHandler();
SharePointRestRetryHandler retryHandler = new SharePointRestRetryHandler(null)
{
InnerHandler = responseHandler,
// Set delay to zero to speed up test case
DelayInSeconds = 0,
// Start with default values for the other settings
MaxRetries = 10,
UseRetryAfterHeader = false,
IncrementalDelay = true
};
using (HttpMessageInvoker invoker = new HttpMessageInvoker(retryHandler))
{
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "https://pnp.com/rocks");
// Check 1: basic retry
var retryResponse = new HttpResponseMessage(statusCode);
var secondResponse = new HttpResponseMessage(HttpStatusCode.OK);
responseHandler.SetHttpResponse(retryResponse, secondResponse);
var response = await invoker.SendAsync(httpRequestMessage, new CancellationToken());
Assert.AreEqual(response, secondResponse);
// Check 2: bump into max retries
retryResponse = new HttpResponseMessage(statusCode);
secondResponse = new HttpResponseMessage(statusCode);
responseHandler.SetHttpResponse(retryResponse, secondResponse);
bool exceptionThrown = false;
try
{
response = await invoker.SendAsync(httpRequestMessage, new CancellationToken());
}
catch (Exception ex)
{
if (ex is ServiceException)
{
exceptionThrown = true;
var serviceException = ex as ServiceException;
Assert.IsTrue((serviceException.Error as ServiceError).HttpResponseCode == (int)statusCode);
}
}
Assert.IsTrue(exceptionThrown);
}
}
private HttpClient PrepareHttpClient(List <string> breeds)
{
var baseUri = "https://api.thecatapi.com/v1/";
var breedsUri = $"{baseUri}breeds";
var mockMessageHandler = new MockResponseHandler();
var catBreedResponse = breeds
.Select(c => new CatBreedsResponse("", c))
.ToList();
mockMessageHandler.AddMockResponse(catBreedResponse, breedsUri);
return(new HttpClient(mockMessageHandler));
}
public async void HeadersProvider()
{
var httpHandler = new MockHttpHandler();
var responseHandler = new MockResponseHandler<object>();
var headersProvider = new MockApiInstrumenter();
headersProvider.Headers.Add(new HttpHeader("key", "value"));
var endpoint = new HttpApiEndpoint("path/to/api", HttpMethod.Get, new Dictionary<string, IHttpArgumentHandler>(), responseHandler, Enumerable.Empty<HttpHeader>());
await endpoint.Call(httpHandler, "http://localhost", new Dictionary<string, object>(), headersProvider.InstrumentCall);
var header = httpHandler.Request.Headers.Single();
Assert.AreEqual("key", header.Name);
Assert.AreEqual("value", header.Values.Single());
}
public void GetFilteredSongs_Match_ReturnsObject()
{
var mockResponseHandler = new MockResponseHandler();
mockResponseHandler.AddFakeResponse(
"http://l.stoffi.io/search.json?q=love&limit=3&c=songs",
"SearchResult_Love.json");
var httpClient = new HttpClient(mockResponseHandler);
var searchService = new SearchService(httpClient);
var searchResults = searchService.GetFilteredSongsAsync("love", 3).Result;
Assert.AreEqual(947, searchResults.TotalHits);
Assert.AreEqual(428, searchResults.Hits[0].Id);
Assert.AreEqual("Love", searchResults.Hits[0].Name);
}
public void GetSearchSuggestions_Match_ReturnsMatches()
{
var mockResponseHandler = new MockResponseHandler();
mockResponseHandler.AddFakeResponse(
"http://l.stoffi.io/search/suggestions.json?q=lo",
"SearchSuggestions_Lo.json");
var httpClient = new HttpClient(mockResponseHandler);
var searchService = new SearchService(httpClient);
var suggestions = searchService.GetSearchSuggestionsAsync("lo").Result;
var suggestionList = new List <SearchSuggestion>(suggestions);
Assert.AreEqual(3, suggestions.Count);
Assert.AreEqual("love", suggestionList[0].Value);
Assert.AreEqual(60.0, suggestionList[0].Score);
}
public async Task ServiceUnavailableRetryHandler_SendRequestAsync_RetriesOnTooManyRequests()
{
var mockHandler = new MockMessageHandler();
DateTime timeToStart = DateTime.Now.AddSeconds(1);
var requestHandler = new MockResponseHandler()
{
CanHandleRequest = (request) => request.Method.Method == "GET" && request.RequestUri.ToString() == "http://testsite.com/test",
HandleRequest = async(request) =>
{
try
{
System.Diagnostics.Debug.WriteLine(System.Threading.Interlocked.Increment(ref requestCount));
var timeToWait = timeToStart.Subtract(DateTime.Now);
if (timeToWait.TotalMilliseconds > 0)
{
await Task.Delay(timeToWait).ConfigureAwait(false);
}
if (requestCount < 4)
{
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.ServiceUnavailable));
}
else
{
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.NoContent));
}
}
finally
{
System.Threading.Interlocked.Increment(ref requestCount);
}
}
};
mockHandler.AddDynamicResponse(requestHandler);
var handler = new ServiceUnavailableRetryHandler(mockHandler, 5, TimeSpan.FromMilliseconds(1000));
using (var client = new System.Net.Http.HttpClient(handler))
{
var response = await client.GetAsync("http://testsite.com/test");
Assert.AreNotEqual(System.Net.HttpStatusCode.ServiceUnavailable, response.StatusCode);
}
}
public async void ArgumentProvider()
{
var httpHandler = new MockHttpHandler();
var responseHandler = new MockResponseHandler<string>(x => x.Headers.Single(y => y.Name == "name").Values.Single());
var endpoint = new HttpApiEndpoint(
"path/to/api",
HttpMethod.Get,
new Dictionary<string, IHttpArgumentHandler>
{
{ "name", new HttpHeaderArgumentHandler(DefaultTypeConverter.Create()) }
},
responseHandler,
Enumerable.Empty<HttpHeader>());
var response = await endpoint.Call(httpHandler, "http://localhost", new Dictionary<string, object> { ["name"] = "value" });
Assert.AreEqual("value", response);
}
private HttpClient PrepareHttpClient(string breedName, string breedId, int responseCount = 1)
{
var baseUri = "https://api.thecatapi.com/v1/";
var breedFinderUri = $"{baseUri}breeds/search?q={HttpUtility.UrlEncode(breedName)}";
var imageFinderUri = $"{baseUri}images/search?size=small&breed_id={breedId}";
var mockMessageHandler = new MockResponseHandler();
var catBreedResponse = Enumerable.Range(0, responseCount)
.Select(c => new CatBreedsResponse(breedId, breedName))
.ToList();
mockMessageHandler.AddMockResponse(catBreedResponse, breedFinderUri);
var catImageResponse = Enumerable.Range(0, responseCount)
.Select(c => new CatResponse(new Uri("https://cdn2.thecatapi.com/images/" + breedId + ".jpg")))
.ToList();
mockMessageHandler.AddMockResponse(catImageResponse, imageFinderUri);
return(new HttpClient(mockMessageHandler));
}
private HttpClient PrepareHttpClient(MockResponseHandler mockResponseHandler)
{
return(new HttpClient(mockResponseHandler));
}
private static MockMessageHandler SetupOAuth2MockHandler()
{
var mockHandler = new MockMessageHandler();
mockHandler.AddFixedResponse(new Uri("http://testsite.com/Token"), new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new System.Net.Http.StringContent(String.Empty, System.Text.UTF8Encoding.UTF8, MediaTypes.ApplicationJson)
});
var mockResponse = new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.Redirect)
{
Content = new System.Net.Http.StringContent("Normally this is a web page the user logs into, but this test is automated and skips that.", System.Text.UTF8Encoding.UTF8, MediaTypes.ApplicationJson)
};
mockResponse.Headers.Location = new Uri("http://testsite.com/AuthComplete?code=28770506516186843330");
mockHandler.AddFixedResponse(new Uri("http://testsite.com/Authorize"), mockResponse);
var tokenIssuingHandler = new MockResponseHandler();
tokenIssuingHandler.CanHandleRequest = (request) => { return(request.Method.Method == "POST" && request.RequestUri.ToString() == "http://testsite.com/Token"); };
tokenIssuingHandler.HandleRequest = async(request) =>
{
var content = request.Content as System.Net.Http.FormUrlEncodedContent;
if (content == null)
{
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.BadRequest));
}
var contentParams = new Dictionary <string, string>();
var contentStr = await content.ReadAsStringAsync().ConfigureAwait(false);
foreach (var kvp in contentStr.Split(new char[] { '&' }, StringSplitOptions.RemoveEmptyEntries))
{
var parts = kvp.Split(new char[] { '=' });
var key = Uri.UnescapeDataString(parts[0]);
string value = null;
if (parts.Length > 1)
{
value = Uri.UnescapeDataString(parts[1]);
}
contentParams.Add(key, value);
}
var grantType = (from c in contentParams where c.Key == "grant_type" select c.Value).FirstOrDefault();
if (grantType == OAuth2.OAuth2GrantTypes.AuthorizationCode)
{
var code = (from c in contentParams where c.Key == "code" select c.Value).FirstOrDefault();
if (code != "28770506516186843330")
{
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.BadRequest));
}
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new System.Net.Http.StringContent("{ token_type: \"Bearer\", access_token: \"123\", expires_in: \"3600\", refresh_token: \"456\" }", System.Text.UTF8Encoding.UTF8, MediaTypes.ApplicationJson)
});
}
else if (grantType == OAuth2GrantTypes.ClientCredentials)
{
if (request.Headers.Authorization.Scheme == "Basic" && request.Headers.Authorization.Parameter == "OTg3NjU0MzIxOmFiY2RlZmdoaWxtbm9wcXJzdHV2emFiYw==")
{
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new System.Net.Http.StringContent("{ token_type: \"Bearer\", access_token: \"123\", expires_in: \"3600\", refresh_token: \"456\" }", System.Text.UTF8Encoding.UTF8, MediaTypes.ApplicationJson)
});
}
}
return(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.BadRequest));
};
mockHandler.AddDynamicResponse(tokenIssuingHandler);
var authCheckingHandler = new MockResponseHandler();
authCheckingHandler.CanHandleRequest = (request) => { return(request.RequestUri.ToString() == "http://testsite.com/TestEndpoint"); };
authCheckingHandler.HandleRequest = (request) =>
{
if (request.Headers.Authorization == null || request.Headers.Authorization.Scheme != "Bearer" || request.Headers.Authorization.Parameter != "123")
{
return(Task.FromResult(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.Unauthorized)));
}
return(Task.FromResult(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new System.Net.Http.StringContent("Yay! You're authed.")
}));
};
mockHandler.AddDynamicResponse(authCheckingHandler);
return(mockHandler);
}
public async Task MicrosoftGraphRetryTest(HttpStatusCode statusCode)
{
MockResponseHandler responseHandler = new MockResponseHandler();
MicrosoftGraphRetryHandler retryHandler = new MicrosoftGraphRetryHandler(null)
{
InnerHandler = responseHandler,
// Set delay to zero to speed up test case
DelayInSeconds = 0,
// Start with testing without retry header
UseRetryAfterHeader = false,
// Start with default values for the other settings
MaxRetries = 10,
IncrementalDelay = true
};
using (HttpMessageInvoker invoker = new HttpMessageInvoker(retryHandler))
{
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "https://pnp.com/rocks");
// Check 1: basic retry
var retryResponse = new HttpResponseMessage(statusCode);
var secondResponse = new HttpResponseMessage(HttpStatusCode.OK);
responseHandler.SetHttpResponse(retryResponse, secondResponse);
var response = await invoker.SendAsync(httpRequestMessage, new CancellationToken());
Assert.AreEqual(response, secondResponse);
// Check 2: bump into max retries
retryResponse = new HttpResponseMessage(statusCode);
secondResponse = new HttpResponseMessage(statusCode);
responseHandler.SetHttpResponse(retryResponse, secondResponse);
bool exceptionThrown = false;
try
{
response = await invoker.SendAsync(httpRequestMessage, new CancellationToken());
}
catch (Exception ex)
{
if (ex is ServiceException)
{
exceptionThrown = true;
var serviceException = ex as ServiceException;
Assert.IsTrue((serviceException.Error as ServiceError).HttpResponseCode == (int)statusCode);
}
}
Assert.IsTrue(exceptionThrown);
// Check 3: retry-header testing
retryHandler.UseRetryAfterHeader = true;
retryResponse = new HttpResponseMessage(statusCode);
retryResponse.Headers.TryAddWithoutValidation(RETRY_AFTER, "0");
secondResponse = new HttpResponseMessage(HttpStatusCode.OK);
responseHandler.SetHttpResponse(retryResponse, secondResponse);
response = await invoker.SendAsync(httpRequestMessage, new CancellationToken());
Assert.AreEqual(response, secondResponse);
response.RequestMessage.Headers.TryGetValues(RETRY_ATTEMPT, out IEnumerable <string> values);
Assert.AreEqual(values.First(), "1");
}
}
