public void GivenABackgroundColourWhenImageResizedThenBackgroundColourApplied()
{
// Arrange
var request = new ResizeRequest(Resolution.X1080, BackgroundColour.Black, string.Empty, FileType.Png);
// Act
_sut.MutateImage(request);
// Assert
_mockImageProcessService.Verify(service => service.ChangeBackgroundColour(It.IsAny <Image>(), It.IsAny <string>()), Times.Once);
}
public void GivenNoWatermarkWhenImageResizedThenNoWatermarkApplied()
{
// Arrange
var request = new ResizeRequest(Resolution.X1080, BackgroundColour.None, string.Empty, FileType.Png);
// Act
_sut.MutateImage(request);
// Assert
_mockImageProcessService.Verify(service => service.AddWaterMark(It.IsAny <Image>(), It.IsAny <string>()), Times.Never);
}
public void GivenResolution2160WhenImageResizedThenImageResized()
{
// Arrange
var request = new ResizeRequest(Resolution.X2160, BackgroundColour.None, string.Empty, FileType.Png);
// Act
_sut.MutateImage(request);
// Assert
_mockImageProcessService.Verify(service => service.ResizeImage(It.IsAny <Image>(), It.IsAny <string>()), Times.Once);
}
public void GivenFileTypeJpgWhenImageResizedThenFileTypeSavedAsJpg()
{
// Arrange
var request = new ResizeRequest(Resolution.X1080, BackgroundColour.None, String.Empty, FileType.Jpg);
// Act
var result = _sut.MutateImage(request);
using var image = Image.Load(result, out var format);
// Assert
Assert.Equal("jpg", format.FileExtensions.FirstOrDefault());
}
public async void GivenFileCachedWhenRequestedThenReturnCachedImage()
{
// Arrange
var request = new ResizeRequest(Resolution.X1080, BackgroundColour.None, String.Empty, FileType.Jpg);
_cache.Setup(cache => cache.GetAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(_thing));
// Act
var result = await _sut.Handle(request, CancellationToken.None);
// Assert
_mockFileService.Verify(service => service.MutateImage(It.IsAny <ResizeRequest>()), Times.Never);
}
public void ReturnResizeResult()
{
var resizeRequest = new ResizeRequest(LargeImage, 100, 100);
var sw = new Stopwatch();
sw.Start();
using (var resizeResult = _imageResizer.ResizeImage(resizeRequest))
{
sw.Stop();
_output.WriteLine($"Took:{sw.Elapsed}");
resizeResult.ShouldBeOfType <ResizeResult>();
resizeResult.ImageData.Length.ShouldBeGreaterThanOrEqualTo(1);
}
}
public byte[] MutateImage(ResizeRequest request)
{
var location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var filePath = location + @"\Images\01_04_2019_001103.png";
var fileStream = File.OpenRead(filePath);
using var outputStream = new MemoryStream();
using (var image = Image.Load(fileStream))
{
var resolution = request.Resolution.GetAttributeOfType <DescriptionAttribute>().Description;
_imageProcessService.ResizeImage(image, resolution);
if (!string.IsNullOrWhiteSpace(request.Watermark))
{
_imageProcessService.AddWaterMark(image, request.Watermark);
}
if (request.BackgroundColour != BackgroundColour.None)
{
var colourHex = request.BackgroundColour.GetAttributeOfType <DescriptionAttribute>().Description;
_imageProcessService.ChangeBackgroundColour(image, colourHex);
}
switch (request.FileType)
{
case FileType.Png:
image.SaveAsPng(outputStream);
break;
case FileType.Jpg:
image.SaveAsJpeg(outputStream);
break;
}
}
return(outputStream.ToArray());
}
public void FindAverageRunTime()
{
const int amountOfTimesToRun = 10;
var runTimes = new Stack <TimeSpan>(amountOfTimesToRun);
var resizeRequest = new ResizeRequest(LargeImage, 100, 100);
for (int i = 0; i < amountOfTimesToRun; i++)
{
var sw = new Stopwatch();
sw.Start();
using (_imageResizer.ResizeImage(resizeRequest))
{
sw.Stop();
runTimes.Push(sw.Elapsed);
_output.WriteLine($"Took:{sw.Elapsed}");
}
}
var average = runTimes.Average(x => x.TotalMilliseconds);
_output.WriteLine($"Average:{average} ms");
}
public override ExecuteResult Execute(HandlerStartInfo startInfo)
{
ResizeResponse response = new ResizeResponse // Handler response
{
Results = new List <ResizeResult>()
};
try
{
_mainProgressMsg = "Deserializing incoming request...";
UpdateProgress(_mainProgressMsg, StatusType.Initializing);
ResizeRequest parms = DeserializeOrNew <ResizeRequest>(startInfo.Parameters);
_mainProgressMsg = "Processing individual child request...";
UpdateProgress(_mainProgressMsg, StatusType.Running);
if (parms?.Details != null)
{
foreach (ResizeDetail detail in parms.Details)
{
bool subTaskSucceed = false;
try
{
_subProgressMsg = "Verifying child request parameters...";
UpdateProgress(_subProgressMsg);
if (ValidateRequest(detail))
{
_subProgressMsg = "Executing request" + (startInfo.IsDryRun ? " in dry run mode..." : "...");
UpdateProgress(_subProgressMsg);
subTaskSucceed = ExecuteEc2Resize(detail, startInfo.IsDryRun); // TODO: Complete this
_subProgressMsg = "Processed child request.";
UpdateProgress(_subProgressMsg);
}
}
catch (Exception ex)
{
_subProgressMsg = ex.Message;
UpdateProgress(_subProgressMsg);
subTaskSucceed = false;
}
finally
{
response.Results.Add(new ResizeResult()
{
ExitCode = subTaskSucceed ? 0 : -1,
ExitSummary = _subProgressMsg,
Environment = detail.Environment,
InstanceId = detail.InstanceId,
NewInstanceType = detail.NewInstanceType,
Region = detail.Region
});
}
}
_result.Status = StatusType.Complete;
}
else
{
_result.Status = StatusType.Failed;
_mainProgressMsg = "No server resize detail is found from the incoming request.";
UpdateProgress(_mainProgressMsg, StatusType.Failed);
}
}
catch (Exception ex)
{
_result.Status = StatusType.Failed;
_mainProgressMsg = $"Execution has been aborted due to: {ex.Message}";
UpdateProgress(_mainProgressMsg, StatusType.Failed);
}
_mainProgressMsg = startInfo.IsDryRun ? "Dry run execution is completed." : "Execution is completed.";
response.Summary = _mainProgressMsg;
_result.ExitData = JsonConvert.SerializeObject(response);
return(_result);
}
