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)); } }
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"); } }
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 NotFound() { using (var fakeService = new FakeService()) using (var httpClient = HttpClient(fakeService.Start())) { Expect.equal(httpClient.GetAsync("/boom").Result.StatusCode, HttpStatusCode.NotFound, "NotFound is returned"); Expect.equal(fakeService.Requests.First().Path, "/boom", "Path is recorded"); } }
public void NotFound() { using (var fakeService = new FakeService()) using (var httpClient = HttpClient(fakeService.Start())) { Assert.That(httpClient.GetAsync("/boom").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound)); Assert.That(fakeService.Requests.First().Path, Is.EqualTo("/boom")); } }
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"); } }
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"); } }
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"); } }
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"); } }
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 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)); } }
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 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 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 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 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 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 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"); } }
static void File() { using (var fakeService = new FakeService()) using (var httpClient = HttpClient(fakeService.Start())) { fakeService.AddResponsesFromFile("Responses.txt"); Expect.equal(httpClient.GetAsync("/statuscode").Result.StatusCode, HttpStatusCode.OK, "Statuscode returns OK"); Expect.equal(httpClient.GetAsync("/headers").Result.Headers.GetValues("foo").First(), "bar", "Headers has foo: bar header"); Expect.equal(httpClient.GetAsync("/headers").Result.Headers.GetValues("bing").First(), "bong", "Headers has bing: bong header"); Expect.equal(httpClient.GetAsync("/body").Result.Content.ReadAsStringAsync().Result, "bodytext", "Body text returned"); Expect.equal(httpClient.GetAsync("/bodyandheaders").Result.Content.ReadAsStringAsync().Result, "body", "BodyAndHeaders has body"); Expect.equal(httpClient.GetAsync("/bodyandheaders").Result.Headers.GetValues("foo").First(), "bar", "BodyAndHeaders has foo: bar header"); } }
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 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); } }
public void Responses_from_file() { using (var fakeService = new FakeService()) using (var httpClient = HttpClient(fakeService.Start())) { var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resources\\responses.txt"); fakeService.AddResponsesFromFile(path); Assert.That(httpClient.GetAsync("/statuscode").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK)); Assert.That(httpClient.GetAsync("/headers").Result.Headers.First(x => x.Key == "foo").Value.First(), Is.EqualTo("bar")); Assert.That(httpClient.GetAsync("/headers").Result.Headers.First(x => x.Key == "bing").Value.First(), Is.EqualTo("bong")); Assert.That(httpClient.GetAsync("/body").Result.Content.ReadAsStringAsync().Result, Is.EqualTo("bodytext")); Assert.That(httpClient.GetAsync("/bodyandheaders").Result.Content.ReadAsStringAsync().Result, Is.EqualTo("body")); Assert.That(httpClient.GetAsync("/bodyandheaders").Result.Headers.First(x => x.Key == "foo").Value.First(), Is.EqualTo("bar")); } }