public void Undo_ReplacesProxyTableBlockWithAParagraphBlock()
{
// Arrange
const string dummyText = "dummyText";
var dummyProxyTableBlock = new ProxyTableBlock(null);
dummyProxyTableBlock.Lines = new StringLineGroup(dummyText);
BlockParser dummyBlockParser = _mockRepository.Create <BlockParser>().Object;
ContainerBlock dummyParent = _mockRepository.Create <ContainerBlock>(dummyBlockParser).Object; // Must specify block parser since we're calling ProcessLine later
dummyParent.Add(dummyProxyTableBlock); // Assigns dummyParent to dummyProxyTableBlock.Parent
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Open(dummyParent);
dummyBlockProcessor.Open(dummyProxyTableBlock);
ExposedFlexiTableBlockParser testSubject = CreateExposedFlexiTableBlockParser();
// Act
testSubject.ExposedUndo(dummyBlockProcessor, dummyProxyTableBlock);
// Assert
Assert.Single(dummyParent);
var resultParagraphBlock = dummyParent[0] as ParagraphBlock;
Assert.NotNull(resultParagraphBlock);
Assert.Equal(dummyText, resultParagraphBlock.Lines.ToString());
// Verify that ParagraphBlock remains open
dummyBlockProcessor.ProcessLine(new StringSlice(dummyText));
Assert.Equal($"{dummyText}\n{dummyText}", resultParagraphBlock.Lines.ToString());
}
public void CreateFlexiTableBlock_ThrowsOptionsExceptionIfTypeIsNotUnresponsiveAndTableHasMultipleHeaderRows(FlexiTableType dummyType,
Row[] dummyRows)
{
// Arrange
const int dummyNumColumns = 6;
var dummyColumnDefinitions = new List <ColumnDefinition>();
var dummyAttributes = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
var dummyProxyTableBlock = new ProxyTableBlock(null);
foreach (Row row in dummyRows)
{
dummyProxyTableBlock.Rows.Add(row);
}
dummyProxyTableBlock.ColumnDefinitions = dummyColumnDefinitions;
dummyProxyTableBlock.NumColumns = dummyNumColumns;
Mock <FlexiTableBlockFactory> mockTestSubject = CreateMockFlexiTableBlockFactory();
mockTestSubject.CallBase = true;
mockTestSubject.
Setup(t => t.CreateFlexiTableRowBlock(dummyType, It.IsAny <BlockProcessor>(), dummyColumnDefinitions, dummyNumColumns, 0, dummyRows[0], dummyRows[0].IsHeaderRow)).
Returns(new FlexiTableRowBlock(true));
// Act and assert
OptionsException result = Assert.Throws <OptionsException>(() => mockTestSubject.Object.CreateFlexiTableBlock(default, dummyType, dummyAttributes, dummyProxyTableBlock, dummyBlockProcessor));
public void Create_CreatesFlexiSectionBlockAndUpdatesOpenFlexiSectionBlocks()
{
// Arrange
var dummyLine = new StringSlice("dummyLine", 4, 8);
const int dummyColumn = 4;
const string dummyBlockName = "dummyBlockName";
const string dummyResolvedBlockName = "dummyResolvedBlockName";
const SectioningContentElement dummyElement = SectioningContentElement.Aside;
const string dummyLinkIcon = "dummyLinkIcon";
const FlexiSectionBlockRenderingMode dummyRenderingMode = FlexiSectionBlockRenderingMode.Classic;
const int dummyLevel = 5;
var dummyAttributes = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
Mock <IFlexiSectionBlockOptions> dummyFlexiSectionBlockOptions = _mockRepository.Create <IFlexiSectionBlockOptions>();
dummyFlexiSectionBlockOptions.Setup(f => f.BlockName).Returns(dummyBlockName);
dummyFlexiSectionBlockOptions.Setup(f => f.Element).Returns(dummyElement);
dummyFlexiSectionBlockOptions.Setup(f => f.RenderingMode).Returns(dummyRenderingMode);
dummyFlexiSectionBlockOptions.Setup(f => f.LinkIcon).Returns(dummyLinkIcon);
dummyFlexiSectionBlockOptions.Setup(f => f.Attributes).Returns(dummyAttributes);
Mock <BlockParser> dummyBlockParser = _mockRepository.Create <BlockParser>();
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Column = dummyColumn;
dummyBlockProcessor.Line = dummyLine;
var dummyFlexiSectionHeadingBlock = new FlexiSectionHeadingBlock(null);
Mock <IFlexiSectionHeadingBlockFactory> mockFlexiSectionHeadingBlockFactory = _mockRepository.Create <IFlexiSectionHeadingBlockFactory>();
mockFlexiSectionHeadingBlockFactory.
Setup(f => f.Create(dummyBlockProcessor, dummyFlexiSectionBlockOptions.Object, dummyBlockParser.Object)).
Returns(dummyFlexiSectionHeadingBlock);
Mock <IOptionsService <IFlexiSectionBlockOptions, IFlexiSectionBlocksExtensionOptions> > mockOptionsService = _mockRepository.Create <IOptionsService <IFlexiSectionBlockOptions, IFlexiSectionBlocksExtensionOptions> >();
mockOptionsService.Setup(o => o.CreateOptions(dummyBlockProcessor)).Returns((dummyFlexiSectionBlockOptions.Object, null));
Mock <FlexiSectionBlockFactory> mockTestSubject = CreateMockFlexiSectionBlockFactory(mockOptionsService.Object, mockFlexiSectionHeadingBlockFactory.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ValidateLevel(dummyLevel));
mockTestSubject.Setup(t => t.ResolveBlockName(dummyBlockName)).Returns(dummyResolvedBlockName);
mockTestSubject.Setup(t => t.ValidateElement(dummyElement));
mockTestSubject.Setup(t => t.ValidateRenderingMode(dummyRenderingMode));
mockTestSubject.Setup(t => t.UpdateOpenFlexiSectionBlocks(dummyBlockProcessor, It.IsAny <FlexiSectionBlock>()));
// Act
FlexiSectionBlock result = mockTestSubject.Object.Create(dummyLevel, dummyBlockProcessor, dummyBlockParser.Object);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyResolvedBlockName, result.BlockName);
Assert.Equal(dummyElement, result.Element);
Assert.Equal(dummyLinkIcon, result.LinkIcon);
Assert.Equal(dummyRenderingMode, result.RenderingMode);
Assert.Equal(dummyLevel, result.Level);
Assert.Same(dummyAttributes, result.Attributes);
Assert.Same(dummyBlockParser.Object, result.Parser);
Assert.Equal(dummyColumn, result.Column);
Assert.Equal(dummyLine.Start, result.Span.Start);
Assert.Equal(dummyLine.End, result.Span.End);
Assert.Single(result);
Assert.Same(dummyFlexiSectionHeadingBlock, result[0]);
}
public void ExtractCiteUrl_ExtractsCiteUrlIfSuccessful()
{
// Arrange
const string dummyUrl = "dummyLink";
var dummyAuthorLinkInline = new LinkInline();
var dummyCiteLinkInline = new LinkInline(dummyUrl, null);
var dummyContainerInline = new ContainerInline();
dummyContainerInline.
AppendChild(dummyAuthorLinkInline).
AppendChild(dummyCiteLinkInline);
LeafBlock dummyCitationBlock = _mockRepository.Create <LeafBlock>(null).Object;
InlineProcessor dummyInlineProcessor = MarkdigTypesFactory.CreateInlineProcessor();
dummyInlineProcessor.ProcessInlineLeaf(dummyCitationBlock); // Sets InlineProcessor.Block to dummyCitationBlock
dummyCitationBlock.Inline = dummyContainerInline; // Replace container created in ProcessInlineLeaf
FlexiQuoteBlock dummyFlexiQuoteBlock = CreateFlexiQuoteBlock();
dummyFlexiQuoteBlock.Add(dummyCitationBlock);
Mock <FlexiQuoteBlockFactory> mockTestSubject = CreateMockFlexiQuoteBlockFactory();
mockTestSubject.Setup(m => m.NormalizeCiteLinkIndex(2, dummyFlexiQuoteBlock)).Returns(1);
// Act
mockTestSubject.Object.ExtractCiteUrl(dummyInlineProcessor, null);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyUrl, dummyFlexiQuoteBlock.CiteUrl);
}
public void CreateProxyFencedBlock_CreatesProxyFencedBlock()
{
// Arrange
const int dummyOpeningFenceIndent = 5;
const int dummyOpeningFenceCharCount = 6;
const int dummyColumn = 2;
const int dummyLineStart = 7;
const int dummyLineEnd = 99;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Column = dummyColumn;
dummyBlockProcessor.Line = new StringSlice("", dummyLineStart, dummyLineEnd);
Mock <BlockParser> dummyBlockParser = _mockRepository.Create <BlockParser>();
FlexiCodeBlockFactory testSubject = CreateFlexiCodeBlockFactory();
// Act
ProxyFencedLeafBlock result = testSubject.CreateProxyFencedBlock(dummyOpeningFenceIndent,
dummyOpeningFenceCharCount,
dummyBlockProcessor,
dummyBlockParser.Object);
// Assert
Assert.Equal(dummyOpeningFenceIndent, result.OpeningFenceIndent);
Assert.Equal(dummyOpeningFenceCharCount, result.OpeningFenceCharCount);
Assert.Equal(dummyColumn, result.Column);
Assert.Equal(dummyLineStart, result.Span.Start);
Assert.Equal(dummyLineEnd, result.Span.End);
Assert.Same(dummyBlockParser.Object, result.Parser);
Assert.Equal(nameof(FlexiCodeBlock), result.MainTypeName);
}
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 Create_CreateFlexiSectionHeadingBlock()
{
// Arrange
const int dummyColumn = 12;
const int dummyLineIndex = 5;
var dummyLine = new StringSlice("dummyLine", 4, 8);
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = dummyLine;
dummyBlockProcessor.LineIndex = dummyLineIndex;
dummyBlockProcessor.Column = dummyColumn;
Mock <BlockParser> dummyBlockParser = _mockRepository.Create <BlockParser>();
Mock <IFlexiSectionBlockOptions> dummyFlexiSectionBlockOptions = _mockRepository.Create <IFlexiSectionBlockOptions>();
Mock <FlexiSectionHeadingBlockFactory> mockTestSubject = CreateMockFlexiSectionHeadingBlockFactory();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.SetupIDGenerationAndReferenceLinking(It.IsAny <FlexiSectionHeadingBlock>(),
dummyFlexiSectionBlockOptions.Object,
dummyBlockProcessor));
// Act
FlexiSectionHeadingBlock result = mockTestSubject.Object.Create(dummyBlockProcessor, dummyFlexiSectionBlockOptions.Object, dummyBlockParser.Object);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyColumn, result.Column);
Assert.Equal(dummyLine.Start, result.Span.Start);
Assert.Equal(dummyLine.End, result.Span.End);
Assert.Equal(dummyLineIndex, result.Line);
Assert.Equal(dummyLine.ToString(), result.Lines.ToString());
}
public void TryOpenBlock_ThrowsBlockExceptionIfAnExceptionIsThrownWhileCreatingTheBlock()
{
// Arrange
const int dummyLineIndex = 6;
const int dummyColumn = 3;
const int dummyLevel = 1;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice("# Dummy");
dummyBlockProcessor.LineIndex = dummyLineIndex;
dummyBlockProcessor.Column = dummyColumn;
Mock <IFlexiSectionBlockFactory> mockFlexiSectionBlockFactory = _mockRepository.Create <IFlexiSectionBlockFactory>();
var dummyOptionsException = new OptionsException();
Mock <ExposedFlexiSectionBlockParser> mockTestSubject = CreateMockExposedFlexiSectionBlockParser(mockFlexiSectionBlockFactory.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.DiscardRedundantCharacters(dummyLevel, dummyBlockProcessor));
mockFlexiSectionBlockFactory.Setup(f => f.Create(dummyLevel, dummyBlockProcessor, mockTestSubject.Object)).Throws(dummyOptionsException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.ExposedTryOpenBlock(dummyBlockProcessor));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
nameof(FlexiSectionBlock),
dummyLineIndex + 1,
dummyColumn,
Strings.BlockException_Shared_ExceptionOccurredWhileCreatingBlock),
result.Message);
Assert.Same(dummyOptionsException, result.InnerException);
}
public void DocumentOnProcessInlinesBegin_CreatesAndAddsALinkReferenceDefinitionForEachReferenceLinkableFlexiFigureBlock()
{
// Arrange
const string dummyLinkLabelContent = "dummyLinkLabelContent";
const string dummyID = "dummyID";
const string dummyName = "dummyName";
FlexiFigureBlock dummyFlexiFigureBlock = CreateFlexiFigureBlock(name: dummyName, linkLabelContent: dummyLinkLabelContent, id: dummyID);
InlineProcessor dummyInlineProcessor = MarkdigTypesFactory.CreateInlineProcessor();
dummyInlineProcessor.Document.SetData(FlexiFigureBlockFactory.REFERENCE_LINKABLE_FLEXI_FIGURE_BLOCKS_KEY, new List <FlexiFigureBlock> {
dummyFlexiFigureBlock
});
FlexiFigureBlockFactory testSubject = CreateFlexiFigureBlockFactory();
// Act
testSubject.DocumentOnProcessInlinesBegin(dummyInlineProcessor, null);
// Assert
Dictionary <string, LinkReferenceDefinition> linkReferenceDefinitions = (dummyInlineProcessor.Document.GetData(typeof(LinkReferenceDefinitionGroup)) as LinkReferenceDefinitionGroup)?.Links;
Assert.Single(linkReferenceDefinitions);
LinkReferenceDefinition resultLinkReferenceDefinition = linkReferenceDefinitions.Values.First();
Assert.Equal(dummyLinkLabelContent, resultLinkReferenceDefinition.Label);
Assert.Equal($"#{dummyID}", resultLinkReferenceDefinition.Url);
Assert.Equal(dummyName, resultLinkReferenceDefinition.Title);
}
public void DocumentOnProcessInlinesBegin_DoesNotReplaceExistingLinkReferenceDefinitions()
{
// Arrange
const string dummyLinkLabelContent = "dummyLinkLabelContent";
InlineProcessor dummyInlineProcessor = MarkdigTypesFactory.CreateInlineProcessor();
FlexiFigureBlock dummyFlexiFigureBlock = CreateFlexiFigureBlock(linkLabelContent: dummyLinkLabelContent);
dummyInlineProcessor.Document.SetData(FlexiFigureBlockFactory.REFERENCE_LINKABLE_FLEXI_FIGURE_BLOCKS_KEY,
new List <FlexiFigureBlock> {
dummyFlexiFigureBlock
});
var dummyLinkReferenceDefinition = new LinkReferenceDefinition();
dummyInlineProcessor.Document.SetLinkReferenceDefinition(dummyLinkLabelContent, dummyLinkReferenceDefinition);
FlexiFigureBlockFactory testSubject = CreateFlexiFigureBlockFactory();
// Act
testSubject.DocumentOnProcessInlinesBegin(dummyInlineProcessor, null);
// Assert
Dictionary <string, LinkReferenceDefinition> linkReferenceDefinitions =
(dummyInlineProcessor.Document.GetData(typeof(LinkReferenceDefinitionGroup)) as LinkReferenceDefinitionGroup)?.Links;
Assert.Single(linkReferenceDefinitions);
Assert.Same(dummyLinkReferenceDefinition, linkReferenceDefinitions.Values.First()); // Doesn't get replaced
}
public void TryContinueBlock_UndoesProxyTableBlockAndReturnsBlockStateBreakIfColumnDefinitionsIsAlreadyDefinedAndLineIsNotAValidRowLine()
{
// Arrange
const int dummyNumColumns = 8;
const int dummyNumRows = 4;
var dummyColumnDefinitions = new List <ColumnDefinition>();
var dummyProxyTableBlock = new ProxyTableBlock(null);
for (int i = 0; i < dummyNumRows; i++)
{
dummyProxyTableBlock.Rows.Add(new Row());
}
dummyProxyTableBlock.NumColumns = dummyNumColumns;
dummyProxyTableBlock.ColumnDefinitions = dummyColumnDefinitions;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice("|");
Mock <ExposedBasicFlexiTableBlockParser> mockTestSubject = CreateMockExposedBasicFlexiTableBlockParser();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.TryParseRowLine(dummyBlockProcessor, dummyNumRows, dummyNumColumns)).Returns((Row)null);
mockTestSubject.Protected().Setup("Undo", dummyBlockProcessor, dummyProxyTableBlock);
// Act
BlockState result = mockTestSubject.Object.ExposedTryContinueBlock(dummyBlockProcessor, dummyProxyTableBlock);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(BlockState.Break, result);
}
public void TryContinueBlock_UndoesProxyTableBlockAndReturnsBlockStateBreakIfLineIsNeitherAValidColumnDefinitionsLineNorAValidRowLine()
{
// Arrange
const string dummyText = "| dummyText";
const int dummyNumColumns = 8;
const int dummyNumRows = 4;
var dummyProxyTableBlock = new ProxyTableBlock(null);
for (int i = 0; i < dummyNumRows; i++)
{
dummyProxyTableBlock.Rows.Add(new Row());
}
dummyProxyTableBlock.NumColumns = dummyNumColumns;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(dummyText);
Mock <ExposedBasicFlexiTableBlockParser> mockTestSubject = CreateMockExposedBasicFlexiTableBlockParser();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.TryParseRowLine(dummyBlockProcessor, dummyNumRows, dummyNumColumns)).Returns((Row)null);
mockTestSubject.
Protected().
Setup <List <ColumnDefinition> >("TryParseColumnDefinitionsLine", ItExpr.Is <StringSlice>(line => line.Text == dummyText), '|', dummyNumColumns).
Returns((List <ColumnDefinition>)null);
mockTestSubject.Protected().Setup("Undo", dummyBlockProcessor, dummyProxyTableBlock);
// Act
BlockState result = mockTestSubject.Object.ExposedTryContinueBlock(dummyBlockProcessor, dummyProxyTableBlock);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(BlockState.Break, result);
}
public void TryContinueBlock_ReturnsBlockStateContinueDiscardIfColumnDefinitionsHasBeenDefinedAndTheCurrentLineIsAValidRowLine()
{
// Arrange
const string dummyText = "| dummyText";
const int dummyNumColumns = 8;
const int dummyNumRows = 4;
var dummyColumnDefinitions = new List <ColumnDefinition>();
var dummyProxyTableBlock = new ProxyTableBlock(null);
for (int i = 0; i < dummyNumRows; i++)
{
dummyProxyTableBlock.Rows.Add(new Row());
}
dummyProxyTableBlock.NumColumns = dummyNumColumns;
dummyProxyTableBlock.ColumnDefinitions = dummyColumnDefinitions;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(dummyText);
var dummyRow = new Row();
Mock <ExposedBasicFlexiTableBlockParser> mockTestSubject = CreateMockExposedBasicFlexiTableBlockParser();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.TryParseRowLine(dummyBlockProcessor, dummyNumRows, dummyNumColumns)).Returns(dummyRow);
// Act
BlockState result = mockTestSubject.Object.ExposedTryContinueBlock(dummyBlockProcessor, dummyProxyTableBlock);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyProxyTableBlock.Span.End, dummyText.Length - 1); // Block span end is updated
Assert.Same(dummyProxyTableBlock.Rows.Last(), dummyRow);
Assert.Equal(dummyText, dummyProxyTableBlock.Lines.ToString());
Assert.Equal(BlockState.ContinueDiscard, result);
}
public void Create_CreatesFlexiTableBlock()
{
// Arrange
const string dummyBlockName = "dummyBlockName";
const string dummyResolvedBlockName = "dummyResolvedBlockName";
const FlexiTableType dummyType = FlexiTableType.FixedTitles;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
var dummyAttributes = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
Mock <IFlexiTableBlockOptions> mockFlexiTableBlockOptions = _mockRepository.Create <IFlexiTableBlockOptions>();
mockFlexiTableBlockOptions.Setup(f => f.BlockName).Returns(dummyBlockName);
mockFlexiTableBlockOptions.Setup(f => f.Type).Returns(dummyType);
mockFlexiTableBlockOptions.Setup(f => f.Attributes).Returns(dummyAttributes);
Mock <IOptionsService <IFlexiTableBlockOptions, IFlexiTableBlocksExtensionOptions> > mockOptionsService = _mockRepository.
Create <IOptionsService <IFlexiTableBlockOptions, IFlexiTableBlocksExtensionOptions> >();
mockOptionsService.Setup(f => f.CreateOptions(dummyBlockProcessor)).
Returns((mockFlexiTableBlockOptions.Object, null));
var dummyProxyTableBlock = new ProxyTableBlock(null);
FlexiTableBlock dummyFlexiTableBlock = CreateFlexiTableBlock();
Mock <FlexiTableBlockFactory> mockTestSubject = CreateMockFlexiTableBlockFactory(mockOptionsService.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ResolveBlockName(dummyBlockName)).Returns(dummyResolvedBlockName);
mockTestSubject.Setup(t => t.ValidateType(dummyType));
mockTestSubject.Setup(t => t.CreateFlexiTableBlock(dummyResolvedBlockName, dummyType, dummyAttributes, dummyProxyTableBlock, dummyBlockProcessor)).Returns(dummyFlexiTableBlock);
// Act
FlexiTableBlock result = mockTestSubject.Object.Create(dummyProxyTableBlock, dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
}
public void Create_ThrowsBlockExceptionIfThereIsAnUnconsumedFlexiOptionsBlock()
{
// Arrange
const int dummyLineIndex = 1;
const int dummyColumn = 2;
var dummyPendingFlexiOptionsBlock = new FlexiOptionsBlock(null)
{
Line = dummyLineIndex,
Column = dummyColumn
};
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Document.SetData(FlexiOptionsBlockFactory.PENDING_FLEXI_OPTIONS_BLOCK, dummyPendingFlexiOptionsBlock);
FlexiOptionsBlockFactory testSubject = CreateFlexiOptionsBlockFactory();
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => testSubject.Create(new ProxyJsonBlock(null, null), dummyBlockProcessor));
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
nameof(FlexiOptionsBlock),
dummyLineIndex + 1,
dummyColumn,
Strings.BlockException_FlexiOptionsBlockParser_UnconsumedBlock),
result.Message);
}
public void UpdateOpenFlexiSectionBlocks_DiscardsStacksForClosedTreesAndCreatesANewStackForANewTree()
{
// Arrange
var dummyCurrentBranch = new Stack <FlexiSectionBlock>();
dummyCurrentBranch.Push(CreateFlexiSectionBlock());
FlexiSectionBlock dummyClosedFlexiSectionBlock = CreateFlexiSectionBlock();
dummyClosedFlexiSectionBlock.IsOpen = false;
var dummyClosedBranchStack = new Stack <FlexiSectionBlock>();
dummyClosedBranchStack.Push(dummyClosedFlexiSectionBlock);
var dummyOpenSectionBlocks = new Stack <Stack <FlexiSectionBlock> >();
dummyOpenSectionBlocks.Push(dummyCurrentBranch);
dummyOpenSectionBlocks.Push(dummyClosedBranchStack);
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.ProcessLine(new StringSlice("")); // This line sets BlockProcessor.CurrentContainer to a MarkdownDocument
FlexiSectionBlock dummyNewFlexiSectionBlock = CreateFlexiSectionBlock();
Mock <FlexiSectionBlockFactory> mockTestSubject = CreateMockFlexiSectionBlockFactory();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.GetOrCreateOpenFlexiSectionBlocks(dummyBlockProcessor.Document)).Returns(dummyOpenSectionBlocks);
// Act
mockTestSubject.Object.UpdateOpenFlexiSectionBlocks(dummyBlockProcessor, dummyNewFlexiSectionBlock);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(2, dummyOpenSectionBlocks.Count); // Closed tree removed, open tree remains, new tree added
Assert.Same(dummyNewFlexiSectionBlock, dummyOpenSectionBlocks.Pop().Peek());
Assert.Same(dummyCurrentBranch, dummyOpenSectionBlocks.Peek());
}
public void CreateFlexiTableBlock_CreatesFlexiTableBlock(FlexiTableType dummyType,
Row[] dummyRows)
{
// Arrange
const int dummyNumColumns = 6;
const int dummyColumn = 4;
const int dummyLine = 5;
const int dummyLineStart = 3;
const int dummyLineEnd = 10;
const string dummyBlockName = "dummyBlockName";
BlockParser dummyBlockParser = _mockRepository.Create <BlockParser>().Object;
var dummyColumnDefinitions = new List <ColumnDefinition>();
var dummyAttributes = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
var dummyProxyTableBlock = new ProxyTableBlock(dummyBlockParser);
dummyProxyTableBlock.Column = dummyColumn;
dummyProxyTableBlock.Line = dummyLine;
dummyProxyTableBlock.Span = new SourceSpan(dummyLineStart, dummyLineEnd);
foreach (Row row in dummyRows)
{
dummyProxyTableBlock.Rows.Add(row);
}
dummyProxyTableBlock.ColumnDefinitions = dummyColumnDefinitions;
dummyProxyTableBlock.NumColumns = dummyNumColumns;
var dummyFlexiTableRowBlock1 = new FlexiTableRowBlock(false);
var dummyFlexiTableRowBlock2 = new FlexiTableRowBlock(false);
var dummyFlexiTableRowBlock3 = new FlexiTableRowBlock(false);
Mock <FlexiTableBlockFactory> mockTestSubject = CreateMockFlexiTableBlockFactory();
mockTestSubject.CallBase = true;
mockTestSubject.
Setup(t => t.CreateFlexiTableRowBlock(dummyType, It.IsAny <BlockProcessor>(), dummyColumnDefinitions, dummyNumColumns, 0, dummyRows[0], dummyRows[0].IsHeaderRow)).
Returns(dummyFlexiTableRowBlock1);
mockTestSubject.
Setup(t => t.CreateFlexiTableRowBlock(dummyType, It.IsAny <BlockProcessor>(), dummyColumnDefinitions, dummyNumColumns, 1, dummyRows[1], dummyRows[1].IsHeaderRow)).
Returns(dummyFlexiTableRowBlock2);
mockTestSubject.
Setup(t => t.CreateFlexiTableRowBlock(dummyType, It.IsAny <BlockProcessor>(), dummyColumnDefinitions, dummyNumColumns, 2, dummyRows[2], dummyRows[2].IsHeaderRow)).
Returns(dummyFlexiTableRowBlock3);
// Act
FlexiTableBlock result = mockTestSubject.Object.CreateFlexiTableBlock(dummyBlockName, dummyType, dummyAttributes, dummyProxyTableBlock, dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyBlockName, result.BlockName);
Assert.Equal(dummyType, result.Type);
Assert.Same(dummyAttributes, result.Attributes);
Assert.Same(dummyBlockParser, result.Parser);
Assert.Equal(dummyColumn, result.Column);
Assert.Equal(dummyLine, result.Line);
Assert.Equal(dummyLineStart, result.Span.Start);
Assert.Equal(dummyLineEnd, result.Span.End);
Assert.Equal(3, result.Count);
Assert.Same(dummyFlexiTableRowBlock1, result[0]);
Assert.Same(dummyFlexiTableRowBlock2, result[1]);
Assert.Same(dummyFlexiTableRowBlock3, result[2]);
}
public void Create_ThrowsArgumentNullExceptionIfProxyJsonBlockIsNull()
{
// Arrange
FlexiOptionsBlockFactory testSubject = CreateFlexiOptionsBlockFactory();
// Act and assert
Assert.Throws <ArgumentNullException>(() => testSubject.Create(null, MarkdigTypesFactory.CreateBlockProcessor()));
}
public void CreateCore_ThrowsArgumentNullExceptionIfProxyLeafBlockIsNull()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
FlexiCodeBlockFactory testSubject = CreateFlexiCodeBlockFactory();
// Act and assert
Assert.Throws <ArgumentNullException>(() => testSubject.CreateCore(null, dummyBlockProcessor));
}
public void Undo_ThrowsArgumentNullExceptionIfProxyTableBlockIsNull()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
ExposedFlexiTableBlockParser testSubject = CreateExposedFlexiTableBlockParser();
// Act and assert
Assert.Throws <ArgumentNullException>(() => testSubject.ExposedUndo(dummyBlockProcessor, null));
}
public void ExtractCiteUrl_DoesNothingIfThereAreNoLinkInlinesInCitationBlock()
{
// Arrange
LeafBlock dummyCitationBlock = _mockRepository.Create <LeafBlock>(null).Object;
InlineProcessor dummyInlineProcessor = MarkdigTypesFactory.CreateInlineProcessor();
dummyInlineProcessor.ProcessInlineLeaf(dummyCitationBlock); // Sets InlineProcessor.Block to dummyCitationBlock
FlexiQuoteBlockFactory testSubject = CreateFlexiQuoteBlockFactory();
// Act and assert
testSubject.ExtractCiteUrl(dummyInlineProcessor, null); // If this doesn't throw, we never attempted to extract cite URL
}
public void Create_CreatesFlexiAlertBlock()
{
// Arrange
const int dummyColumn = 2;
var dummyLine = new StringSlice("dummyText", 3, 8);
const string dummyBlockName = "dummyBlockName";
const string dummyResolvedBlockName = "dummyResolvedBlockName";
const string dummyType = "dummyType";
const string dummyResolvedType = "dummyResolvedType";
const string dummyIcon = "dummyIcon";
const string dummyResolvedIcon = "dummyResolvedIcon";
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Column = dummyColumn;
dummyBlockProcessor.Line = dummyLine;
Mock <BlockParser> dummyBlockParser = _mockRepository.Create <BlockParser>();
var dummyAttributes = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
Mock <IFlexiAlertBlockOptions> mockFlexiAlertBlockOptions = _mockRepository.Create <IFlexiAlertBlockOptions>();
mockFlexiAlertBlockOptions.Setup(f => f.BlockName).Returns(dummyBlockName);
mockFlexiAlertBlockOptions.Setup(f => f.Type).Returns(dummyType);
mockFlexiAlertBlockOptions.Setup(f => f.Icon).Returns(dummyIcon);
mockFlexiAlertBlockOptions.Setup(f => f.Attributes).Returns(dummyAttributes);
var dummyIcons = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
Mock <IFlexiAlertBlocksExtensionOptions> mockFlexiAlertBlockExtensionOptions = _mockRepository.Create <IFlexiAlertBlocksExtensionOptions>();
mockFlexiAlertBlockExtensionOptions.Setup(f => f.Icons).Returns(dummyIcons);
Mock <IOptionsService <IFlexiAlertBlockOptions, IFlexiAlertBlocksExtensionOptions> > mockOptionsService = _mockRepository.
Create <IOptionsService <IFlexiAlertBlockOptions, IFlexiAlertBlocksExtensionOptions> >();
mockOptionsService.Setup(f => f.CreateOptions(dummyBlockProcessor)).
Returns((mockFlexiAlertBlockOptions.Object, mockFlexiAlertBlockExtensionOptions.Object));
Mock <FlexiAlertBlockFactory> mockTestSubject = CreateMockFlexiAlertBlockFactory(mockOptionsService.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ResolveBlockName(dummyBlockName)).Returns(dummyResolvedBlockName);
mockTestSubject.Setup(t => t.ResolveType(dummyType)).Returns(dummyResolvedType);
mockTestSubject.Setup(t => t.ResolveIcon(dummyIcon, dummyResolvedType, dummyIcons)).Returns(dummyResolvedIcon);
// Act
FlexiAlertBlock result = mockTestSubject.Object.Create(dummyBlockProcessor, dummyBlockParser.Object);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyResolvedBlockName, result.BlockName);
Assert.Equal(dummyResolvedType, result.Type);
Assert.Equal(dummyResolvedIcon, result.Icon);
Assert.Same(dummyAttributes, result.Attributes);
Assert.Same(dummyBlockParser.Object, result.Parser);
Assert.Equal(dummyColumn, result.Column);
Assert.Equal(dummyLine.Start, result.Span.Start);
Assert.Equal(dummyLine.End, result.Span.End);
}
public static IEnumerable <object[]> GetFlexiFigureBlockNumber_IfThereIsNoStoredNumberReturnsOneAndStoresTwo_Data()
{
BlockProcessor dummyBlockProcessorWithNonIntNextNumber = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessorWithNonIntNextNumber.Document.SetData(FlexiFigureBlockFactory.NEXT_FLEXI_FIGURE_BLOCK_NUMBER_KEY, new object());
return(new object[][]
{
new object[] { MarkdigTypesFactory.CreateBlockProcessor() }, // No next number
new object[] { dummyBlockProcessorWithNonIntNextNumber }
});
}
public void TryGetContextObjectsStore_ReturnsNullIfThereAreNoGlobalParsers()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor(blockParsers: new BlockParserList(new BlockParser[0]));
ContextObjectsService testSubject = CreateContextObjectsService();
// Act
ContextObjectsStore result = testSubject.TryGetContextObjectsStore(dummyBlockProcessor);
// Assert
Assert.Null(result);
}
public void TryGetContextObjectsStore_ReturnsNullIfNoGlobalParserIsAContextObjectsStore()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor(); // Several global parsers registered by default
ContextObjectsService testSubject = CreateContextObjectsService();
// Act
ContextObjectsStore result = testSubject.TryGetContextObjectsStore(dummyBlockProcessor);
// Assert
Assert.Null(result);
}
public void ParseLine_ReturnsBlockStateNoneIfCurrentLineDoesNotBeginWithExclamationMarkAndIsNotBlank()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice("dummyString");
ExposedFlexiAlertBlockParser testSubject = CreateExposedFlexiAlertBlockParser();
// Act
BlockState result = testSubject.ParseLine(dummyBlockProcessor, null);
// Assert
Assert.Equal(BlockState.None, result);
}
public void ParseLine_ReturnsBlockStateNoneIfCurrentLineHasCodeIndent()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Column = 4; // IsCodeIndent is an expression bodied member that derives its value from Column
ExposedFlexiAlertBlockParser testSubject = CreateExposedFlexiAlertBlockParser();
// Act
BlockState result = testSubject.ParseLine(dummyBlockProcessor, null);
// Assert
Assert.Equal(BlockState.None, result);
}
public void ParseLine_ReturnsBlockStateBreakDiscardIfCurrentLineIsBlank()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(string.Empty);
ExposedFlexiAlertBlockParser testSubject = CreateExposedFlexiAlertBlockParser();
// Act
BlockState result = testSubject.ParseLine(dummyBlockProcessor, null);
// Assert
Assert.Equal(BlockState.BreakDiscard, result);
}
public void TryOpenBlock_ReturnsBlockStateNoneIfLineDoesNotStartWithTheExpectedCharacters(string dummyLineText)
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(dummyLineText);
ExposedFlexiSectionBlockParser testSubject = CreateExposedFlexiSectionBlockParser();
// Act
BlockState result = testSubject.ExposedTryOpenBlock(dummyBlockProcessor);
// Assert
Assert.Equal(BlockState.None, result);
}
public void TryGetContextObjectsStore_ReturnsContextObjectsStoreIfItExists()
{
// Arrange
var dummyContextObjectsStore = new ContextObjectsStore();
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor(blockParsers: new BlockParserList(new BlockParser[] { dummyContextObjectsStore }));
ContextObjectsService testSubject = CreateContextObjectsService();
// Act
ContextObjectsStore result = testSubject.TryGetContextObjectsStore(dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Same(dummyContextObjectsStore, result);
}
