public void TryOpenBlock_IfSuccessfulCreatesNewProxyJsonBlockAndReturnsBlockStateContinue()
{
// Arrange
const BlockState expectedResult = BlockState.Continue;
var dummyLine = new StringSlice("o{dummy");
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = dummyLine;
var dummyProxyJsonBlock = new ProxyJsonBlock(null, null);
Mock <IJsonBlockFactory <Block, ProxyJsonBlock> > mockJsonBlockFactory = _mockRepository.Create <IJsonBlockFactory <Block, ProxyJsonBlock> >();
dummyLine.NextChar(); // TryOpenProxy advances line by 1 char (skips @) before calling ParseLine
Mock <ExposedJsonBlockParser> mockTestSubject = CreateMockExposedJsonBlockParser(mockJsonBlockFactory.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ParseLine(dummyLine, dummyProxyJsonBlock)).Returns(expectedResult);
mockJsonBlockFactory.Setup(b => b.CreateProxyJsonBlock(dummyBlockProcessor, mockTestSubject.Object)).Returns(dummyProxyJsonBlock);
// Act
BlockState result = mockTestSubject.Object.ExposedTryOpenBlock(dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(expectedResult, result);
Assert.Single(dummyBlockProcessor.NewBlocks);
Assert.Same(dummyProxyJsonBlock, dummyBlockProcessor.NewBlocks.Peek());
}
public void Create_CreatesFlexiOptionsBlockAndAddsItToDocumentData()
{
// Arrange
const int dummyLine = 6;
const int dummyColumn = 3;
var dummySpan = new SourceSpan(9, 12);
var dummyLines = new StringLineGroup(2);
Mock <BlockParser> dummyBlockParser = _mockRepository.Create <BlockParser>();
var dummyProxyJsonBlock = new ProxyJsonBlock(null, dummyBlockParser.Object)
{
Lines = dummyLines,
Line = dummyLine,
Column = dummyColumn,
Span = dummySpan
};
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
FlexiOptionsBlockFactory testSubject = CreateFlexiOptionsBlockFactory();
// Act
FlexiOptionsBlock result = testSubject.Create(dummyProxyJsonBlock, dummyBlockProcessor);
// Assert
Assert.Null(result);
var resultFlexiOptionsBlock = dummyBlockProcessor.Document.GetData(FlexiOptionsBlockFactory.PENDING_FLEXI_OPTIONS_BLOCK) as FlexiOptionsBlock;
Assert.NotNull(resultFlexiOptionsBlock);
Assert.Same(dummyBlockParser.Object, resultFlexiOptionsBlock.Parser);
Assert.Equal(dummyLines, resultFlexiOptionsBlock.Lines); // Default ValueType comparer - https://github.com/dotnet/coreclr/blob/master/src/System.Private.CoreLib/src/System/ValueType.cs
Assert.Equal(dummyLine, resultFlexiOptionsBlock.Line);
Assert.Equal(dummyColumn, resultFlexiOptionsBlock.Column);
Assert.Equal(dummySpan, resultFlexiOptionsBlock.Span); // Default ValueType comparer - https://github.com/dotnet/coreclr/blob/master/src/System.Private.CoreLib/src/System/ValueType.cs
}
public void CloseProxy_ThrowsJsonExceptionIfJsonIsIncomplete()
{
// Arrange
const string dummyLines = "dummyLines";
var dummyProxyJsonBlock = new ProxyJsonBlock(null, null);
dummyProxyJsonBlock.Lines = new StringLineGroup(dummyLines);
dummyProxyJsonBlock.NumOpenObjects = 1;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
ExposedJsonBlockParser testSubject = CreateExposedJsonBlockParser();
// Act and assert
JsonException result = Assert.Throws <JsonException>(() => testSubject.ExposedCloseProxy(dummyBlockProcessor, dummyProxyJsonBlock));
Assert.Equal(string.Format(Strings.JsonException_Shared_InvalidJson, dummyLines), result.Message);
}
/// <summary>
/// Creates a <see cref="FlexiPictureBlock"/>.
/// </summary>
/// <param name="proxyJsonBlock">The <see cref="ProxyJsonBlock"/> containing data for the <see cref="FlexiPictureBlock"/>.</param>
/// <param name="blockProcessor">The <see cref="BlockProcessor"/> processing the <see cref="FlexiPictureBlock"/>.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="proxyJsonBlock"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="blockProcessor"/> is <c>null</c>.</exception>
/// <exception cref="OptionsException">Thrown if an option is invalid.</exception>
/// <exception cref="InvalidOperationException">Thrown if dimensions cannot be read from the local image file.</exception>
public override FlexiPictureBlock Create(ProxyJsonBlock proxyJsonBlock, BlockProcessor blockProcessor)
{
(IFlexiPictureBlockOptions flexiPictureBlockOptions, IFlexiPictureBlocksExtensionOptions flexiPictureBlocksExtensionOptions) = _optionsService.
CreateOptions(blockProcessor, proxyJsonBlock);
// Block name
string blockName = ResolveBlockName(flexiPictureBlockOptions.BlockName);
// Src
string fileName = ValidateSrcAndResolveFileName(flexiPictureBlockOptions);
// Enable file operations
double height = flexiPictureBlockOptions.Height;
double width = flexiPictureBlockOptions.Width;
bool enableFileOperations = ResolveEnableFileOperations(flexiPictureBlockOptions.EnableFileOperations,
flexiPictureBlocksExtensionOptions.LocalMediaDirectory,
width,
height);
// Source local absolute path
string localAbsolutePath = ResolveLocalAbsolutePath(enableFileOperations, fileName, flexiPictureBlocksExtensionOptions);
// Resolve intrinsic width and height
(double resolvedWidth, double resolvedHeight, double aspectRatio) = ResolveDimensions(localAbsolutePath, width, height);
// Create block
return(new FlexiPictureBlock(blockName,
flexiPictureBlockOptions.Src,
flexiPictureBlockOptions.Alt,
flexiPictureBlockOptions.Lazy,
resolvedWidth,
resolvedHeight,
aspectRatio,
flexiPictureBlockOptions.ExitFullscreenIcon,
flexiPictureBlockOptions.ErrorIcon,
flexiPictureBlockOptions.Spinner,
flexiPictureBlockOptions.Attributes,
proxyJsonBlock.Parser)
{
Column = proxyJsonBlock.Column,
Line = proxyJsonBlock.Line,
Span = proxyJsonBlock.Span
});
}
public void CloseProxy_ReturnsJsonBlockIfSuccessful()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
var dummyProxyJsonBlock = new ProxyJsonBlock(null, null);
dummyProxyJsonBlock.NumOpenObjects = 0;
Mock <Block> dummyBlock = _mockRepository.Create <Block>(null);
Mock <IJsonBlockFactory <Block, ProxyJsonBlock> > mockJsonBlockFactory = _mockRepository.Create <IJsonBlockFactory <Block, ProxyJsonBlock> >();
mockJsonBlockFactory.Setup(j => j.Create(dummyProxyJsonBlock, dummyBlockProcessor)).Returns(dummyBlock.Object);
ExposedJsonBlockParser testSubject = CreateExposedJsonBlockParser(mockJsonBlockFactory.Object);
// Act
Block result = testSubject.ExposedCloseProxy(dummyBlockProcessor, dummyProxyJsonBlock);
// Assert
_mockRepository.VerifyAll();
Assert.Same(dummyBlock.Object, result);
}
public void CreateProxyJsonBlock_CreatesProxyJsonBlock()
{
// Arrange
const int dummyColumn = 4;
const int dummyLineStart = 2;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Column = dummyColumn;
dummyBlockProcessor.Line = new StringSlice("", dummyLineStart, 10);
Mock <BlockParser> dummyBlockParser = _mockRepository.Create <BlockParser>();
ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory();
// Act
ProxyJsonBlock result = testSubject.CreateProxyJsonBlock(dummyBlockProcessor, dummyBlockParser.Object);
// Assert
Assert.Equal(result.Column, dummyColumn);
Assert.Equal(result.Span.Start, dummyLineStart);
Assert.Equal(nameof(Block), result.MainTypeName);
Assert.Same(dummyBlockParser.Object, result.Parser);
}
public void TryContinueBlock_AttemptsToContinueProxyBlock()
{
// Arrange
const BlockState expectedResult = BlockState.Continue;
var dummyLine = new StringSlice("o{dummy");
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = dummyLine;
var dummyProxyJsonBlock = new ProxyJsonBlock(null, null);
Mock <ExposedJsonBlockParser> mockTestSubject = CreateMockExposedJsonBlockParser();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ParseLine(dummyLine, dummyProxyJsonBlock)).Returns(expectedResult);
// Act
BlockState result = mockTestSubject.Object.ExposedTryContinueBlock(dummyBlockProcessor, dummyProxyJsonBlock);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(expectedResult, result);
}
public void ParseLine_ParsesTheLineUpdatesBlockSpanEndAndReturnsBlockState(string dummyJson)
{
// Arrange
ExposedJsonBlockParser testSubject = CreateExposedJsonBlockParser();
var dummyProxyJsonBlock = new ProxyJsonBlock(null, null);
var lineReader = new LineReader(dummyJson);
// Act and assert
while (true)
{
BlockState result = testSubject.ParseLine(lineReader.ReadLine().Value, dummyProxyJsonBlock);
if (result == BlockState.Break)
{
Assert.Null(lineReader.ReadLine()); // If result is break we must be at the last line
break;
}
else
{
Assert.Equal(BlockState.Continue, result);
}
}
Assert.Equal(dummyJson.Length - 1, dummyProxyJsonBlock.Span.End);
}
public override Block Create(ProxyJsonBlock proxyJsonBlock, BlockProcessor blockProcessor)
{
// Do nothing
return(null);
}
public void Create_CreatesFlexiVideoBlock()
{
// Arrange
const int dummyColumn = 3;
const int dummyLine = 5;
var dummySpan = new SourceSpan(1, 5);
const string dummyBlockName = "dummyBlockName";
const string dummyResolvedBlockName = "dummyResolvedBlockName";
const string dummySrc = "dummySrc";
const string dummyType = "dummyType";
const double dummyWidth = 123;
const double dummyResolvedWidth = 515;
const double dummyHeight = 321;
const double dummyResolvedHeight = 356;
const double dummyDuration = 123.456;
const double dummyResolvedDuration = 321.654;
const bool dummyGeneratePoster = true;
const string dummyPoster = "dummyPoster";
const string dummyResolvedPoster = "dummyResolvedPoster";
const bool dummyEnableFileOperations = false;
const bool dummyResolvedEnableFileOperations = true;
const string dummySpinner = "dummySpinner";
const string dummyPlayIcon = "dummyPlayIcon";
const string dummyPauseIcon = "dummyPauseIcon";
const string dummyFullscreenIcon = "dummyFullscreenIcon";
const string dummyExitFullscreenIcon = "dummyExitFullscreenIcon";
const string dummyErrorIcon = "dummyErrorIcon";
var dummyAttributes = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
const string dummyLocalMediaDirectory = "dummyLocalMediaDirectory";
var dummyMimeTypes = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
const string dummyFileName = "dummyFileName";
const string dummyLocalAbsolutePath = "dummyLocalAbsolutePath";
const double dummyAspectRatio = 968;
Mock <BlockParser> dummyBlockParser = _mockRepository.Create <BlockParser>();
var dummyProxyJsonBlock = new ProxyJsonBlock(null, dummyBlockParser.Object)
{
Line = dummyLine,
Column = dummyColumn,
Span = dummySpan
};
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <IFlexiVideoBlockOptions> mockFlexiVideoBlockOptions = _mockRepository.Create <IFlexiVideoBlockOptions>();
mockFlexiVideoBlockOptions.Setup(i => i.BlockName).Returns(dummyBlockName);
mockFlexiVideoBlockOptions.Setup(i => i.Src).Returns(dummySrc);
mockFlexiVideoBlockOptions.Setup(i => i.Type).Returns(dummyType);
mockFlexiVideoBlockOptions.Setup(i => i.Width).Returns(dummyWidth);
mockFlexiVideoBlockOptions.Setup(i => i.Height).Returns(dummyHeight);
mockFlexiVideoBlockOptions.Setup(i => i.Duration).Returns(dummyDuration);
mockFlexiVideoBlockOptions.Setup(i => i.GeneratePoster).Returns(dummyGeneratePoster);
mockFlexiVideoBlockOptions.Setup(i => i.Poster).Returns(dummyPoster);
mockFlexiVideoBlockOptions.Setup(i => i.EnableFileOperations).Returns(dummyEnableFileOperations);
mockFlexiVideoBlockOptions.Setup(i => i.Spinner).Returns(dummySpinner);
mockFlexiVideoBlockOptions.Setup(i => i.PlayIcon).Returns(dummyPlayIcon);
mockFlexiVideoBlockOptions.Setup(i => i.PauseIcon).Returns(dummyPauseIcon);
mockFlexiVideoBlockOptions.Setup(i => i.FullscreenIcon).Returns(dummyFullscreenIcon);
mockFlexiVideoBlockOptions.Setup(i => i.ExitFullscreenIcon).Returns(dummyExitFullscreenIcon);
mockFlexiVideoBlockOptions.Setup(i => i.ErrorIcon).Returns(dummyErrorIcon);
mockFlexiVideoBlockOptions.Setup(i => i.Attributes).Returns(dummyAttributes);
Mock <IFlexiVideoBlocksExtensionOptions> mockFlexiVideoBlocksExtensionOptions = _mockRepository.Create <IFlexiVideoBlocksExtensionOptions>();
mockFlexiVideoBlocksExtensionOptions.Setup(f => f.LocalMediaDirectory).Returns(dummyLocalMediaDirectory);
mockFlexiVideoBlocksExtensionOptions.Setup(f => f.MimeTypes).Returns(dummyMimeTypes);
Mock <IOptionsService <IFlexiVideoBlockOptions, IFlexiVideoBlocksExtensionOptions> > mockOptionsService = _mockRepository.
Create <IOptionsService <IFlexiVideoBlockOptions, IFlexiVideoBlocksExtensionOptions> >();
mockOptionsService.Setup(o => o.CreateOptions(dummyBlockProcessor, dummyProxyJsonBlock)).Returns((mockFlexiVideoBlockOptions.Object, mockFlexiVideoBlocksExtensionOptions.Object));
Mock <FlexiVideoBlockFactory> mockTestSubject = CreateMockFlexiVideoBlockFactory(optionsService: mockOptionsService.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ResolveBlockName(dummyBlockName)).Returns(dummyResolvedBlockName);
mockTestSubject.Protected().Setup <string>("ValidateSrcAndResolveFileName", mockFlexiVideoBlockOptions.Object).Returns(dummyFileName);
mockTestSubject.Setup(t => t.ResolveType(dummyFileName, dummyType, dummyMimeTypes)).Returns(dummyType);
mockTestSubject.
Setup(t => t.ResolveEnableFileOperations(dummyEnableFileOperations, dummyLocalMediaDirectory, dummyGeneratePoster, dummyPoster, dummyWidth, dummyHeight, dummyDuration)).
Returns(dummyResolvedEnableFileOperations);
mockTestSubject.Protected().Setup <string>("ResolveLocalAbsolutePath", false, dummyResolvedEnableFileOperations, dummyFileName, mockFlexiVideoBlocksExtensionOptions.Object).Returns(dummyLocalAbsolutePath);
mockTestSubject.
Setup(t => t.ResolveDimensionsAndDuration(dummyLocalAbsolutePath, dummyWidth, dummyHeight, dummyDuration)).
Returns((dummyResolvedWidth, dummyResolvedHeight, dummyAspectRatio, dummyResolvedDuration));
mockTestSubject.Setup(t => t.ResolvePoster(dummyLocalAbsolutePath, dummySrc, dummyPoster, dummyGeneratePoster)).Returns(dummyResolvedPoster);
// Act
FlexiVideoBlock result = mockTestSubject.Object.Create(dummyProxyJsonBlock, dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyResolvedBlockName, result.BlockName);
Assert.Equal(dummySrc, result.Src);
Assert.Equal(dummyType, result.Type);
Assert.Equal(dummyResolvedPoster, result.Poster);
Assert.Equal(dummyResolvedWidth, result.Width);
Assert.Equal(dummyResolvedHeight, result.Height);
Assert.Equal(dummyAspectRatio, result.AspectRatio);
Assert.Equal(dummyResolvedDuration, result.Duration);
Assert.Equal(dummySpinner, result.Spinner);
Assert.Equal(dummyPlayIcon, result.PlayIcon);
Assert.Equal(dummyPauseIcon, result.PauseIcon);
Assert.Equal(dummyFullscreenIcon, result.FullscreenIcon);
Assert.Equal(dummyExitFullscreenIcon, result.ExitFullscreenIcon);
Assert.Equal(dummyErrorIcon, result.ErrorIcon);
Assert.Equal(dummyAttributes, result.Attributes);
Assert.Same(dummyBlockParser.Object, result.Parser);
Assert.Equal(dummyColumn, result.Column);
Assert.Equal(dummyLine, result.Line);
Assert.Equal(dummySpan, result.Span);
}
/// <summary>
/// Creates a <see cref="FlexiVideoBlock"/>.
/// </summary>
/// <param name="proxyJsonBlock">The <see cref="ProxyJsonBlock"/> containing data for the <see cref="FlexiVideoBlock"/>.</param>
/// <param name="blockProcessor">The <see cref="BlockProcessor"/> processing the <see cref="FlexiVideoBlock"/>.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="proxyJsonBlock"/> is <c>null</c>.</exception>S
/// <exception cref="ArgumentNullException">Thrown if <paramref name="blockProcessor"/> is <c>null</c>.</exception>
/// <exception cref="OptionsException">Thrown if an option is invalid.</exception>
/// <exception cref="InvalidOperationException">Thrown if FFmpeg is not available.</exception>
/// <exception cref="InvalidOperationException">Thrown if an exception is thrown while attempting to run FFmpeg.</exception>
/// <exception cref="InvalidOperationException">Thrown if an FFmpeg run fails (exit code > 0).</exception>
/// <exception cref="InvalidOperationException">Thrown if metadata retrieved from the video is invalid.</exception>
public override FlexiVideoBlock Create(ProxyJsonBlock proxyJsonBlock, BlockProcessor blockProcessor)
{
(IFlexiVideoBlockOptions flexiVideoBlockOptions, IFlexiVideoBlocksExtensionOptions flexiVideoBlocksExtensionOptions) = _optionsService.
CreateOptions(blockProcessor, proxyJsonBlock);
// Block name
string blockName = ResolveBlockName(flexiVideoBlockOptions.BlockName);
// Src
string fileName = ValidateSrcAndResolveFileName(flexiVideoBlockOptions);
// Type
string type = ResolveType(fileName, flexiVideoBlockOptions.Type, flexiVideoBlocksExtensionOptions.MimeTypes);
// Enable file operations
double width = flexiVideoBlockOptions.Width;
double height = flexiVideoBlockOptions.Height;
double duration = flexiVideoBlockOptions.Duration;
bool generatePoster = flexiVideoBlockOptions.GeneratePoster;
string poster = flexiVideoBlockOptions.Poster;
bool enableFileOperations = ResolveEnableFileOperations(flexiVideoBlockOptions.EnableFileOperations,
flexiVideoBlocksExtensionOptions.LocalMediaDirectory,
generatePoster,
poster,
width,
height,
duration);
// Source local absolute path
string localAbsolutePath = ResolveLocalAbsolutePath(enableFileOperations,
fileName,
flexiVideoBlocksExtensionOptions);
// Dimensions and duration
(double resolvedWidth, double resolvedHeight, double aspectRatio, double resolvedDuration) = ResolveDimensionsAndDuration(localAbsolutePath, width, height, duration);
// Poster
string src = flexiVideoBlockOptions.Src;
string resolvedPoster = ResolvePoster(localAbsolutePath, src, poster, generatePoster);
// Create block
return(new FlexiVideoBlock(blockName,
src,
type,
resolvedPoster,
resolvedWidth,
resolvedHeight,
aspectRatio,
resolvedDuration,
flexiVideoBlockOptions.Spinner,
flexiVideoBlockOptions.PlayIcon,
flexiVideoBlockOptions.PauseIcon,
flexiVideoBlockOptions.FullscreenIcon,
flexiVideoBlockOptions.ExitFullscreenIcon,
flexiVideoBlockOptions.ErrorIcon,
flexiVideoBlockOptions.Attributes,
proxyJsonBlock.Parser)
{
Column = proxyJsonBlock.Column,
Line = proxyJsonBlock.Line,
Span = proxyJsonBlock.Span
});
}
