/// <summary>
/// Checks that the service correctly determines status code and response time.
/// </summary>
/// <param name="option">Option describing the expected behavior</param>
public async Task GeneratesCorrectDataPoint(HttpResponseOption option)
{
// Arrange
var responseHandler = new ResponseHandler();
responseHandler.AddHandler(
new Uri("https://my.url.com"),
option
);
var mockHttpFactory = new Mock <IHttpClientFactory>();
mockHttpFactory
.Setup(factory => factory.BuildClient())
.Returns(new HttpClient(responseHandler));
var metricServiceMock = new Mock <IMetricService>();
metricServiceMock
.Setup(mock => mock.GetOrCreateMetricAsync(Metrics.Ping, "https://my.url.com"))
.ReturnsAsync(new Metric());
var pingService = new PingService(
metricServiceMock.Object,
new Mock <ILogger <PingService> >().Object,
mockHttpFactory.Object
);
// Act
var dataPoint = await pingService.PingServerAsync(
new PingSetting {
ServerUrl = "https://my.url.com",
MaxResponseTime = new TimeSpan(0, 0, 0, 0, 500)
}
);
// Assert
switch (option)
{
case HttpResponseOption.Success:
Assert.True(dataPoint.Success);
Assert.True(dataPoint.ResponseTime < new TimeSpan(0, 0, 0, 0, 2000));
break;
case HttpResponseOption.Timeout:
Assert.False(dataPoint.Success);
Assert.Equal(new TimeSpan(0), dataPoint.ResponseTime);
break;
case HttpResponseOption.ServiceUnavailable:
Assert.False(dataPoint.Success);
Assert.True(dataPoint.ResponseTime < new TimeSpan(0, 0, 0, 0, 2000));
break;
}
// Clean up
responseHandler.RemoveHandler(
new Uri("https://my.url.com")
);
}
private void SendSlowResponse(
HeyHttpResponse response,
int delayInMilliseconds,
HttpResponseOption option)
{
Stream stream = response.ContentStream;
long idleLength;
if (!request.QueryStringHas("idleLength", out idleLength))
{
idleLength = -1;
}
// Calculate positions.
long totalBytesRead = 0;
long firstPosition = 0;
if (response.FirstPosition > 0)
{
firstPosition = response.FirstPosition;
stream.Position = firstPosition;
}
long length = response.ContentStream.Length;
if (response.LastPosition > 0)
{
length = response.LastPosition - firstPosition + 1;
}
// Send headers.
response.Headers.Add("Content-Length: " + length);
response.Headers.Add("Content-Type: " + GetMediaType(request.Path));
response.CopyHeadersTo(networkStream);
// Server must not send a message body when using HEAD method (RFC 7231 4.3.2 HEAD).
if (request.IsHeadMethod)
{
return;
}
// Calulate buffer size.
int bufferLength;
if (!request.QueryStringHas("bufferLength", out bufferLength))
{
bufferLength = 1000000; // 1 MB
}
byte[] buffer = new byte[bufferLength];
while (totalBytesRead < length)
{
long remainingBytes = length - totalBytesRead;
int loopLength = (int)Math.Min(bufferLength, remainingBytes);
int localBytesRead = stream.Read(buffer, 0, loopLength);
if (option == HttpResponseOption.Pause)
{
BlockThreadUntilEnterIsPressed();
}
if (option == HttpResponseOption.Slow)
{
Thread.Sleep(delayInMilliseconds);
}
networkStream.Write(buffer, 0, localBytesRead);
networkStream.Flush();
totalBytesRead += localBytesRead;
logger.WriteBodyLine(String.Format(
"{0,13:N0} of {1,13:N0} bytes sent.",
totalBytesRead,
length));
if (idleLength >= 0 && totalBytesRead >= idleLength)
{
BlockThreadUntilClientIsDisconnected();
}
}
logger.WriteBodyLine("Response completed!\r\n");
}
public void AddHandler(Uri uri, HttpResponseOption option)
{
_urls.Add(uri, option);
}
public async Task GeneratesCorrectDataPoint(HttpResponseOption option)
{
// Arrange
var responseHandler = new ResponseHandler();
responseHandler.AddAction(
new Uri("http://ping.server"),
() =>
option == HttpResponseOption.Success ?
JsonConvert.SerializeObject(
new RemotePingServerResponse
{
Latency = 100,
StatusCode = 200,
IsError = false
}
) :
JsonConvert.SerializeObject(
new RemotePingServerResponse
{
StatusCode = 503,
IsError = true,
Error = "Some error"
}
)
);
var mockHttpFactory = new Mock <IHttpClientFactory>();
mockHttpFactory
.Setup(factory => factory.BuildClient())
.Returns(new HttpClient(responseHandler));
var metricServiceMock = new Mock <IMetricService>();
metricServiceMock
.Setup(mock => mock.GetOrCreateMetricAsync(Metrics.Ping, "https://my.url.com"))
.ReturnsAsync(new Metric());
var config = new Mock <IConfiguration>();
config
.SetupGet(conf => conf["Data:PingServerUrl"])
.Returns("http://ping.server");
var pingService = new RemotePingService(
metricServiceMock.Object,
new Mock <ILogger <PingService> >().Object,
config.Object,
mockHttpFactory.Object
);
// Act
var dataPoint = await pingService.PingServerAsync(
new PingSetting
{
ServerUrl = "https://my.url.com",
MaxResponseTime = new TimeSpan(0, 0, 0, 0, 500)
}
);
// Assert
switch (option)
{
case HttpResponseOption.Success:
Assert.True(dataPoint.Success);
Assert.Equal(dataPoint.ResponseTime, new TimeSpan(0, 0, 0, 0, 100));
Assert.Equal("OK", dataPoint.Message);
break;
case HttpResponseOption.ServiceUnavailable:
Assert.False(dataPoint.Success);
Assert.Equal(dataPoint.ResponseTime, new TimeSpan(0));
Assert.Equal("Some error", dataPoint.Message);
break;
}
// Clean up
responseHandler.RemoveAction(
new Uri("http://ping.server")
);
}
