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); }