public BenchMarkData ConvertToBenchMarkData(List <BenchMarkResult> resultDataPoints)
{
var benchmarkData = new BenchMarkData()
{
CloudProvider = Enum.ToObject(typeof(CloudProvider), resultDataPoints.First().CloudProvider).ToString(),
HostingEnvironment =
Enum.ToObject(typeof(HostingEnvironment), resultDataPoints.First().HostingEnvironment).ToString(),
Runtime = Enum.ToObject(typeof(Runtime), resultDataPoints.First().Runtime).ToString()
};
var currentDate = resultDataPoints.OrderByDescending(c => c.CreatedAt).First().CreatedAt.Date;
var coldMedians = MedianCalculator.Calculate(currentDate, resultDataPoints, true);
benchmarkData.ColdMedianExecutionTime = coldMedians.currentDay;
var coldDifference =
Math.Round(
((coldMedians.currentDay - coldMedians.previousDay) /
Math.Abs(coldMedians.currentDay)) * 100, 2);
benchmarkData.ColdPreviousDayDifference = coldDifference;
benchmarkData.ColdPreviousDayPositive = benchmarkData.ColdPreviousDayDifference < 0;
var warmMedians = MedianCalculator.Calculate(currentDate, resultDataPoints, false);
benchmarkData.WarmMedianExecutionTime = warmMedians.currentDay;
var warmDifference =
Math.Round(
((warmMedians.currentDay - warmMedians.previousDay) /
Math.Abs(warmMedians.currentDay)) * 100, 2);
benchmarkData.WarmPreviousDayDifference = warmDifference;
benchmarkData.WarmPreviousDayPositive = benchmarkData.WarmPreviousDayDifference < 0;
var dates = new List <DateTime>();
for (var i = 0; i < Convert.ToInt32(Environment.GetEnvironmentVariable("dayRange")); i++)
{
dates.Add(currentDate - TimeSpan.FromDays(i));
}
dates = dates.OrderBy(c => c.Date).ToList();
foreach (var date in dates)
{
benchmarkData.ColdDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"),
resultDataPoints.Where(c => c.CreatedAt.Date == date.Date && c.IsColdRequest)
.Select(c => c.RequestDuration).ToList()));
benchmarkData.WarmDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"),
resultDataPoints.Where(c => c.CreatedAt.Date == date.Date && !c.IsColdRequest)
.Select(c => c.RequestDuration).ToList()));
}
return(benchmarkData);
}
public async Task FunctionShouldReturnOkObjectResultContainingBenchMarkData()
{
#region Arrange
var benchMarkResults = new List <BenchMarkResult>()
{
new BenchMarkResult()
{
Id = 1,
CloudProvider = 0,
HostingEnvironment = 0,
Runtime = 0,
CreatedAt = DateTimeOffset.Now,
RequestDuration = 200,
Success = true
}
};
_mockBenchMarkResultService.Setup(c =>
c.GetBenchMarkResults(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()))
.Returns(Task.FromResult(benchMarkResults));
var sampleBenchMarkData = new BenchMarkData()
{
CloudProvider = "Azure"
};
_mockResponseConverter.Setup(c => c.ConvertToBenchMarkData(benchMarkResults))
.Returns(sampleBenchMarkData);
var trigger = new Trigger(_mockBenchMarkResultService.Object, _mockResponseConverter.Object);
var request = TestFactory.CreateHttpRequest(new Dictionary <string, StringValues>()
{
{ "cloudProvider", "Azure" }, { "hostingEnvironment", "Windows" }, { "runtime", "Csharp" }
});
#endregion
#region Act
var response = await trigger.Run(request, _logger);
#endregion
#region Assert
var responseObject = Assert.IsType <OkObjectResult>(response);
var benchMarkData = Assert.IsType <BenchMarkData>(responseObject.Value);
Assert.Equal(benchMarkData.CloudProvider, sampleBenchMarkData.CloudProvider);
#endregion
}
public BenchMarkData ConvertToBenchMarkData(List <BenchMarkResult> resultDataPoints)
{
var firstResult = resultDataPoints.OrderByDescending(c => c.CreatedAt).First();
var benchmarkData = new BenchMarkData()
{
CloudProvider = firstResult.CloudProvider.ToString(),
HostingEnvironment = firstResult.HostingEnvironment.ToString(),
Runtime = firstResult.Runtime.ToString()
};
var currentDate = firstResult.CreatedAt.Date;
var coldDataPoints = resultDataPoints.Where(c => c.IsColdRequest).ToList();
var coldMedians = MedianCalculator.Calculate(currentDate, coldDataPoints);
benchmarkData.ColdMedianExecutionTime = coldMedians.CurrentDay;
benchmarkData.ColdPreviousDayDifference = coldMedians.DifferencePercentage;
benchmarkData.ColdPreviousDayPositive = benchmarkData.ColdPreviousDayDifference < 0;
var warmDataPoints = resultDataPoints.Where(c => !c.IsColdRequest).ToList();
var warmMedians = MedianCalculator.Calculate(currentDate, warmDataPoints);
benchmarkData.WarmMedianExecutionTime = warmMedians.CurrentDay;
benchmarkData.WarmPreviousDayDifference = warmMedians.DifferencePercentage;
benchmarkData.WarmPreviousDayPositive = benchmarkData.WarmPreviousDayDifference < 0;
var dates = new List <DateTime>();
for (var i = 0; i < Convert.ToInt32(Environment.GetEnvironmentVariable("dayRange")); i++)
{
dates.Add(currentDate - TimeSpan.FromDays(i));
}
dates = dates.OrderBy(c => c.Date).ToList();
foreach (var date in dates)
{
benchmarkData.ColdDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"),
coldDataPoints.Where(c => c.CreatedAt.Date == date.Date)
.Select(c => c.RequestDuration).ToList()));
benchmarkData.WarmDataPoints.Add(new DataPoint(date.ToString("yyyy MMMM dd"),
warmDataPoints.Where(c => c.CreatedAt.Date == date.Date)
.Select(c => c.RequestDuration).ToList()));
}
return(benchmarkData);
}
public async Task Run_Should_Return_OkObjectResult_Containing_ConvertedBenchMarkData_From_Service()
{
// Arrange
var benchMarkResults = new List <BenchMarkResult>()
{
new BenchMarkResult()
{
Success = true,
}
};
Environment.SetEnvironmentVariable("dayRange", "1");
_mockBenchMarkResultService.Setup(c => c.GetDateTimeNow()).Returns(new DateTime(2020, 1, 2));
_mockBenchMarkResultService.Setup(c =>
c.GetBenchMarkResultsAsync(It.IsAny <CloudProvider>(), It.IsAny <HostEnvironment>(), It.IsAny <Runtime>(), It.IsAny <DateTime>()))
.Returns(Task.FromResult(benchMarkResults));
var sampleBenchMarkData = new BenchMarkData()
{
CloudProvider = "ReturnedData"
};
_mockResponseConverter.Setup(c => c.ConvertToBenchMarkData(benchMarkResults))
.Returns(sampleBenchMarkData);
var trigger = new Trigger(_mockBenchMarkResultService.Object, _mockResponseConverter.Object);
var request = TestFactory.CreateHttpRequest(new Dictionary <string, StringValues>()
{
{ "cloudProvider", "Firebase" }, { "hostingEnvironment", "Linux" }, { "runtime", "Fsharp" }
});
// Act
var response = await trigger.Run(request, _logger);
// Assert
var responseObject = Assert.IsType <OkObjectResult>(response);
var benchMarkData = Assert.IsType <BenchMarkData>(responseObject.Value);
Assert.Equal(sampleBenchMarkData.CloudProvider, benchMarkData.CloudProvider);
}
public async Task Run_Should_Call_ResponseConverter_With_Result_Of_BenchmarkResultService()
{
// Arrange
var benchMarkResults = new List <BenchMarkResult>()
{
new BenchMarkResult()
{
Id = 77,
Success = true,
}
};
Environment.SetEnvironmentVariable("dayRange", "1");
_mockBenchMarkResultService.Setup(c => c.GetDateTimeNow()).Returns(new DateTime(2020, 1, 2));
_mockBenchMarkResultService.Setup(c =>
c.GetBenchMarkResultsAsync(It.IsAny <CloudProvider>(), It.IsAny <HostEnvironment>(), It.IsAny <Runtime>(), It.IsAny <DateTime>()))
.Returns(Task.FromResult(benchMarkResults));
var sampleBenchMarkData = new BenchMarkData()
{
CloudProvider = "ReturnedData"
};
var trigger = new Trigger(_mockBenchMarkResultService.Object, _mockResponseConverter.Object);
var request = TestFactory.CreateHttpRequest(new Dictionary <string, StringValues>()
{
{ "cloudProvider", "Firebase" }, { "hostingEnvironment", "Linux" }, { "runtime", "Fsharp" }
});
// Act
var response = await trigger.Run(request, _logger);
// Assert
_mockResponseConverter.Verify(service => service.ConvertToBenchMarkData(
It.Is <List <BenchMarkResult> >(results => results[0].Id == benchMarkResults[0].Id)), Times.Once);
}
public async Task Run_Should_Call_BenchMarkResultService_With_QueryParameters()
{
// Arrange
var benchMarkResults = new List <BenchMarkResult>();
Environment.SetEnvironmentVariable("dayRange", "1");
_mockBenchMarkResultService.Setup(c => c.GetDateTimeNow()).Returns(new DateTime(2020, 1, 2));
_mockBenchMarkResultService.Setup(c =>
c.GetBenchMarkResultsAsync(It.IsAny <CloudProvider>(), It.IsAny <HostEnvironment>(), It.IsAny <Runtime>(), It.IsAny <DateTime>()))
.Returns(Task.FromResult(benchMarkResults));
var sampleBenchMarkData = new BenchMarkData()
{
CloudProvider = "Azure"
};
_mockResponseConverter.Setup(c => c.ConvertToBenchMarkData(benchMarkResults))
.Returns(sampleBenchMarkData);
var trigger = new Trigger(_mockBenchMarkResultService.Object, _mockResponseConverter.Object);
var request = TestFactory.CreateHttpRequest(new Dictionary <string, StringValues>()
{
{ "cloudProvider", "Firebase" }, { "hostingEnvironment", "Linux" }, { "runtime", "Fsharp" }
});
// Act
var response = await trigger.Run(request, _logger);
// Assert
_mockBenchMarkResultService.Verify(service => service.GetBenchMarkResultsAsync(
It.Is <CloudProvider>(cloudProvider => cloudProvider == CloudProvider.Firebase),
It.Is <HostEnvironment>(hostingEnvironment => hostingEnvironment == HostEnvironment.Linux),
It.Is <Runtime>(runtime => runtime == Runtime.Fsharp),
It.IsAny <DateTime>()), Times.Once);
}
