public static Entity GeneratEntity()
{
return(new Entity()
{
Id = HttpMonitorId.Create()
});
}
public async Task DoNotReadEntireResponseBody()
{
// Arrange
var command = new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, _httpServer.BaseAddress));
_httpServer.Handler = async ctx =>
{
ctx.Response.StatusCode = (int)HttpStatusCode.Accepted;
// write infinitely to the response stream
while (true)
{
await ctx.Response.WriteAsync(Guid.NewGuid().ToString());
}
// ReSharper disable once FunctionNeverReturns
};
// Act
var @event = await _executor.CheckHttpEndpointAsync(command);
// Assert
Assert.Null(@event.ErrorMessage);
Assert.Equal(HttpStatusCode.Accepted, @event.Response.StatusCode);
}
public async Task RequestHttpMethodAndPathCalled(string httpMethod)
{
// Arrange
var command = new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(new HttpMethod(httpMethod),
new Uri(_httpServer.BaseAddress,
$"/api/{DateTime.UtcNow.Ticks}/index.html?q={DateTime.UtcNow.Ticks}")));
string actualHttpMethod = null;
string actualRelativePath = null;
string actualQueryString = null;
_httpServer.Handler = ctx =>
{
// capture request data
actualHttpMethod = ctx.Request.Method;
actualRelativePath = ctx.Request.Path.Value;
actualQueryString = ctx.Request.QueryString.Value;
return(Task.CompletedTask);
};
// Act
await _executor.CheckHttpEndpointAsync(command);
// Assert
Assert.Equal(command.Request.Method.Method, actualHttpMethod, StringComparer.InvariantCultureIgnoreCase);
Assert.Equal(command.Request.Url.AbsolutePath, actualRelativePath);
Assert.Equal(command.Request.Url.Query, actualQueryString);
}
public void CreateReturnsUniqueInstances()
{
// Act
var id1 = HttpMonitorId.Create();
var id2 = HttpMonitorId.Create();
// Assert
Assert.NotEqual(id1.Value, id2.Value);
}
public async Task DeleteDoesNotThrowExceptionWhenNotFound()
{
// Arrange
var id = HttpMonitorId.Create();
// Act
// Assert no exception thrown
await _repository.DeleteAsync(id);
}
private HttpMonitorCheck GenerateHttpMonitorCheck(HttpMonitorCheckId id)
{
return(new HttpMonitorCheck(
id,
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Delete, new Uri("http://yahoo.com")),
new HttpRequestTiming(DateTime.UtcNow, DateTime.UtcNow.AddSeconds(1)),
new HttpResponse(HttpStatusCode.Accepted)));
}
private IEnumerable <CheckHttpEndpoint> GenerateCheckHttpEndpoint(int count)
{
for (var i = 0; i < count; i++)
{
yield return(new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, new Uri("http://example.com/asdfasdfasdfasdfasdf/asdfasdfasdf/asdfasdfasdf/asdfasdf/sadf"))));
}
}
public async Task GetByIdReturnsNotFound()
{
// Arrange
var entityId = HttpMonitorId.Create().ToString();
// Act
(var response, _) = await _client.GetAsync(entityId);
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task DeleteReturnsNotFoundWhenEntityDoesNotExist()
{
// Arrange
var entityId = HttpMonitorId.Create().ToString();
// Act
var response = await _client.DeleteAsync(entityId);
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task GetByIdReturnsNullWhenNotFound()
{
// Arrange
var id = HttpMonitorId.Create();
// Act
var entity = await _repository.GetByIdAsync(id);
// Assert
Assert.Null(entity);
}
public async Task NotFound()
{
// Arrange
var id = HttpMonitorId.Create();
// Act
(var response, _) = await _client.TestAsync(id.ToString());
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task PutReturnsNotFoundWhenEntityDoesNotExist()
{
// Arrange
var entity = EntityGenerator.GenerateHttpMonitor();
var id = HttpMonitorId.Create().ToString();
// Act
(var response, _) = await _client.PutAsync(id, entity);
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
private HttpMonitor GenerateHttpMonitor()
{
var entity = new HttpMonitor(
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, new Uri("https://example.com")));
var @event = GenerateHttpMonitorChecked(entity);
entity.Handle(@event);
return(entity);
}
public async Task <HttpMonitor> CreateHttpMonitorAsync(CreateHttpMonitor command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var httpMonitor = new HttpMonitor(HttpMonitorId.Create(), command.Request);
await _repository.PutAsync(httpMonitor);
return(httpMonitor);
}
public void ValueIsImmutable()
{
// Arrange
var id = HttpMonitorId.Create();
var value = id.Value;
var newValue = Guid.NewGuid();
// Act
// cast to dynamic to attempt to set value to get around compilation error
Assert.Throws <RuntimeBinderException>(() => ((dynamic)id).Value = newValue);
// Assert
Assert.Equal(value, id.Value);
}
public async Task EndpointUnavailableReturnsError()
{
// Arrange
var command = new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, new Uri("http://localhost:9485/")));// nothing should be open on port
// Act
var @event = await _executor.CheckHttpEndpointAsync(command);
// Assert
Assert.Null(@event.Response);
Assert.Equal("A connection with the server could not be established", @event.ErrorMessage);
}
public async Task ForceCloseConnectionReturnsError()
{
// Arrange
var command = new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, _httpServer.BaseAddress));
_httpServer.Handler = async ctx =>
{
await _httpServer.Host.StopAsync();
};
// Act
var @event = await _executor.CheckHttpEndpointAsync(command);
// Assert
Assert.Null(@event.Response);
Assert.Equal("The server returned an invalid or unrecognized response", @event.ErrorMessage);
}
public async Task ResponseCatpured(HttpStatusCode statusCode)
{
// Arrange
var command = new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, _httpServer.BaseAddress));
_httpServer.Handler = ctx =>
{
// set response status code
ctx.Response.StatusCode = (int)statusCode;
return(Task.CompletedTask);
};
// Act
var @event = await _executor.CheckHttpEndpointAsync(command);
// Assert
Assert.Equal(statusCode, @event.Response.StatusCode);
}
public async Task HangRequestReturnsTimeoutError()
{
// Arrange
var command = new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, _httpServer.BaseAddress));
// set timeout on client level
_httpClient.Timeout = TimeSpan.FromMilliseconds(100);
_httpServer.Handler = async ctx =>
{
await Task.Delay(TimeSpan.FromMilliseconds(1000));
};
// Act
var @event = await _executor.CheckHttpEndpointAsync(command);
// Assert
Assert.Null(@event.Response);
Assert.Equal("Request timed out", @event.ErrorMessage);
}
public async Task RequestTiming(int millisecondsDelay)
{
// Arrange
var command = new CheckHttpEndpoint(
HttpMonitorCheckId.Create(),
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, _httpServer.BaseAddress));
_httpServer.Handler = async ctx =>
{
await Task.Delay(millisecondsDelay);
};
// Act
var expectedStartTime = DateTime.UtcNow;
var @event = await _executor.CheckHttpEndpointAsync(command);
var expectedEndTime = DateTime.UtcNow;
// Assert
AssertDateTime.Equal(expectedStartTime, @event.RequestTiming.StartTime, TimeSpanComparer.DefaultTolerance);
AssertDateTime.Equal(expectedEndTime, @event.RequestTiming.EndTime, TimeSpanComparer.DefaultTolerance);
}
public async Task TestLaunch()
{
// Arrange
var httpMonitor1 = new HttpMonitor(
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, _fixture.OpenHttpServer.BaseAddress));
var httpMonitor2 = new HttpMonitor(
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Delete, _fixture.OpenHttpServer.BaseAddress));
await _httpMonitorRepository.PutAsync(httpMonitor1);
await _httpMonitorRepository.PutAsync(httpMonitor2);
var tcs1 = new TaskCompletionSource <object>();
var tcs2 = new TaskCompletionSource <object>();
var combinedTasks = Task.WhenAll(tcs1.Task, tcs2.Task);
_openHttpServer.Handler = ctx =>
{
if (string.Equals(ctx.Request.Method, httpMonitor1.Request.Method.Method,
StringComparison.InvariantCultureIgnoreCase))
{
tcs1.SetResult(null);
ctx.Response.StatusCode = 200;
}
else if (string.Equals(ctx.Request.Method, httpMonitor2.Request.Method.Method,
StringComparison.InvariantCultureIgnoreCase))
{
tcs2.SetResult(null);
ctx.Response.StatusCode = 300;
}
else
{
ctx.Response.StatusCode = 404;
}
return(Task.CompletedTask);
};
// Act
await _fixture.StartHostAsync();
await Task.WhenAny(
combinedTasks,
Task.Delay(10000));
// Assert
Assert.True(combinedTasks.IsCompletedSuccessfully);
// todo race condition
await Task.Delay(100);
var check1 = (await _httpMonitorCheckRepository.GetAsync(httpMonitor1.Id)).SingleOrDefault();
Assert.NotNull(check1);
Assert.Equal(200, (int)check1.Response.StatusCode);
var check2 = (await _httpMonitorCheckRepository.GetAsync(httpMonitor2.Id)).SingleOrDefault();
Assert.NotNull(check2);
Assert.Equal(300, (int)check2.Response.StatusCode);
}
private Task GenerateAsync()
{
var httpMonitor = new HttpMonitor(HttpMonitorId.Create(), new HttpRequest(HttpMethod.Get, new Uri("http://example.com/sdfsd/sdfsdfsd/sdffsd")));
return(_repository.PutAsync(httpMonitor));
}
public static HttpMonitor Generate()
{
return(new HttpMonitor(
HttpMonitorId.Create(),
new HttpRequest(HttpMethod.Get, new Uri($"https://{DateTime.UtcNow.Ticks}.example.com/"))));
}
