public void WriteBlock_OnlyWritesChildrenIfEnableHtmlForBlockIsFalse()
{
// Arrange
const string dummyChildText = "dummyChildText";
var dummyContainerInline = new ContainerInline();
dummyContainerInline.AppendChild(new LiteralInline(dummyChildText));
var dummyParagraphBlock = new ParagraphBlock()
{
Inline = dummyContainerInline
};
FlexiAlertBlock dummyFlexiAlertBlock = CreateFlexiAlertBlock();
dummyFlexiAlertBlock.Add(dummyParagraphBlock);
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter)
{
EnableHtmlForBlock = false
};
ExposedFlexiAlertBlockRenderer testSubject = CreateExposedFlexiAlertBlockRenderer();
// Act
testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiAlertBlock);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal(dummyChildText + "\n", result, ignoreLineEndingDifferences: true);
}
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 void WriteBlock_WritesBlock(FlexiAlertBlock dummyFlexiAlertBlock,
string expectedResult)
{
// Arrange
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter);
ExposedFlexiAlertBlockRenderer testSubject = CreateExposedFlexiAlertBlockRenderer();
// Act
testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiAlertBlock);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal(expectedResult, result, ignoreLineEndingDifferences: true);
}
public void TryContinueBlock_ParsesLine()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
FlexiAlertBlock dummyFlexiAlertBlock = CreateFlexiAlertBlock();
const BlockState dummyBlockState = BlockState.Continue;
Mock <ExposedFlexiAlertBlockParser> mockTestSubject = CreateMockExposedFlexiAlertBlockParser();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.ParseLine(dummyBlockProcessor, dummyFlexiAlertBlock)).Returns(dummyBlockState);
// Act
BlockState result = mockTestSubject.Object.ExposedTryContinueBlock(dummyBlockProcessor, dummyFlexiAlertBlock);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(dummyBlockState, result);
}
public void ParseLine_UpdatesFlexiAlertBlockAndReturnsBlockStateContinueIfFlexiAlertBlockCanBeContinued()
{
// Arrange
var dummyLine = new StringSlice("! dummyLine");
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = dummyLine;
FlexiAlertBlock dummyFlexiAlertBlock = CreateFlexiAlertBlock();
ExposedFlexiAlertBlockParser testSubject = CreateExposedFlexiAlertBlockParser();
// Act
BlockState result = testSubject.ParseLine(dummyBlockProcessor, dummyFlexiAlertBlock);
// Assert
Assert.Equal(BlockState.Continue, result);
Assert.Equal(dummyLine.End, dummyFlexiAlertBlock.Span.End);
Assert.Equal(2, dummyBlockProcessor.Start); // Skips ! and first space
}
public void ParseLine_IfSuccessfullyParsedStartLineOfABlockCreatesNewFlexiAlertBlockAdvancesCurrentCharAndReturnsBlockStateContinue()
{
// Arrange
var dummyLine = new StringSlice("! dummyLine");
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = dummyLine;
FlexiAlertBlock dummyFlexiAlertBlock = CreateFlexiAlertBlock();
Mock <IFlexiAlertBlockFactory> mockFlexiAlertBlockFactory = _mockRepository.Create <IFlexiAlertBlockFactory>();
ExposedFlexiAlertBlockParser testSubject = CreateExposedFlexiAlertBlockParser(mockFlexiAlertBlockFactory.Object);
mockFlexiAlertBlockFactory.Setup(f => f.Create(dummyBlockProcessor, testSubject)).Returns(dummyFlexiAlertBlock);
// Act
BlockState result = testSubject.ParseLine(dummyBlockProcessor, null);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(BlockState.Continue, result);
var resultBlock = dummyBlockProcessor.NewBlocks.Peek() as FlexiAlertBlock;
Assert.Same(dummyFlexiAlertBlock, resultBlock);
Assert.Equal(2, dummyBlockProcessor.Start); // Skips ! and first space
}
public BlockState ExposedTryContinueBlock(BlockProcessor processor, FlexiAlertBlock flexiAlertBlock)
{
return(TryContinueBlock(processor, flexiAlertBlock));
}
public static IEnumerable <object[]> WriteBlock_WritesBlock_Data()
{
const string dummyBlockName = "dummyBlockName";
const string dummyType = "dummyType";
const string dummyAttributeKey1 = "dummyAttributeKey1";
const string dummyAttributeValue1 = "dummyAttributeValue1";
const string dummyAttributeKey2 = "dummyAttributeKey2";
const string dummyAttributeValue2 = "dummyAttributeValue2";
const string dummyClass = "dummyClass";
const string dummyIcon = "<dummyIcon></dummyIcon>";
const string dummyIconWithClass = "<dummyIcon class=\"__icon\"></dummyIcon>";
const string dummyChildText = "dummyChildText";
var dummyChildContainerInline = new ContainerInline();
dummyChildContainerInline.AppendChild(new LiteralInline(dummyChildText));
var dummyChildBlock = new ParagraphBlock()
{
Inline = dummyChildContainerInline
};
FlexiAlertBlock dummyFlexiAlertBlockWithChild = CreateFlexiAlertBlock();
dummyFlexiAlertBlockWithChild.Add(dummyChildBlock);
return(new object[][]
{
// BlockName is assigned as a class of the root element and all default classes are prepended with it
new object[] {
CreateFlexiAlertBlock(dummyBlockName),
$@"<div class=""{dummyBlockName} {dummyBlockName}_type_ {dummyBlockName}_no-icon"">
<div class=""{dummyBlockName}__content"">
</div>
</div>
"
},
// If type is specified, a language modifier class is rendered
new object[] {
CreateFlexiAlertBlock(type: dummyType),
$@"<div class="" _type_{dummyType} _no-icon"">
<div class=""__content"">
</div>
</div>
"
},
// If icon is valid HTML, it is rendered with a default class and a _has-icon class is rendered
new object[] {
CreateFlexiAlertBlock(icon: dummyIcon),
$@"<div class="" _type_ _has-icon"">
{dummyIconWithClass}
<div class=""__content"">
</div>
</div>
"
},
// If icon is null, whitespace or an empty string, no icon is rendered and a _no-icon class is rendered (null case already verified in other tests)
new object[] {
CreateFlexiAlertBlock(icon: " "),
@"<div class="" _type_ _no-icon"">
<div class=""__content"">
</div>
</div>
"
},
new object[] {
CreateFlexiAlertBlock(icon: string.Empty),
@"<div class="" _type_ _no-icon"">
<div class=""__content"">
</div>
</div>
"
},
// If attributes specified, they're written
new object[] {
CreateFlexiAlertBlock(attributes: new ReadOnlyDictionary <string, string>(new Dictionary <string, string> {
{ dummyAttributeKey1, dummyAttributeValue1 }, { dummyAttributeKey2, dummyAttributeValue2 }
})),
$@"<div class="" _type_ _no-icon"" {dummyAttributeKey1}=""{dummyAttributeValue1}"" {dummyAttributeKey2}=""{dummyAttributeValue2}"">
<div class=""__content"">
</div>
</div>
"
},
// If classes are specified, they're appended to default classes
new object[] {
CreateFlexiAlertBlock(attributes: new ReadOnlyDictionary <string, string>(new Dictionary <string, string> {
{ "class", dummyClass }
})),
$@"<div class="" _type_ _no-icon {dummyClass}"">
<div class=""__content"">
</div>
</div>
"
},
// Children are rendered
new object[] {
dummyFlexiAlertBlockWithChild,
$@"<div class="" _type_ _no-icon"">
<div class=""__content"">
<p>{dummyChildText}</p>
</div>
</div>
"
}
});
}
public void ExposedWriteBlock(HtmlRenderer htmlRenderer, FlexiAlertBlock flexiAlertBlock)
{
WriteBlock(htmlRenderer, flexiAlertBlock);
}
