public async Task When_Disposed_Then_the_FakeServer_releases_its_port()
{
Uri baseAddress;
Func <Task <HttpResponseMessage> > makeRequest;
using (var fakeService = new FakeHttpService()
.OnRequest(r => true)
.RespondWith(async r => { await Task.Yield(); }))
{
baseAddress = fakeService.BaseAddress;
makeRequest = async() => await new HttpClient().GetAsync(baseAddress);
var firstResponse = await makeRequest();
firstResponse.EnsureSuccessStatusCode();
}
Action makeAnotherRequest = () =>
{
makeRequest().Wait();
};
makeAnotherRequest.ShouldThrow <HttpRequestException>("Because the port should no longer be available.");
}
static PlaylistServiceFactory()
{
SettingsProvider = new SerialisationSettingsProvider();
EndpointProvider = new EndpointProvider();
HttpService = new FakeHttpService(SettingsProvider);
TokenService = new FakeTokenService(Guid.NewGuid().ToString());
}
public void When_GetServiceMockById_called_with_registered_port_Then_returns_registered_MockService()
{
var mockService = new FakeHttpService();
FakeHttpServiceRepository.GetServiceMockById(mockService.ServiceId)
.Should().Be(mockService, "Because the MockService self-registered.");
FakeHttpServiceRepository.Unregister(mockService);
}
public void When_Unregister_called_with_registered_MockService_Then_removes_MockService()
{
var mockService = new FakeHttpService();
FakeHttpServiceRepository.Unregister(mockService);
FakeHttpServiceRepository.GetServiceMockById(mockService.ServiceId)
.Should().BeNull("Because the mockService was unregistered");
}
public void When_Register_called_with_registered_MockService_Then_throws_with_useful_message()
{
var mockService = new FakeHttpService();
Action register = () => FakeHttpServiceRepository.Register(mockService);
register
.ShouldThrow <InvalidOperationException>("Because that MockService is already registered")
.WithMessage("ServiceId in use", "Because that helps debug the issue");
}
public static FakeHttpService WithContentAt(this FakeHttpService subject, string relativeUri, string content)
{
subject
.OnRequest(r => r.GetUri().ToString().EndsWith(relativeUri))
.RespondWith(async r =>
{
await r.Body.WriteTextAsUtf8BytesAsync(content);
});
return(subject);
}
public async Task When_requesting_a_registered_Uri_Then_the_expected_response_is_returned()
{
using (var fakeService = new FakeHttpService()
.OnRequest(r => true)
.RespondWith(async r => { await Task.Yield(); }))
{
var response = await new HttpClient().GetAsync(fakeService.BaseAddress);
response.EnsureSuccessStatusCode();
}
}
public async void When_specifying_content_for_a_relative_Uri_Then_that_content_is_returned()
{
using (var fakeService = new FakeHttpService()
.WithContentAt("/foo/bar/zap.zip", "quick brown fox"))
{
var response = await new HttpClient().GetAsync(fakeService.BaseAddress + "/foo/bar/zap.zip");
var body = await response.Content.ReadAsStringAsync();
body.Should().Be("quick brown fox");
}
}
public void When_Unregister_called_with_unregistered_MockService_Then_throws_with_useful_message()
{
var mockService = new FakeHttpService();
FakeHttpServiceRepository.Unregister(mockService);
Action unregister = () => FakeHttpServiceRepository.Unregister(mockService);
unregister
.ShouldThrow <InvalidOperationException>("Because that MockService was not registered")
.WithMessage("MockService not registered", "Because that helps debug the issue");
}
private void Test_Get_Current_Project_Without_Persisted_Id()
{
var tracker = GetTracker();
var returnProject = new PivotalProject {
Id = 1, Name = "Project 1", Public = true
};
var response = CreateResponse(returnProject);
FakeHttpService.Setup(x => x.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(response));
var project = tracker.GetCurrentProjectAsync(1);
Assert.NotNull(project);
}
private void Test_Search_By_Query()
{
var tracker = GetTracker();
var returnStories = new PivotalSearchModel {
Query = "label: \"my label\""
};
var response = CreateResponse(returnStories);
FakeHttpService.Setup(x => x.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(response));
var query = "label: \"my label\"";
var searchStories = tracker.SearchByQueryAsync(1, query);
Assert.Equal(query, searchStories.Result.Query);
}
public void Test_PivotalTracker_Authentication_Sets_ApiToken()
{
var tracker = GetTracker();
var returnUser = new PivotalUser
{
Username = "******",
ApiToken = "MyToken"
};
var response = CreateResponse(returnUser);
FakeHttpService.Setup(x => x.AuthorizeAsync(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(response));
var auth = tracker.AuthorizeAsync("test", "test").Result;
Assert.Equal(returnUser.ApiToken, tracker.ApiToken);
}
public async Task When_response_includes_a_body_Then_it_is_returned()
{
using (var fakeService = new FakeHttpService()
.OnRequest(r => true)
.RespondWith(async r =>
{
await r.Body.WriteTextAsUtf8BytesAsync("foo bar zap");
}))
{
var response = await new HttpClient().GetAsync(fakeService.BaseAddress);
var body = await response.Content.ReadAsStringAsync();
body.Should().Be("foo bar zap");
}
}
public void When_request_condition_met_Then_provides_response_with_baseAddress()
{
var path = new Uri("/some/path", UriKind.Relative);
using (var fakeService = new FakeHttpService()
.OnRequest(r => r.Path.ToString() == path.ToString())
.RespondWith(async(r, s) => await r.Body.WriteTextAsUtf8BytesAsync(s.AbsolutePath)))
{
var client = new HttpClient {
BaseAddress = fakeService.BaseAddress
};
client.GetStringAsync(path).Result
.Should().Be(fakeService.BaseAddress.AbsolutePath);
}
}
public void When_request_not_expected_Then_responds_404()
{
HttpResponseMessage response;
using (var fakeService = new FakeHttpService())
{
var client = new HttpClient {
BaseAddress = fakeService.BaseAddress
};
response = client.GetAsync("").Result;
}
response.StatusCode.
Should().Be(System.Net.HttpStatusCode.NotFound, "Because the request was not expected");
}
public async Task When_filtering_Uri_Then_the_expected_response_is_returned()
{
using (var fakeService = new FakeHttpService()
.OnRequest()
.WhereUri(uri => uri.ToString().EndsWith("customapicall"))
.Then()
.RespondWith(async r =>
{
r.StatusCode = 200;
await Task.Yield();
}))
{
var response = await new HttpClient().GetAsync(new Uri(fakeService.BaseAddress, "/customapicall"));
response.EnsureSuccessStatusCode();
}
}
public async Task When_filtering_body_as_json_Then_the_expected_response_is_returned()
{
using (var fakeService = new FakeHttpService()
.OnRequest()
.WhereBodyAsJson(body => JToken.DeepEquals(body, JToken.Parse("{ field: 1}")))
.Then()
.Succeed()
.FailOnUnexpectedRequest())
{
var response = await new HttpClient().PostAsync(new Uri(fakeService.BaseAddress, "/customapicall"), new StringContent("{ field: 1}"));
response.EnsureSuccessStatusCode();
response = await new HttpClient().PostAsync(new Uri(fakeService.BaseAddress, "/customapicall"), new StringContent("{}"));
response.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
}
}
public void Test_PivotalTracker_Authentication_With_Credentials_Returns_User()
{
var tracker = GetTracker();
var returnUser = new PivotalUser
{
Username = "******",
ApiToken = "MyToken"
};
var response = CreateResponse(returnUser);
FakeHttpService.Setup(x => x.AuthorizeAsync(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(response));
tracker.AuthorizeAsync("testUser", "testPassword");
FakeHttpService.Setup(x => x.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(response));
var user = tracker.GetUserAsync().Result;
Assert.Equal(user.ApiToken, returnUser.ApiToken);
}
public async Task When_filtering_body_as_POCO_Then_the_expected_response_is_returned()
{
using (var fakeService = new FakeHttpService()
.OnRequest()
.WhereBodyAs <SamplePOCO>(obj => obj.Value == "defined")
.Then()
.Succeed()
.FailOnUnexpectedRequest())
{
var response = await new HttpClient().PostAsync(new Uri(fakeService.BaseAddress, "/customapicall"), new StringContent(JsonConvert.SerializeObject(new SamplePOCO("defined"))));
response.EnsureSuccessStatusCode();
response = await new HttpClient().PostAsync(new Uri(fakeService.BaseAddress, "/customapicall"), new StringContent(JsonConvert.SerializeObject(new SamplePOCO("undefined"))));
response.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
}
}
public async Task When_response_includes_headers_Then_they_are_returned()
{
using (var fakeService = new FakeHttpService()
.OnRequest(r => true)
.RespondWith(async r =>
{
r.Headers.Append("foo", "bar");
r.Headers.Append("colors", new StringValues(new[] { "red", "green", "blue" }));
await Task.Yield();
}))
{
var response = await new HttpClient().GetAsync(fakeService.BaseAddress);
response.Headers.GetValues("foo").Should().BeEquivalentTo("bar");
response.Headers.GetValues("colors").Should().BeEquivalentTo("red", "green", "blue");
}
}
public async Task When_filtering_body_Then_the_expected_response_is_returned()
{
using (var fakeService = new FakeHttpService()
.OnRequest()
.WhereBodyAsString(body => body == "nothing")
.Then()
.Succeed()
.FailOnUnexpectedRequest())
{
var response = await new HttpClient().PostAsync(new Uri(fakeService.BaseAddress, "/customapicall"), new StringContent("nothing"));
response.EnsureSuccessStatusCode();
response = await new HttpClient().PostAsync(new Uri(fakeService.BaseAddress, "/customapicall"), new StringContent("different"));
response.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
}
}
public void Test_Get_User_Returns_User()
{
var tracker = GetTracker();
var returnUser = new PivotalUser
{
Email = "*****@*****.**",
Id = 27,
Initials = "TU",
Name = "Test User",
Username = "******"
};
var response = CreateResponse(returnUser);
FakeHttpService.Setup(x => x.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(response));
var user = tracker.GetUserAsync().Result;
Assert.Equal(returnUser.Id, user.Id);
}
public async Task Request_information_is_sent_to_PocketLogger()
{
var log = new List <string>();
using (var fakeService = new FakeHttpService()
.OnRequest(r => true)
.RespondWith(async r =>
{
r.Headers.Add("a-response-header", "a-response-header-value");
await r.WriteAsync(JsonConvert.SerializeObject(new { ResponseProperty = "response-property-value" }));
}))
using (LogEvents.Subscribe(e => log.Add(e.ToLogString())))
{
await new HttpClient().PostAsync(
new Uri(fakeService.BaseAddress, "/and/the/path?and=query"),
new StringContent(JsonConvert.SerializeObject(new { RequestProperty = "request-property-value" }), Encoding.UTF8, "application/json"));
}
log.Should()
.HaveCount(2);
log[0]
.NormalizeLineEndings()
.Should()
.Match(@"*[FakeHttpService.RequestLoggingMiddleware] [Invoke] ▶
POST http://127.0.0.1:*/and/the/path?and=query
Connection: Keep-Alive
Content-Type: application/json; charset=utf-8
Host: 127.0.0.1:*
Content-Length: *
{""RequestProperty"":""request-property-value""}*".NormalizeLineEndings());
log[1]
.NormalizeLineEndings()
.Should()
.Match(@"*[FakeHttpService.RequestLoggingMiddleware] [Invoke] ⏹ -> ✔ (*ms)
HTTP/ 200
a-response-header: a-response-header-value
{""ResponseProperty"":""response-property-value""}*".NormalizeLineEndings());
}
public void Test_Get_Projects_Returns_Projects()
{
var tracker = GetTracker();
var returnProjects = new List <PivotalProject>
{
new PivotalProject {
Id = 1, Name = "Project 1", Public = true
},
new PivotalProject {
Id = 2, Name = "Project 2", Public = false
},
new PivotalProject {
Id = 3, Name = "Project 3", Public = false
}
};
var response = CreateResponse(returnProjects);
FakeHttpService.Setup(x => x.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(response));
var projects = tracker.GetProjectsAsync().Result;
Assert.Equal(3, projects.Count);
}
private void Test_Get_Project_Stories()
{
var tracker = GetTracker();
var returnStories = new List <PivotalStory>
{
new PivotalStory {
Id = 1, Name = "Story 1"
},
new PivotalStory {
Id = 2, Name = "Story 2"
},
new PivotalStory {
Id = 3, Name = "Story 3"
},
};
var response = CreateResponse(returnStories);
FakeHttpService.Setup(x => x.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(response));
var stories = tracker.GetProjectStoriesAsync(1);
Assert.NotNull(stories);
}
public void When_request_condition_met_Then_provides_response()
{
const string responseBody = "a quick brown fox";
var path = new Uri("/some/path", UriKind.Relative);
using (var fakeService = new FakeHttpService()
.OnRequest(r => r.Path.ToString() == path.ToString())
.RespondWith(async r =>
{
r.StatusCode = 200;
r.ContentType = "text/plain";
await r.Body.WriteTextAsUtf8BytesAsync(responseBody);
}))
{
var client = new HttpClient {
BaseAddress = fakeService.BaseAddress
};
client.GetStringAsync(path).Result
.Should().Be(responseBody);
}
}
public async Task When_an_expected_request_is_not_made_but_FakeServer_is_configured_to_throw_Then_an_exception_is_thrown()
{
Uri address = null;
Action createServiceWithoutInvoking = () =>
{
using (var fakeService = new FakeHttpService(
"my service",
throwOnUnusedHandlers: true)
.OnRequest(r => r.Path == "foo")
.RespondWith(async r => { await Task.Yield(); }))
{
address = fakeService.BaseAddress;
}
};
createServiceWithoutInvoking
.ShouldThrow <InvalidOperationException>(
"Because failing to perform a request can be an error")
.Which
.Message
.Should()
.StartWith($"{nameof(FakeHttpService)} \"my service\" @ {address} expected requests");
}
public void When_request_processing_throws_an_exception_Then_responds_500_with_exception_body()
{
const string exceptionMessage = "exception!";
HttpResponseMessage response;
using (var fakeService = new FakeHttpService()
.OnRequest(r => true)
.RespondWith(r => throw new Exception(exceptionMessage)))
{
var client = new HttpClient {
BaseAddress = fakeService.BaseAddress
};
response = client.GetAsync("").Result;
}
response.StatusCode
.Should().Be(System.Net.HttpStatusCode.InternalServerError,
"Because request processing threw an exception");
response.Content.ReadAsStringAsync().Result
.Should().Contain(exceptionMessage);
}
public RequestFilterExpressionBuilder(FakeHttpService fakeHttpService)
{
_fakeHttpService = fakeHttpService;
}
public static RequestFilterExpressionBuilder OnRequest(this FakeHttpService service)
{
return(new RequestFilterExpressionBuilder(service));
}
