public void NormalizeCiteLinkIndex_ThrowsBlockExceptionIfCiteLinkIndexIsInvalid(int dummyNumLinks, int dummyCiteLinkIndex)
{
// Arrange
const int dummyLineIndex = 5;
const int dummyColumn = 2;
FlexiQuoteBlock dummyFlexiQuoteBlock = CreateFlexiQuoteBlock(citeLink: dummyCiteLinkIndex);
dummyFlexiQuoteBlock.Column = dummyColumn;
dummyFlexiQuoteBlock.Line = dummyLineIndex;
FlexiQuoteBlockFactory testSubject = CreateFlexiQuoteBlockFactory();
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => testSubject.NormalizeCiteLinkIndex(dummyNumLinks, dummyFlexiQuoteBlock));
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
nameof(FlexiQuoteBlock),
dummyLineIndex + 1,
dummyColumn,
Strings.BlockException_BlockException_ExceptionOccurredWhileProcessingBlock),
result.Message);
var resultOptionsException = result.InnerException as OptionsException;
Assert.IsType <OptionsException>(resultOptionsException);
Assert.Equal(string.Format(Strings.OptionsException_OptionsException_InvalidOption,
nameof(IFlexiQuoteBlockOptions.CiteLink),
string.Format(Strings.OptionsException_FlexiQuoteBlockFactory_UnableToNormalize, dummyCiteLinkIndex, dummyNumLinks)),
resultOptionsException.Message);
}
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 NormalizeCiteLinkIndex_NormalizesCiteLinkIndexIfSuccessful(int dummyNumLinks, int dummyCiteLinkIndex, int expectedCiteLinkIndex)
{
// Arrange
FlexiQuoteBlock dummyFlexiQuoteBlock = CreateFlexiQuoteBlock(citeLink: dummyCiteLinkIndex);
FlexiQuoteBlockFactory testSubject = CreateFlexiQuoteBlockFactory();
// Act
int result = testSubject.NormalizeCiteLinkIndex(dummyNumLinks, dummyFlexiQuoteBlock);
// Assert
Assert.Equal(expectedCiteLinkIndex, result);
}
public void WriteBlock_WritesBlock(FlexiQuoteBlock dummyFlexiQuoteBlock,
string expectedResult)
{
// Arrange
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter);
ExposedFlexiQuoteBlockRenderer testSubject = CreateExposedFlexiQuoteBlockRenderer();
// Act
testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiQuoteBlock);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal(expectedResult, result, ignoreLineEndingDifferences: true);
}
public void Create_CreatesFlexiQuoteBlock()
{
// Arrange
const int dummyColumn = 2;
var dummyLine = new StringSlice("dummyText", 3, 8);
const string dummyBlockName = "dummyBlockName";
const string dummyResolvedBlockName = "dummyResolvedBlockName";
const string dummyIcon = "dummyIcon";
const int dummyCiteLink = -3;
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 <IFlexiQuoteBlockOptions> mockFlexiQuoteBlockOptions = _mockRepository.Create <IFlexiQuoteBlockOptions>();
mockFlexiQuoteBlockOptions.Setup(f => f.BlockName).Returns(dummyBlockName);
mockFlexiQuoteBlockOptions.Setup(f => f.Icon).Returns(dummyIcon);
mockFlexiQuoteBlockOptions.Setup(f => f.CiteLink).Returns(dummyCiteLink);
mockFlexiQuoteBlockOptions.Setup(f => f.Attributes).Returns(dummyAttributes);
Mock <IOptionsService <IFlexiQuoteBlockOptions, IFlexiQuoteBlocksExtensionOptions> > mockOptionsService = _mockRepository.
Create <IOptionsService <IFlexiQuoteBlockOptions, IFlexiQuoteBlocksExtensionOptions> >();
mockOptionsService.Setup(f => f.CreateOptions(dummyBlockProcessor)).
Returns((mockFlexiQuoteBlockOptions.Object, (IFlexiQuoteBlocksExtensionOptions)null));
Mock <FlexiQuoteBlockFactory> mockTestSubject = CreateMockFlexiQuoteBlockFactory(mockOptionsService.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ResolveBlockName(dummyBlockName)).Returns(dummyResolvedBlockName);
// Act
FlexiQuoteBlock result = mockTestSubject.Object.Create(dummyBlockProcessor, dummyBlockParser.Object);
// TODO how can we verify that ProcessInlineEnd event handler is added? Due to language restrictions, no simple solution, got to get Block.OnProcessInlinesEnd to fire
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyResolvedBlockName, result.BlockName);
Assert.Equal(dummyIcon, result.Icon);
Assert.Equal(dummyCiteLink, result.CiteLink);
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(0, result.Span.End);
}
private static FlexiQuoteBlock CreateFlexiQuoteBlock(string blockName = default,
string icon = default,
int citeLink = default,
ReadOnlyDictionary <string, string> attributes = default,
BlockParser blockParser = default,
string citeUrl = default,
PlainContainerBlock quotePart = default,
PlainLeafBlock citationPart = default)
{
var result = new FlexiQuoteBlock(blockName, icon, citeLink, attributes, blockParser)
{
quotePart ?? new PlainContainerBlock(null), citationPart ?? new PlainLeafBlock(null)
};
result.CiteUrl = citeUrl;
return(result);
}
public void WriteBlock_OnlyWritesChildrenIfEnableHtmlForBlockIsFalse()
{
// Arrange
const string dummyQuote = "dummyQuote";
var dummyQuoteContainerInline = new ContainerInline();
dummyQuoteContainerInline.AppendChild(new LiteralInline(dummyQuote));
var dummyQuoteParagraphBlock = new ParagraphBlock()
{
Inline = dummyQuoteContainerInline
};
var dummyQuotePartBlock = new PlainContainerBlock(null);
dummyQuotePartBlock.Add(dummyQuoteParagraphBlock);
const string dummyCitation = "dummyCitation";
var dummyCitationContainerInline = new ContainerInline();
dummyCitationContainerInline.AppendChild(new LiteralInline(dummyCitation));
var dummyCitationPartBlock = new PlainLeafBlock(null);
dummyCitationPartBlock.Inline = dummyCitationContainerInline;
FlexiQuoteBlock dummyFlexiQuoteBlock = CreateFlexiQuoteBlock(quotePart: dummyQuotePartBlock, citationPart: dummyCitationPartBlock);
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter)
{
EnableHtmlForBlock = false
};
ExposedFlexiQuoteBlockRenderer testSubject = CreateExposedFlexiQuoteBlockRenderer();
// Act
testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiQuoteBlock);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal($"{dummyQuote}\n{dummyCitation}\n", result, ignoreLineEndingDifferences: true);
}
public void ExposedWriteBlock(HtmlRenderer htmlRenderer, FlexiQuoteBlock flexiQuoteBlock)
{
WriteBlock(htmlRenderer, flexiQuoteBlock);
}
