static void Regex()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/1234", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/foo/[\\d]+/boom\\?this=that", Method.GET, Response.WithStatusCode(500));
Expect.equal(httpClient.GetAsync("/foo/1234/boom?this=that").Result.StatusCode, HttpStatusCode.InternalServerError, "InternalServerError is returned");
}
}
public void Regex()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/1234", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/foo/[\\d]+/boom?this=that", Method.GET, Response.WithStatusCode(500));
Assert.That(httpClient.GetAsync("/foo/1234/boom?this=that").Result.StatusCode,
Is.EqualTo(HttpStatusCode.InternalServerError));
}
}
static void ReplaceResponse()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithBody(200, "foobar"));
fakeService.AddResponse("/foo", Method.GET, Response.WithBody(200, "foo"));
Expect.equal(httpClient.GetStringAsync("/foo").Result, "foo", "GET returns foo");
Expect.equal(fakeService.Requests.First().Method, Method.GET, "First request is GET");
}
}
static void SamePathWithDifferentMethod()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/", Method.HEAD, Response.WithStatusCode(404));
Expect.equal(httpClient.GetAsync("/").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
var httpRequestMessage = new HttpRequestMessage {
Method = HttpMethod.Head
};
Expect.equal(httpClient.SendAsync(httpRequestMessage).Result.StatusCode, HttpStatusCode.NotFound, "NotFound is returned");
}
}
public void Same_path_different_method()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/", Method.HEAD, Response.WithStatusCode(404));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var httpRequestMessage = new HttpRequestMessage {
Method = HttpMethod.Head
};
Assert.That(httpClient.SendAsync(httpRequestMessage).Result.StatusCode,
Is.EqualTo(HttpStatusCode.NotFound));
}
}
static void StaticFile(string fileName)
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var sourceFile = new FileInfo(fileName);
fakeService.AddResponse($"/Files/{fileName}", Method.GET, Response.WithStaticFile(fileName));
var httpResponseMessage = httpClient.GetAsync($"/Files/{fileName}").Result;
Expect.equal(httpResponseMessage.StatusCode, HttpStatusCode.OK, "OK is returned");
var destinationFileName = Path.GetTempFileName();
using (var fileStream = new FileStream(destinationFileName, FileMode.Create, FileAccess.Write, FileShare.None)
{
Position = 0
})
{
httpResponseMessage.Content.CopyToAsync(fileStream).Wait();
}
var destinationFile = new FileInfo(destinationFileName);
Expect.isTrue(destinationFile.Exists, "File exists");
Expect.equal(sourceFile.Length, destinationFile.Length, "File lengths are the same");
}
}
public void StaticFiles(string fileName)
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var sourceFile = new FileInfo(Path.Combine(AssemblyDirectory, fileName));
fakeService.AddResponse($"/Files/{fileName}", Method.GET, Response.WithStaticFile(sourceFile.FullName));
var httpResponseMessage = httpClient.GetAsync($"/Files/{fileName}").Result;
Assert.That(httpResponseMessage.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var destinationFileName = Path.GetTempFileName();
using (var fileStream = new FileStream(destinationFileName, FileMode.Create, FileAccess.Write, FileShare.None)
{
Position = 0
})
{
httpResponseMessage.Content.CopyToAsync(fileStream).Wait();
}
var destinationFile = new FileInfo(destinationFileName);
Assert.That(destinationFile.Exists);
Assert.That(sourceFile.Length, Is.EqualTo(destinationFile.Length));
}
}
public void Handles_urls_in_path()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/http://ping/pong", Method.GET, Response.WithStatusCode(200));
Assert.That(httpClient.GetAsync("/foo/http://ping/pong").Result.IsSuccessStatusCode, Is.True);
}
}
static void SetPort()
{
using (var fakeService = new FakeService(8080))
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
Expect.equal(httpClient.GetAsync("/foo").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
}
}
public void Handles_urls_in_path()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/http://ping/pong", Method.GET, Response.WithStatusCode(200));
Assert.That(httpClient.GetAsync("/foo/http://ping/pong").Result.IsSuccessStatusCode, Is.True);
}
}
static void Status()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/boom", Method.GET, Response.WithStatusCode(500));
Expect.equal(httpClient.GetAsync("/boom").Result.StatusCode, HttpStatusCode.InternalServerError, "InternalServerError is returned");
Expect.equal(fakeService.Requests.Count, 1, "Service received one request");
}
}
public void Body()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithBody(200, "foo"));
Assert.That(httpClient.GetStringAsync("/foo").Result, Is.EqualTo("foo"));
Assert.That(fakeService.Requests.First().Method, Is.EqualTo(Method.GET));
}
}
static void Delegate()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test\\?foo=bar", Method.GET, Response.WithDelegate(x => x.Query["foo"].Contains("bar") ? Response.WithStatusCode(200) : Response.WithStatusCode(404)));
Expect.equal(httpClient.GetAsync("/test?foo=bar").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
Expect.equal(httpClient.GetAsync("/test?foo=baz").Result.StatusCode, HttpStatusCode.NotFound, "NotFound is returned");
}
}
public void Body()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithBody(200, "foo"));
Assert.That(httpClient.GetStringAsync("/foo").Result, Is.EqualTo("foo"));
Assert.That(fakeService.Requests.First().Method, Is.EqualTo(Method.GET));
}
}
public void Status()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/boom", Method.GET, Response.WithStatusCode(500));
Assert.That(httpClient.GetAsync("/boom").Result.StatusCode,
Is.EqualTo(HttpStatusCode.InternalServerError));
Assert.That(fakeService.Requests.Count, Is.EqualTo(1));
}
}
static void HeadersParamsWithExtraSpaces()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET, Response.WithHeaders(200, "foo : bar", "bing::bong"));
var result = httpClient.GetAsync("/test").Result;
Expect.equal(result.Headers.GetValues("foo").First(), "bar", "Headers contains foo: bar");
Expect.equal(result.Headers.GetValues("bing").First(), ":bong", "Headers contains bing: bong");
}
}
static void ResponsesParams()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET, Response.WithResponses(Response.WithStatusCode(200), Response.WithStatusCode(500)));
Expect.equal(httpClient.GetAsync("/").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
Expect.equal(httpClient.GetAsync("/").Result.StatusCode, HttpStatusCode.InternalServerError, "InternalServerError is returned");
Expect.equal(httpClient.GetAsync("/").Result.StatusCode, HttpStatusCode.NotFound, "NotFound is returned");
}
}
public void Headers()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET,
Response.WithHeaders(200, new Dictionary<string, string> {["foo"] = "bar"}));
var result = httpClient.GetAsync("/test").Result;
Assert.That(result.Headers.First().Key, Is.EqualTo("foo"));
Assert.That(result.Headers.First().Value.First(), Is.EqualTo("bar"));
}
}
static void SetPort()
{
const int port = 8080;
using (var fakeService = new FakeService(port))
using (var httpClient = HttpClient($"http://localhost:{port}"))
{
fakeService.Start();
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
Expect.equal(httpClient.GetAsync("/foo").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
}
}
public void HeadersAndBody2()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/headers", Method.GET, Response.WithBodyAndHeaders(200, "body", "foo : bar"));
var result = httpClient.GetAsync("/headers").Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(result.Content.ReadAsStringAsync().Result, Is.EqualTo("body"));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
static void HeadersStringAndBody()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/headers", Method.GET, Response.WithBodyAndHeaders(200, "body", "foo : bar"));
var result = httpClient.GetAsync("/headers").Result;
Expect.equal(result.StatusCode, HttpStatusCode.OK, "OK is returned");
Expect.equal(result.Content.ReadAsStringAsync().Result, "body", "Body = body");
Expect.equal(result.Headers.GetValues("foo").First(), "bar", "Headers contains foo: bar");
}
}
static void Headers()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET, Response.WithHeaders(200, new Dictionary <string, string> {
["foo"] = "bar"
}));
var result = httpClient.GetAsync("/test").Result;
Expect.equal(result.Headers.GetValues("foo").First(), "bar", "Headers contains foo: bar");
}
}
public void Responses_as_params()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET,
Response.WithResponses(Response.WithStatusCode(200), Response.WithStatusCode(500)));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}
}
public void Delegate()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test?foo=bar", Method.GET,
Response.WithDelegate(
x =>
x.Query["foo"].Contains("bar") ? Response.WithStatusCode(200) : Response.WithStatusCode(404)));
Assert.That(httpClient.GetAsync("/test?foo=bar").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(httpClient.GetAsync("/test?foo=baz").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}
}
public void Header_params()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET, Response.WithHeaders(200, "foo : bar", "bing::bong"));
var result = httpClient.GetAsync("/test").Result;
Assert.That(result.Headers.First().Key, Is.EqualTo("foo"));
Assert.That(result.Headers.First().Value.First(), Is.EqualTo("bar"));
Assert.That(result.Headers.ElementAt(1).Key, Is.EqualTo("bing"));
Assert.That(result.Headers.ElementAt(1).Value.First(), Is.EqualTo(":bong"));
}
}
public void Delegate()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test?foo=bar", Method.GET,
Response.WithDelegate(
x =>
x.Query["foo"].Contains("bar") ? Response.WithStatusCode(200) : Response.WithStatusCode(404)));
Assert.That(httpClient.GetAsync("/test?foo=bar").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(httpClient.GetAsync("/test?foo=baz").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}
}
public void Headers()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET,
Response.WithHeaders(200, new Dictionary <string, string> {
["foo"] = "bar"
}));
var result = httpClient.GetAsync("/test").Result;
Assert.That(result.Headers.First().Key, Is.EqualTo("foo"));
Assert.That(result.Headers.First().Value.First(), Is.EqualTo("bar"));
}
}
public void RawResponse()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/boom", Method.GET, Response.WithRawResponse(Resources.rawResponse));
var result = httpClient.GetAsync("/boom").Result;
var body = result.Content.ReadAsStringAsync().Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var expectedBody = $"Body{Environment.NewLine}Text";
Assert.That(body, Is.EqualTo(expectedBody));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
public void Set_port()
{
const int port = 8889;
using (var fakeService = new FakeService(port))
using (var httpClient = new HttpClient {
BaseAddress = new Uri($"http://localhost:{port}")
})
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
fakeService.Start();
Assert.That(httpClient.GetAsync("/foo").Result.IsSuccessStatusCode, Is.True);
}
}
public void File()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resources\\rawresponse.txt");
fakeService.AddResponse("/", Method.GET, Response.WithFile(path));
var result = httpClient.GetAsync("/").Result;
var body = result.Content.ReadAsStringAsync().Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var expectedBody = $"Body{Environment.NewLine}Text";
Assert.That(body, Is.EqualTo(expectedBody));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
public void File()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resources\\rawresponse.txt");
fakeService.AddResponse("/", Method.GET, Response.WithFile(path));
var result = httpClient.GetAsync("/").Result;
var body = result.Content.ReadAsStringAsync().Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var expectedBody = $"Body{Environment.NewLine}Text";
Assert.That(body, Is.EqualTo(expectedBody));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
static void HeadersDictionaryAndBody()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
const string link = "http://foo/bar";
fakeService.AddResponse("/headers", Method.GET, Response.WithBodyAndHeaders(200, "body", new Dictionary <string, string> {
["Link"] = link
}));
httpClient.DefaultRequestHeaders.Add("Foo", "Bar");
var result = httpClient.GetAsync("/headers").Result;
Expect.equal(result.StatusCode, HttpStatusCode.OK, "OK is returned");
Expect.equal(result.Headers.GetValues("Link").Single(), link, "Headers contains Link: http://foo/bar");
Expect.equal(fakeService.Requests.First().Headers["Foo"].First(), "Bar", "Headers contains Foo: Bar");
Expect.equal(result.Content.ReadAsStringAsync().Result, "body", "Body = body");
}
}
public void HeadersAndBody()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
const string link = "http://foo/bar";
fakeService.AddResponse("/headers", Method.GET,
Response.WithBodyAndHeaders(200, "body", new Dictionary <string, string> {
["Link"] = link
}));
httpClient.DefaultRequestHeaders.Add("Foo", "Bar");
var result = httpClient.GetAsync("/headers").Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.AreEqual(link, result.Headers.GetValues("Link").Single());
var linkHeader = fakeService.Requests.First().Headers.Single(x => x.Key == "Foo").Value;
Assert.That(linkHeader, Is.EqualTo(new[] { "Bar" }));
}
}
public void Request_received_event()
{
var autoResetEvent = new AutoResetEvent(false);
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
fakeService.OnRequestReceived(request =>
{
if (request.Path == "/foo")
{
autoResetEvent.Set();
}
});
httpClient.GetAsync("/foo").Result.EnsureSuccessStatusCode();
Assert.That(autoResetEvent.WaitOne(1000), Is.True);
}
}
static void OnRequestReceived()
{
var autoResetEvent = new AutoResetEvent(false);
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
fakeService.OnRequestReceived(request =>
{
if (request.Path == "/foo")
{
autoResetEvent.Set();
}
});
httpClient.GetAsync("/foo").Result.EnsureSuccessStatusCode();
Expect.equal(autoResetEvent.WaitOne(1000), true, "AutoResetEvent is triggered");
}
}
public void Regex()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/1234", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/foo/[\\d]+/boom?this=that", Method.GET, Response.WithStatusCode(500));
Assert.That(httpClient.GetAsync("/foo/1234/boom?this=that").Result.StatusCode,
Is.EqualTo(HttpStatusCode.InternalServerError));
}
}
public void Same_path_different_method()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/", Method.HEAD, Response.WithStatusCode(404));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var httpRequestMessage = new HttpRequestMessage {Method = HttpMethod.Head};
Assert.That(httpClient.SendAsync(httpRequestMessage).Result.StatusCode,
Is.EqualTo(HttpStatusCode.NotFound));
}
}
public void Set_port()
{
const int port = 8889;
using (var fakeService = new FakeService(port))
using (var httpClient = new HttpClient { BaseAddress = new Uri($"http://localhost:{port}") })
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
fakeService.Start();
Assert.That(httpClient.GetAsync("/foo").Result.IsSuccessStatusCode, Is.True);
}
}
public void HeadersAndBody()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
const string link = "http://foo/bar";
fakeService.AddResponse("/headers", Method.GET,
Response.WithBodyAndHeaders(200, "body", new Dictionary<string, string> {["Link"] = link}));
httpClient.DefaultRequestHeaders.Add("Foo", "Bar");
var result = httpClient.GetAsync("/headers").Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.AreEqual(link, result.Headers.GetValues("Link").Single());
var linkHeader = fakeService.Requests.First().Headers.Single(x => x.Key == "Foo").Value;
Assert.That(linkHeader, Is.EqualTo(new[] {"Bar"}));
}
}
public void HeadersAndBody2()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/headers", Method.GET, Response.WithBodyAndHeaders(200, "body", "foo : bar"));
var result = httpClient.GetAsync("/headers").Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(result.Content.ReadAsStringAsync().Result, Is.EqualTo("body"));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
public void Header_params()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET, Response.WithHeaders(200, "foo : bar", "bing::bong"));
var result = httpClient.GetAsync("/test").Result;
Assert.That(result.Headers.First().Key, Is.EqualTo("foo"));
Assert.That(result.Headers.First().Value.First(), Is.EqualTo("bar"));
Assert.That(result.Headers.ElementAt(1).Key, Is.EqualTo("bing"));
Assert.That(result.Headers.ElementAt(1).Value.First(), Is.EqualTo(":bong"));
}
}
public void RawResponse()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/boom", Method.GET, Response.WithRawResponse(Resources.rawResponse));
var result = httpClient.GetAsync("/boom").Result;
var body = result.Content.ReadAsStringAsync().Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var expectedBody = $"Body{Environment.NewLine}Text";
Assert.That(body, Is.EqualTo(expectedBody));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
public void Request_received_event()
{
var autoResetEvent = new AutoResetEvent(false);
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
fakeService.OnRequestReceived(request =>
{
if (request.Path == "/foo")
{
autoResetEvent.Set();
}
});
httpClient.GetAsync("/foo").Result.EnsureSuccessStatusCode();
Assert.That(autoResetEvent.WaitOne(1000), Is.True);
}
}
public void Responses_as_params()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET,
Response.WithResponses(Response.WithStatusCode(200), Response.WithStatusCode(500)));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}
}
public void Status()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/boom", Method.GET, Response.WithStatusCode(500));
Assert.That(httpClient.GetAsync("/boom").Result.StatusCode,
Is.EqualTo(HttpStatusCode.InternalServerError));
Assert.That(fakeService.Requests.Count, Is.EqualTo(1));
}
}
