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 Task <HttpMonitor> GetByIdAsync(HttpMonitorId id)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
var uri = _configs.DocumentCollectionUri;
var options = new FeedOptions()
{
MaxItemCount = 1
};
var querySpec = new SqlQuerySpec
{
QueryText = "select * from root r where (r.id = @id and r._type = @type)",
Parameters = new SqlParameterCollection
{
new SqlParameter("@id", id.ToString()),
new SqlParameter("@type", DocumentType)
}
};
return(_client.CreateDocumentQuery <HttpMonitor>(uri, querySpec, options)
.AsDocumentQuery()
.FirstOrDefaultAsync());
}
public HttpMonitorUp(HttpMonitorId httpMonitorId, MonitorStatus previousStatus, DateTime startTime, DateTime created)
{
HttpMonitorId = httpMonitorId ?? throw new ArgumentNullException(nameof(httpMonitorId));
PreviousStatus = previousStatus;
StartTime = startTime;
Created = created;
}
public static async Task <HttpResponseMessage> PutAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "put", Route = "httpmonitors/{httpMonitorId}")] HttpRequestMessage req,
string httpMonitorId,
TraceWriter log,
[Inject] IHttpMonitorService service,
[Inject] JsonMediaTypeFormatter formatter)
{
if (!HttpMonitorId.TryParse(httpMonitorId, out var id))
{
return(req.CreateResponse(HttpStatusCode.NotFound));
}
try
{
var cmd = await req.Content.ReadAsAsync <UpdateHttpMonitor>(new[] { formatter });
cmd.HttpMonitorId = id;
var httpMonitor = await service.UpdateHttpMonitorAsync(cmd);
return(req.CreateResponse(HttpStatusCode.OK, httpMonitor, formatter));
}
catch (EntityNotFoundException)
{
return(req.CreateResponse(HttpStatusCode.NotFound));
}
}
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);
}
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)));
}
public Task <HttpMonitor> GetHttpMonitorByIdAsync(HttpMonitorId httpMonitorId)
{
if (httpMonitorId == null)
{
throw new ArgumentNullException(nameof(httpMonitorId));
}
return(_repository.GetByIdAsync(httpMonitorId));
}
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);
}
public CheckHttpEndpoint(
HttpMonitorCheckId httpMonitorCheckId,
HttpMonitorId httpMonitorId,
HttpRequest request)
{
HttpMonitorCheckId = httpMonitorCheckId ?? throw new ArgumentNullException(nameof(httpMonitorCheckId));
HttpMonitorId = httpMonitorId ?? throw new ArgumentNullException(nameof(httpMonitorId));
Request = request ?? throw new ArgumentNullException(nameof(request));
}
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 <IActionResult> Get(HttpMonitorId httpMonitorId)
{
var httpMonitor = await _service.GetHttpMonitorByIdAsync(httpMonitorId);
if (httpMonitor != null)
{
return(Ok(httpMonitor));
}
return(NotFound());
}
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 NotFound()
{
// Arrange
var id = HttpMonitorId.Create();
// Act
(var response, _) = await _client.TestAsync(id.ToString());
// 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 GetByIdReturnsNotFound()
{
// Arrange
var entityId = HttpMonitorId.Create().ToString();
// Act
(var response, _) = await _client.GetAsync(entityId);
// 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 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);
}
public async Task <HttpMonitorCheck> ExecuteAsync(HttpMonitorId httpMonitorId)
{
var httpMonitor = await _repository.GetByIdAsync(httpMonitorId);
if (httpMonitor == null)
{
throw new EntityNotFoundException(httpMonitorId);
}
var cmd = httpMonitor.CreateCheckHttpEndpoint(HttpMonitorCheckId.Create());
return(await _executor.CheckHttpEndpointAsync(cmd));
}
public async Task <IActionResult> Delete(HttpMonitorId httpMonitorId)
{
try
{
await _service.DeleteHttpMonitorAsync(httpMonitorId);
return(NoContent());
}
catch (EntityNotFoundException)
{
return(NotFound());
}
}
public HttpMonitorDown(HttpMonitorId httpMonitorId, MonitorStatus previousStatus, DateTime startTime, DateTime created)
{
if (!Enum.IsDefined(typeof(MonitorStatus), previousStatus))
{
throw new InvalidEnumArgumentException(nameof(previousStatus), (int)previousStatus,
typeof(MonitorStatus));
}
HttpMonitorId = httpMonitorId ?? throw new ArgumentNullException(nameof(httpMonitorId));
PreviousStatus = previousStatus;
StartTime = startTime;
Created = created;
}
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 async Task <IActionResult> Test(HttpMonitorId httpMonitorId)
{
try
{
var result = await _service.ExecuteAsync(httpMonitorId);
// maybe set status code if considered "down"?
return(Ok(result));
}
catch (EntityNotFoundException)
{
return(NotFound());
}
}
public ScheduleDownAlertContact(AlertContactId alertContactId, HttpMonitorId httpMonitorId, MonitorStatus previousStatus, DateTime startTime, DateTime created)
{
if (!Enum.IsDefined(typeof(MonitorStatus), previousStatus))
{
throw new InvalidEnumArgumentException(nameof(previousStatus), (int)previousStatus,
typeof(MonitorStatus));
}
AlertContactId = alertContactId ?? throw new ArgumentNullException(nameof(alertContactId));
HttpMonitorId = httpMonitorId ?? throw new ArgumentNullException(nameof(httpMonitorId));
PreviousStatus = previousStatus;
StartTime = startTime;
Created = created;
}
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 <IActionResult> Put(HttpMonitorId httpMonitorId, [FromBody] UpdateHttpMonitor command)
{
command.HttpMonitorId = httpMonitorId;
try
{
var httpMonitor = await _service.UpdateHttpMonitorAsync(command);
return(Ok(httpMonitor));
}
catch (EntityNotFoundException)
{
return(NotFound());
}
}
public async Task DeleteHttpMonitorAsync(HttpMonitorId httpMonitorId)
{
if (httpMonitorId == null)
{
throw new ArgumentNullException(nameof(httpMonitorId));
}
var httpMonitor = await _repository.GetByIdAsync(httpMonitorId);
if (httpMonitor == null)
{
throw new EntityNotFoundException(httpMonitorId);
}
await _repository.DeleteAsync(httpMonitorId);
}
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);
}
