public void RemoteServerShouldWorkCorrectlyWithSpecificBaseAddress()
{
Assert.False(RemoteServer.GlobalIsConfigured);
MyHttpServer
.WorkingRemotely("http://google.com")
.WithHttpRequestMessage(req => req.WithRequestUri("/users/ivaylokenov/repos"))
.ShouldReturnHttpResponseMessage()
.WithResponseTime(time => time.TotalMilliseconds > 0)
.WithStatusCode(HttpStatusCode.NotFound)
.ContainingContentHeader(HttpContentHeader.ContentType, "text/html; charset=UTF-8");
Assert.False(RemoteServer.GlobalIsConfigured);
MyHttpServer
.WorkingRemotely("https://api.github.com")
.WithHttpRequestMessage(req => req
.WithRequestUri("/users/ivaylokenov/repos")
.WithHeader(HttpHeader.UserAgent, "MyTested.WebApi"))
.ShouldReturnHttpResponseMessage()
.WithResponseTime(time => time.TotalMilliseconds > 0)
.WithStatusCode(HttpStatusCode.OK)
.ContainingContentHeader(HttpContentHeader.ContentType, "application/json; charset=utf-8");
Assert.False(RemoteServer.GlobalIsConfigured);
}
public void RemoteServerShouldWorkCorrectlyWithGlobalConfiguration()
{
MyHttpServer.IsLocatedAt("http://google.com", clientHandler =>
{
clientHandler.AllowAutoRedirect = true;
});
MyHttpServer
.WorkingRemotely()
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithResponseTime(time => time.TotalMilliseconds > 0)
.WithStatusCode(HttpStatusCode.OK)
.ContainingContentHeader(HttpContentHeader.ContentType);
MyHttpServer
.WorkingRemotely()
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Delete))
.ShouldReturnHttpResponseMessage()
.WithResponseTime(time => time.TotalMilliseconds > 0)
.WithStatusCode(HttpStatusCode.MethodNotAllowed);
MyHttpServer
.WorkingRemotely()
.WithHttpRequestMessage(req => req.WithRequestUri("/notfound"))
.ShouldReturnHttpResponseMessage()
.WithResponseTime(time => time.TotalMilliseconds > 0)
.WithStatusCode(HttpStatusCode.NotFound);
RemoteServer.DisposeGlobal();
}
public void WithStringContentShouldNotThrowExceptionWithCorrectContent()
{
MyHttpServer
.WorkingRemotely(BaseLocalAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithContent("Not found!");
}
public void ContainingHeaderShouldNotThrowExceptionWithCorrectHeaderNameAndValues()
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.ContainingHeader("Server", new[] { "Microsoft-IIS/8.0" });
}
public void WithSuccessStatusCodeShouldNotThrowExceptionWithValidStatusCode()
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithSuccessStatusCode();
}
public void WithReasonPhraseShouldNotThrowExceptionWithValidPhrase()
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithReasonPhrase("OK");
}
public void WithVersionShouldNotThrowExceptionWithValidVersion()
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithVersion(new Version(1, 1));
}
public void ContainingContentHeaderShouldNotThrowExceptionWithCorrectHeaderNameAndValues()
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.ContainingContentHeader("Content-Type", new[] { "text/html; charset=utf-8" });
}
public void ContainingContentHeaderShouldNotThrowExceptionWithCorrectHeaderName()
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.ContainingContentHeader("Content-Type");
}
public void WithStringContentAssertionsShouldWorkCorrectlyWithCorrectPredicate()
{
MyHttpServer
.WorkingRemotely(BaseLocalAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithContent(content => content == "Not found!");
}
public void WithMethodShouldPopulateCorrectMethod()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithMethod(HttpMethod.Get))
.AndProvideTheHttpRequestMessage();
Assert.Equal(HttpMethod.Get, httpRequestMessage.Method);
}
public void WithRequestUriShouldPopulateCorrectUri()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithRequestUri(new Uri(RequestUri)))
.AndProvideTheHttpRequestMessage();
Assert.Equal(new Uri(RequestUri), httpRequestMessage.RequestUri);
}
public void WithVersionShouldPopulateCorrectVersion()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithVersion(new Version(1, 1)))
.AndProvideTheHttpRequestMessage();
Assert.Equal(Version, httpRequestMessage.Version.ToString());
}
public void AndAlsoShouldWorkCorrectly()
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithSuccessStatusCode()
.AndAlso()
.WithReasonPhrase("OK");
}
public void WithByteArrayContentAndBufferSizeShouldPopulateCorrectContent()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithByteArrayContent(this.buffer, 2, 4))
.AndProvideTheHttpRequestMessage();
Assert.IsAssignableFrom <ByteArrayContent>(httpRequestMessage.Content);
Assert.Equal(4, httpRequestMessage.Content.ReadAsByteArrayAsync().Result.Length);
}
public void WithStreamContentShouldPopulateCorrectContent()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithStreamContent(new MemoryStream(this.buffer)))
.AndProvideTheHttpRequestMessage();
Assert.IsAssignableFrom <StreamContent>(httpRequestMessage.Content);
Assert.Equal(this.buffer.Length, httpRequestMessage.Content.ReadAsByteArrayAsync().Result.Length);
}
public void WithHeaderShouldPopulateCorrectHeader()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithHeader(TestHeader, TestHeaderValue))
.AndProvideTheHttpRequestMessage();
Assert.True(httpRequestMessage.Headers.Contains(TestHeader));
Assert.True(httpRequestMessage.Headers.First(h => h.Key == TestHeader).Value.Contains(TestHeaderValue));
}
public void WithContentShouldPopulateCorrectContent()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithContent(new StringContent(StringContent)))
.AndProvideTheHttpRequestMessage();
Assert.IsAssignableFrom <StringContent>(httpRequestMessage.Content);
Assert.Equal(StringContent, httpRequestMessage.Content.ReadAsStringAsync().Result);
}
public void WithJsonContentShouldPopulateCorrectContent()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithJsonContent(@"{""Age"":5}"))
.AndProvideTheHttpRequestMessage();
Assert.Equal(@"{""Age"":5}", httpRequestMessage.Content.ReadAsStringAsync().Result);
Assert.Equal(MediaType.ApplicationJson, httpRequestMessage.Content.Headers.ContentType.MediaType);
}
public void WithStringContentEncodingAndMediaTypeShouldPopulateCorrectContent()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithStringContent(StringContent, Encoding.UTF8, MediaType.ApplicationJson))
.AndProvideTheHttpRequestMessage();
Assert.IsAssignableFrom <StringContent>(httpRequestMessage.Content);
Assert.Equal(StringContent, httpRequestMessage.Content.ReadAsStringAsync().Result);
}
public void WithFormUrlEncodedContentShouldPopulateCorrectContentWithDirectString()
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithFormUrlEncodedContent("First=FirstValue&Second=SecondValue"))
.AndProvideTheHttpRequestMessage();
Assert.Equal("First=FirstValue&Second=SecondValue", httpRequestMessage.Content.ReadAsStringAsync().Result);
Assert.Equal(MediaType.FormUrlEncoded, httpRequestMessage.Content.Headers.ContentType.MediaType);
}
public void WithResponseTimePredicateShouldWorkCorrectly()
{
var request = new HttpRequestMessage(HttpMethod.Post, "/test");
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithResponseTime(
responseTime => responseTime.TotalMilliseconds > 0 && responseTime.TotalMilliseconds < int.MaxValue);
}
public void WithHeaderCookiesShouldSetCorrectCookieValue()
{
MyHttpServer
.WorkingRemotely(BaseLocalAddress)
.WithHttpRequestMessage(req => req
.WithMethod(HttpMethod.Get)
.WithRequestUri("/cookies")
.WithHeader(HttpHeader.Cookie, "cookiename=cookievalue;anothercookie=anothervalue"))
.ShouldReturnHttpResponseMessage()
.WithContent("cookiename+cookievalue!anothercookie+anothervalue");
}
public void WithInvalidVersionShouldThrowInvalidHttpRequestMessageException()
{
var exception = Assert.Throws <InvalidHttpRequestMessageException>(() =>
{
var httpRequestMessage = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(request => request.WithVersion("Invalid"))
.AndProvideTheHttpRequestMessage();
});
Assert.Equal("When building HttpRequestMessage expected version to be valid version string, but instead received invalid one.", exception.Message);
}
public void AndAlsoShouldWorkCorrectlyWithResponseTime()
{
var request = new HttpRequestMessage(HttpMethod.Post, "/test");
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithResponseTime(responseTime => responseTime.TotalMilliseconds > 0)
.AndAlso()
.WithStatusCode(HttpStatusCode.OK);
}
public void AndProvideTheResponseTimeShouldWorkCorrectly()
{
var request = new HttpRequestMessage(HttpMethod.Post, "/test");
var responseTime = MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.AndProvideTheResponseTime();
Assert.True(responseTime.TotalMilliseconds > 0);
}
public void WithStringContentAssertionsShouldThrowExceptionWithIncorrectPredicate()
{
var exception = Assert.Throws <HttpResponseMessageAssertionException>(() =>
{
MyHttpServer
.WorkingRemotely(BaseLocalAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithContent(content => content == "Not");
});
Assert.Equal("When testing 'http://localhost:9876/' expected HTTP response message result content to pass the given condition, but it failed.", exception.Message);
}
public void ContainingHeaderShouldThrowExceptionWithCorrectHeaderNameAndIncorrectValues()
{
var exception = Assert.Throws <HttpResponseMessageAssertionException>(() =>
{
MyHttpServer
.WorkingRemotely(BaseAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.ContainingHeader("Server", new[] { "AnotherHeaderValue" });
});
Assert.Equal("When testing 'https://mytestedasp.net/' expected HTTP response message result headers to have Server with AnotherHeaderValue value, but none was found.", exception.Message);
}
public void WithSuccessStatusCodeShouldThrowExceptionWithInvalidStatusCode()
{
var exception = Assert.Throws <HttpResponseMessageAssertionException>(() =>
{
MyHttpServer
.WorkingRemotely(BaseLocalAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithSuccessStatusCode();
});
Assert.Equal("When testing 'http://localhost:9876/' expected HTTP response message result status code to be between 200 and 299, but it was not.", exception.Message);
}
public void WithStringContentShouldThrowExceptionWithIncorrectContent()
{
var exception = Assert.Throws <HttpResponseMessageAssertionException>(() =>
{
MyHttpServer
.WorkingRemotely(BaseLocalAddress)
.WithHttpRequestMessage(req => req.WithMethod(HttpMethod.Get))
.ShouldReturnHttpResponseMessage()
.WithContent("Another string");
});
Assert.Equal("When testing 'http://localhost:9876/' expected HTTP response message result string content to be 'Another string', but was in fact 'Not found!'.", exception.Message);
}