private void Create <T>(
Func <T, Guid> createdByUserGuid = null,
Func <T, DateTime> createdAtDateTime = null,
Func <T, Guid> modifiedByUserGuid = null,
Func <T, DateTime> modifiedAtDateTime = null)
where T : class, IAudit, new()
{
long auditId;
this.dateTime.DateTime = new DateTime(2010, 3, 23, 1, 2, 3, 111);
using (var unitOfWork = this.unitOfWorkFactory.Create())
{
var audit = new T();
unitOfWork.Add(audit);
unitOfWork.Save();
auditId = audit.ID;
}
using (var unitOfWork = this.unitOfWorkFactory.Create())
{
var audit = unitOfWork.Query <T>().Single(c => c.ID == auditId);
if (createdByUserGuid != null)
{
Assert.AreEqual(this.userGuid, createdByUserGuid(audit));
}
if (createdAtDateTime != null)
{
AssertDateTime.IsEqual(createdAtDateTime(audit), new DateTime(2010, 3, 23, 1, 2, 3, 111));
}
if (modifiedByUserGuid != null)
{
Assert.AreEqual(this.userGuid, modifiedByUserGuid(audit));
}
if (modifiedAtDateTime != null)
{
AssertDateTime.IsEqual(modifiedAtDateTime(audit), new DateTime(2010, 3, 23, 1, 2, 3, 111));
}
}
}
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 Test()
{
// Arrange
(_, var entity) = await _client.PostAsync(new
{
Request = new
{
Url = new Uri(_httpServer.BaseAddress, "foo/bar?q=123"),
Method = "GET"
}
});
string actualMethod = null;
string actualPath = null;
string actualQueryString = null;
_httpServer.Handler = ctx =>
{
actualMethod = ctx.Request.Method;
actualPath = ctx.Request.Path.Value;
actualQueryString = ctx.Request.QueryString.Value;
return(Task.CompletedTask);
};
// Act
(var response, var testResult) = await _client.TestAsync(entity.Id);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(entity.Request.Method, actualMethod, StringComparer.InvariantCultureIgnoreCase);
Assert.Equal(entity.Request.Url.AbsolutePath, actualPath);
Assert.Equal(entity.Request.Url.Query, actualQueryString);
var expectedResult = new HttpMonitorCheckedDto()
{
HttpMonitorId = entity.Id,
Request = new HttpRequestDto()
{
Url = entity.Request.Url,
Method = HttpMethod.Get.ToString()
},
Response = new HttpResponseDto()
{
StatusCode = (int)HttpStatusCode.OK
},
RequestTiming = new HttpRequestTimingDto()
{
StartTime = DateTime.UtcNow,
EndTime = DateTime.UtcNow
}
};
Assert.Equal(expectedResult.HttpMonitorId, testResult.HttpMonitorId);
Assert.Equal(expectedResult.Request, testResult.Request);
Assert.Equal(expectedResult.Response, testResult.Response);
AssertDateTime.Equal(expectedResult.RequestTiming.StartTime, testResult.RequestTiming.StartTime, TimeSpanComparer.DefaultTolerance);
AssertDateTime.Equal(expectedResult.RequestTiming.EndTime, testResult.RequestTiming.EndTime, TimeSpanComparer.DefaultTolerance);
}
