public async Task When_calling_a_fake_handler()
{
using (var handler = new FakeResponseHandler())
{
handler.AddFakeResponse(
new Uri("http://example.org/test"), new HttpResponseMessage(HttpStatusCode.OK));
using (IRestClient client = new RestClient(handler: handler))
{
var response1 = await client.GetAsync("http://example.org/notthere");
var response2 = await client.GetAsync("http://example.org/test");
response1.StatusCode.ShouldBe(HttpStatusCode.NotFound);
response2.StatusCode.ShouldBe(HttpStatusCode.OK);
}
}
}
public async Task When_sending_an_explicit_get_with_uri_and_completion_option()
{
using var handler = new FakeResponseHandler();
using var expectedResponse = StringResponseMessage;
var endpoint = new Uri("http://example.org/api/15");
handler.AddFakeResponse(endpoint, expectedResponse);
using IRestClient client = new RestClient(handler: handler);
var response = await client.GetAsync(endpoint, HttpCompletionOption.ResponseContentRead);
response.EnsureSuccessStatusCode();
response.StatusCode.ShouldBe(HttpStatusCode.OK);
var respStr = await response.Content.ReadAsStringAsync();
respStr.ShouldBe(ExpectedMessage);
}
public async Task When_sending_a_get_string_with_timeout()
{
var timeout = 3.Seconds();
using (var handler = new FakeResponseHandler())
using (var expectedResponse = StringResponseMessage)
{
var endpoint = new Uri("http://example.org/api/34");
handler.AddFakeResponse(endpoint, expectedResponse);
using (IRestClient client = new RestClient(handler: handler))
{
(await client.GetStringAsync(endpoint, timeout)).ShouldBe(ExpectedMessage);
(await client.GetStringAsync(endpoint.OriginalString, timeout)).ShouldBe(ExpectedMessage);
}
}
}
public async Task When_sending_an_explicit_post_with_uri()
{
using var handler = new FakeResponseHandler();
using var expectedResponse = StringResponseMessage;
var endpoint = new Uri("http://example.org/api/7");
handler.AddFakeResponse(endpoint, expectedResponse);
using IRestClient client = new RestClient(handler: handler);
var response = await client.PostAsync(endpoint, new MultipartFormDataContent());
response.EnsureSuccessStatusCode();
response.StatusCode.ShouldBe(HttpStatusCode.OK);
var respStr = await response.Content.ReadAsStringAsync();
respStr.ShouldBe(ExpectedMessage);
}
public async Task When_sending_an_explicit_delete_with_string()
{
using var handler = new FakeResponseHandler();
using var expectedResponse = StringResponseMessage;
var endpoint = new Uri("http://example.org/api/21");
handler.AddFakeResponse(endpoint, expectedResponse);
using IRestClient client = new RestClient(handler: handler);
var response = await client.DeleteAsync(endpoint.OriginalString);
response.EnsureSuccessStatusCode();
response.StatusCode.ShouldBe(HttpStatusCode.OK);
var respStr = await response.Content.ReadAsStringAsync();
respStr.ShouldBe(ExpectedMessage);
}
public void When_creating_a_client_with_custom_constructor()
{
var defaultHeaders = new Dictionary <string, string>
{
{ HttpRequestHeader.Accept.ToString(), "application/json" },
{ HttpRequestHeader.UserAgent.ToString(), "foo-bar" }
};
using (IRestClient client = new RestClient(defaultHeaders, timeout: 15.Seconds(), maxResponseContentBufferSize: 10))
{
client.DefaultRequestHeaders.Count.ShouldBe(defaultHeaders.Count);
client.DefaultRequestHeaders["Accept"].ShouldBe("application/json");
client.DefaultRequestHeaders["UserAgent"].ShouldBe("foo-bar");
client.Endpoints.ShouldBeEmpty();
client.MaxResponseContentBufferSize.ShouldBe((uint)10);
client.Timeout.ShouldBe(15.Seconds());
}
}
public async Task When_sending_a_request_with_cancellation()
{
var endpoint = new Uri("http://localhost:25/api/");
using (IRestClient client = new RestClient())
using (var server = new SimpleHttpListener(endpoint))
{
await server.ListenAsync();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = endpoint
};
request.Headers.Add("Foo", "Bar");
var cts = new CancellationTokenSource(1.Seconds());
Should.Throw <TaskCanceledException>(async() => await client.SendAsync(request, cts.Token));
}
}
public async Task When_sending_a_delete_request()
{
var endpoint = new Uri("http://localhost:19/api/");
using (IRestClient client = new RestClient())
using (var server = new SimpleHttpListener(endpoint))
{
server.OnRequest += (sender, context) =>
{
if (context.Request.HttpMethod != HttpMethod.Delete.ToString())
{
context.Response.StatusCode = (int)HttpStatusCode.NotAcceptable;
context.Response.Close();
}
else
{
var reply = Encoding.UTF8.GetBytes("Hello There!");
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.OutputStream.Write(reply, 0, reply.Length);
context.Response.Close();
}
};
await server.ListenAsync();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = endpoint
};
request.Headers.Add("Foo", "Bar");
var response = await client.SendAsync(request, HttpCompletionOption.ResponseContentRead);
response.EnsureSuccessStatusCode();
var respStr = await response.Content.ReadAsStringAsync();
respStr.ShouldBe("Hello There!");
}
}
public async Task When_sending_a_get_stream_with_timeout_string()
{
var timeout = 3.Seconds();
using (var handler = new FakeResponseHandler())
using (var expectedResponse = StringResponseMessage)
{
var endpoint = new Uri("http://example.org/api/35");
handler.AddFakeResponse(endpoint, expectedResponse);
using (IRestClient client = new RestClient(handler: handler))
{
var resp = await client.GetStreamAsync(endpoint.OriginalString, timeout);
using (var streamReader = new StreamReader(resp, Encoding.UTF8))
{
(await streamReader.ReadToEndAsync()).ShouldBe(ExpectedMessage);
}
}
}
}
public async Task When_sending_a_post_with_timeout()
{
var timeout = 3.Seconds();
using var handler = new FakeResponseHandler();
using var expectedResponse = StringResponseMessage;
var endpoint = new Uri("http://example.org/api/41");
handler.AddFakeResponse(endpoint, expectedResponse);
using IRestClient client = new RestClient(handler: handler);
var resp1 = await client.PostAsync(endpoint, new MultipartFormDataContent(), timeout);
resp1.EnsureSuccessStatusCode();
(await resp1.Content.ReadAsStringAsync()).ShouldBe(ExpectedMessage);
var resp2 = await client.PostAsync(endpoint.OriginalString, new MultipartFormDataContent(), timeout);
resp2.EnsureSuccessStatusCode();
(await resp2.Content.ReadAsStringAsync()).ShouldBe(ExpectedMessage);
}
public async Task When_sending_a_get_stream_with_uri()
{
using (var handler = new FakeResponseHandler())
using (var expectedResponse = StreamResponseMessage)
{
var endpoint = new Uri("http://example.org/api/29");
handler.AddFakeResponse(endpoint, expectedResponse);
using (IRestClient client = new RestClient(handler: handler))
{
var response = await client.GetStreamAsync(endpoint);
using (var streamReader = new StreamReader(response, Encoding.UTF8))
{
var responseString = await streamReader.ReadToEndAsync();
responseString.ShouldBe(ExpectedMessage);
}
}
}
}
public void When_sending_a_request()
{
var endpoint = new Uri("http://localhost/api");
ServicePointManager.FindServicePoint(endpoint).ConnectionLeaseTimeout.ShouldBe(-1);
using (IRestClient client = new RestClient())
{
client.SendAsync(new HttpRequestMessage(HttpMethod.Get, endpoint));
ServicePointManager.FindServicePoint(endpoint)
.ConnectionLeaseTimeout
.ShouldBe((int)1.Minutes().TotalMilliseconds);
client.Endpoints.Length.ShouldBe(1);
client.Endpoints[0].ShouldBe(endpoint);
client.ClearEndpoints();
client.Endpoints.ShouldBeEmpty();
}
}
public void When_sending_a_request_with_string_uri()
{
const string Endpoint = "http://localhost:33/api";
var endpointUri = new Uri(Endpoint);
ServicePointManager.FindServicePoint(endpointUri).ConnectionLeaseTimeout.ShouldBe(-1);
using (IRestClient client = new RestClient())
{
client.SendAsync(new HttpRequestMessage(HttpMethod.Get, Endpoint));
ServicePointManager.FindServicePoint(endpointUri)
.ConnectionLeaseTimeout
.ShouldBe((int)1.Minutes().TotalMilliseconds);
client.Endpoints.Length.ShouldBe(1);
client.Endpoints[0].OriginalString.ShouldBe(Endpoint);
client.ClearEndpoints();
client.Endpoints.ShouldBeEmpty();
}
}
public async Task When_sending_a_delete_request()
{
using var handler = new FakeResponseHandler();
using var expectedResponse = StringResponseMessage;
var endpoint = new Uri("http://example.org/api/19");
handler.AddFakeResponse(endpoint, expectedResponse);
using IRestClient client = new RestClient(handler: handler);
var request = new HttpRequestMessage {
Method = HttpMethod.Delete, RequestUri = endpoint
};
var response = await client.SendAsync(request, HttpCompletionOption.ResponseContentRead);
response.EnsureSuccessStatusCode();
response.StatusCode.ShouldBe(HttpStatusCode.OK);
var respStr = await response.Content.ReadAsStringAsync();
respStr.ShouldBe(ExpectedMessage);
}
public async Task When_sending_a_request_with_base_address_and_route()
{
var endpoint1 = new Uri("http://foo.bar/api/1");
var resp1 = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("A")
};
var endpoint2 = new Uri("http://foo.bar/api/2");
var resp2 = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("B")
};
var endpoint3 = new Uri("http://foo.bar/api/3");
var resp3 = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("C")
};
using var handler = new FakeResponseHandler();
using (resp1)
using (resp2)
using (resp3)
{
handler.AddFakeResponse(endpoint1, resp1);
handler.AddFakeResponse(endpoint2, resp2);
handler.AddFakeResponse(endpoint3, resp3);
var baseAddress = new Uri("http://foo.bar");
using IRestClient client = new RestClient(handler: handler, baseAddress: baseAddress);
client.BaseAddress.ShouldBe(baseAddress);
(await client.GetStringAsync("api/1")).ShouldBe("A");
(await client.GetStringAsync("api/2")).ShouldBe("B");
(await client.GetStringAsync("api/3")).ShouldBe("C");
}
}
public async Task When_sending_a_request_then_cancelling_all_pending_requests()
{
var endpoint = new Uri("http://localhost:26/api/");
using (IRestClient client = new RestClient())
using (var server = new SimpleHttpListener(endpoint))
{
await server.ListenAsync();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = endpoint
};
request.Headers.Add("Foo", "Bar");
var copy = client;
#pragma warning disable 4014
Task.Delay(1.Seconds()).ContinueWith(_ => copy.CancelPendingRequests());
#pragma warning restore 4014
Should.Throw <TaskCanceledException>(async() => await client.SendAsync(request));
}
}
public async Task When_sending_a_delete_with_timeout()
{
var timeout = 3.Seconds();
using (var handler = new FakeResponseHandler())
using (var expectedResponse = StringResponseMessage)
{
var endpoint = new Uri("http://example.org/api/39");
handler.AddFakeResponse(endpoint, expectedResponse);
using (IRestClient client = new RestClient(handler: handler))
{
var resp1 = await client.DeleteAsync(endpoint, timeout);
resp1.EnsureSuccessStatusCode();
(await resp1.Content.ReadAsStringAsync()).ShouldBe(ExpectedMessage);
var resp2 = await client.DeleteAsync(endpoint.OriginalString, timeout);
resp2.EnsureSuccessStatusCode();
(await resp2.Content.ReadAsStringAsync()).ShouldBe(ExpectedMessage);
}
}
}
public async Task When_sending_a_post_request_via_explicit_post_with_string()
{
const string Endpoint = "http://localhost:8/api/";
using (IRestClient client = new RestClient())
using (var server = new SimpleHttpListener(new Uri(Endpoint)))
{
server.OnRequest += (sender, context) =>
{
if (context.Request.HttpMethod != HttpMethod.Post.ToString())
{
context.Response.StatusCode = (int)HttpStatusCode.NotAcceptable;
context.Response.Close();
}
else
{
var reply = Encoding.UTF8.GetBytes("Hello There!");
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.OutputStream.Write(reply, 0, reply.Length);
context.Response.Close();
}
};
await server.ListenAsync();
var content = new MultipartFormDataContent();
var response = await client.PostAsync(Endpoint, content);
response.EnsureSuccessStatusCode();
var respStr = await response.Content.ReadAsStringAsync();
respStr.ShouldBe("Hello There!");
}
}
