public ScreenshotAdjusterParam CreateScreenshotAdjusterParam(IVideoMetadata videoMetadata)
{
CheckVideoStream(videoMetadata.VideoStreamsCount);
ScreenshotAdjusterParam screenshotAdjusterParam = CreateParam(videoMetadata);
return(screenshotAdjusterParam);
}
public DomainProcessedScreenshot BuildProcessedScreenshot(ScreenshotAdjusterParam screenshotAdjusterParam, string imageFormat, string contentType)
{
ScreenshotParam screenshotParam = _screenshotAdjuster.AdjustScreenshotParam(screenshotAdjusterParam);
DomainProcessedScreenshot processedScreenshot = CreateProcessedScreenshot(screenshotParam, imageFormat, contentType);
return(processedScreenshot);
}
public void AdjustScreenshotParam()
{
//Arrange
const int videoWidth = 234;
const int adjustWidth = 548;
const int videoHeight = 346;
const int adjustHeight = 548;
const double duration = 21.575;
const double adjustOffsetTime = 9;
const double videoRotation = 90;
var screenshotAdjusterParam = new ScreenshotAdjusterParam()
{
ImageWidth = videoWidth,
ImageHeight = videoHeight,
Duration = duration,
VideoRotation = videoRotation
};
_adjustmentScreenshotParam.Setup(m => m.AdjustScreenshotWidth(videoWidth)).Returns(adjustWidth);
_adjustmentScreenshotParam.Setup(m => m.AdjustScreenshotHeight(videoHeight)).Returns(adjustHeight);
_adjustmentScreenshotParam.Setup(m => m.AdjustScreenshotTimeOffset(duration)).Returns(adjustOffsetTime);
//Act
var adjustScreenshotParam = _screenshotAdjuster.AdjustScreenshotParam(screenshotAdjusterParam);
//Assert
Assert.AreEqual(adjustWidth, adjustScreenshotParam.ImageWidth);
Assert.AreEqual(adjustHeight, adjustScreenshotParam.ImageHeight);
Assert.AreEqual(adjustOffsetTime, adjustScreenshotParam.TimeOffset);
Assert.AreEqual(videoRotation, adjustScreenshotParam.VideoRotation);
}
public List <DomainProcessedScreenshot> Generate(IVideoMetadata videoMetadata)
{
ScreenshotAdjusterParam screenshotParam = _screenshotAdjusterParamFactory.CreateScreenshotAdjusterParam(videoMetadata);
DomainProcessedScreenshot processedScreenshot = _processedScreenshotBuilder.BuildProcessedScreenshot(screenshotParam, MetadataConstant.JpegFormat, ContentType.JpegContent);
IEnumerable <DomainProcessedScreenshot> processedScreenshots = CreateProcessedScreenshots(processedScreenshot);
var list = new List <DomainProcessedScreenshot>(processedScreenshots);
return(list);
}
public ScreenshotParam AdjustScreenshotParam(ScreenshotAdjusterParam screenshotAdjusterParam)
{
var exceptionList = new List <VideoFormatException>();
int width = AdjustScreenshotWidth(screenshotAdjusterParam.ImageWidth, exceptionList);
int height = AdjustScreenshotHeight(screenshotAdjusterParam.ImageHeight, exceptionList);
double timeOffset = _adjustmentScreenshotMetadata.AdjustScreenshotTimeOffset(screenshotAdjusterParam.Duration);
ScreenshotParam adjustScreenshotParam = CreateParam(width, height, timeOffset, screenshotAdjusterParam.VideoRotation);
CheckForException(exceptionList);
return(adjustScreenshotParam);
}
public void CreateScreenshotParamThrowAggregateExceptionTest()
{
//Arrange
var screenshotAdjusterParam = new ScreenshotAdjusterParam();
_adjustmentScreenshotParam.Setup(m => m.AdjustScreenshotWidth(It.IsAny <int>())).Throws(new VideoFormatException(ParamType.Width));
_adjustmentScreenshotParam.Setup(m => m.AdjustScreenshotHeight(It.IsAny <int>())).Throws(new VideoFormatException(ParamType.Height));
//Act & Assert
var exception = ExceptionAssert.Throws <AggregateException>(() => _screenshotAdjuster.AdjustScreenshotParam(screenshotAdjusterParam));
//Assert
Assert.IsTrue(exception.InnerExceptions.OfType <VideoFormatException>().Any(p => p.ParamType == ParamType.Width));
Assert.IsTrue(exception.InnerExceptions.OfType <VideoFormatException>().Any(p => p.ParamType == ParamType.Height));
}
public void GenerateProcessedScreenshotTest()
{
//Arrange
var paramFactory = new Mock <IScreenshotAdjusterParamFactory>();
var builder = new Mock <IProcessedScreenshotBuilder>();
var generator = new ProcessedScreenshotGenerator(paramFactory.Object, builder.Object);
var metadata = new Mock <IVideoMetadata>();
var scrrenshotAdjusterParam = new ScreenshotAdjusterParam();
var processedScreenshot = new DomainProcessedScreenshot();
paramFactory.Setup(m => m.CreateScreenshotAdjusterParam(metadata.Object)).Returns(scrrenshotAdjusterParam);
builder.Setup(m => m.BuildProcessedScreenshot(scrrenshotAdjusterParam, MetadataConstant.JpegFormat, ContentType.JpegContent)).Returns(processedScreenshot);
//Act
List <DomainProcessedScreenshot> list = generator.Generate(metadata.Object);
//Assert
Assert.AreEqual(1, list.Count);
Assert.IsTrue(list.Any(p => p == processedScreenshot));
}
public void BuildProcessedScreenshotTest()
{
//Arrange
const string imageFormat = "imageFormat";
const string contentType = "contentType";
var screenshotAdjuster = new Mock <IScreenshotAdjuster>();
var builder = new ProcessdScreenshotBuilder(screenshotAdjuster.Object);
var screenshotAdjusterParam = new ScreenshotAdjusterParam();
var screenshotParm = new ScreenshotParam();
screenshotAdjuster.Setup(m => m.AdjustScreenshotParam(screenshotAdjusterParam)).Returns(screenshotParm);
//Act
var processedScreenshot = builder.BuildProcessedScreenshot(screenshotAdjusterParam, imageFormat, contentType);
//Assert
Assert.AreEqual(screenshotParm, processedScreenshot.ScreenshotParam);
Assert.AreEqual(imageFormat, processedScreenshot.ImageFormat);
Assert.AreEqual(contentType, processedScreenshot.ContentType);
}
