public void FlexiTableBlocks_ExceptionsForBlocksInCellsHaveCorrectLineNumbers()
{
// Arrange
var services = new ServiceCollection();
services.AddFlexiTableBlocks();
services.AddFlexiSectionBlocks();
services.AddFlexiOptionsBlocks();
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
var dummyMarkdownPipelineBuilder = new MarkdownPipelineBuilder();
dummyMarkdownPipelineBuilder.Extensions.Add(serviceProvider.GetRequiredService <IBlockExtension <FlexiTableBlock> >());
dummyMarkdownPipelineBuilder.Extensions.Add(serviceProvider.GetRequiredService <IBlockExtension <FlexiSectionBlock> >());
dummyMarkdownPipelineBuilder.Extensions.Add(serviceProvider.GetRequiredService <IBlockExtension <FlexiOptionsBlock> >());
MarkdownPipeline dummyMarkdownPipeline = dummyMarkdownPipelineBuilder.Build();
// Note: "" counts as 1 character
const string dummyMarkdown = @"
+--------------+---------------------+--------------+
| header 1 | header 2 | header 3 |
+==============+=====================+==============+
| - cell 1 | ``` | > cell 3 |
| - cell 2 | cell 2 | > cell 3 |
| - cell 3 | ``` | > cell 3 |
| | | |
| | o{""element"": 100} | |
| | # Section | |
+--------------+---------------------+--------------+";
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => MarkdownParser.Parse(dummyMarkdown, dummyMarkdownPipeline));
Assert.Equal(10, result.LineNumber);
}
}
public void Close_WrapsNonBlockExceptionsAndBlockExceptionsWithoutBlockContextInBlockExceptionsWithBlockContext(Exception dummyException)
{
// Arrange
const int dummyLineIndex = 4;
const int dummyColumn = 5;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <Block> mockBlock = _mockRepository.Create <Block>(null);
mockBlock.Object.Line = dummyLineIndex; // Line isn't virtual
mockBlock.Object.Column = dummyColumn; // Column isn't virtual
Mock <BlockParser <Block> > mockTestSubject = CreateMockBlockParser <Block>();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("CloseBlock", dummyBlockProcessor, mockBlock.Object).Throws(dummyException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.Close(dummyBlockProcessor, mockBlock.Object));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
mockBlock.Object.GetType().Name,
dummyLineIndex + 1,
dummyColumn,
Strings.BlockException_BlockException_ExceptionOccurredWhileProcessingBlock),
result.Message,
ignoreLineEndingDifferences: true);
Assert.Same(dummyException, result.InnerException);
}
public void Create_FromLeafBlock_ThrowsBlockExceptionIfJsonCannotBeDeserialized()
{
// Arrange
const string dummyJson = "@dummyJson";
const int dummyColumn = 2;
const int dummyLineIndex = 4;
Mock <LeafBlock> dummyLeafBlock = _mockRepository.Create <LeafBlock>(null);
dummyLeafBlock.Object.Lines = new StringLineGroup(dummyJson);
dummyLeafBlock.Object.Line = dummyLineIndex;
dummyLeafBlock.Object.Column = dummyColumn;
var dummyJsonException = new JsonException();
Mock <IDummyOptions> dummyClonedBlockOptions = _mockRepository.Create <IDummyOptions>();
Mock <IDummyOptions> mockDefaultBlockOptions = _mockRepository.Create <IDummyOptions>();
mockDefaultBlockOptions.Setup(d => d.Clone()).Returns(dummyClonedBlockOptions.Object);
Mock <IJsonSerializerService> mockJsonSerializerService = _mockRepository.Create <IJsonSerializerService>();
mockJsonSerializerService.Setup(j => j.Populate(It.IsAny <JsonTextReader>(), dummyClonedBlockOptions.Object)).Throws(dummyJsonException);
BlockOptionsFactory <IDummyOptions> testSubject = CreateBlockOptionsFactory(mockJsonSerializerService.Object);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => testSubject.Create(mockDefaultBlockOptions.Object, dummyLeafBlock.Object));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
dummyLeafBlock.Object.GetType().Name,
dummyLineIndex + 1,
dummyColumn,
string.Format(Strings.OptionsException_BlockOptionsFactory_InvalidJson, dummyJson)),
result.Message);
Assert.Same(dummyJsonException, result.InnerException);
}
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 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 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 MoveChildren_ThrowsBlockExceptionIfAChildIsNotOfTheExpectedType()
{
// Arrange
const int dummyLineIndex = 6;
const int dummyColumn = 2;
var dummyChildBlock1 = new DummyChildBlock(null);
Block dummyChildBlock2 = _mockRepository.Create <Block>(null).Object;
var dummyChildBlock3 = new DummyChildBlock(null);
var dummyProxyFencedContainerBlock = new ProxyFencedContainerBlock(0, 0, null, null)
{
dummyChildBlock1, dummyChildBlock2, dummyChildBlock3
};
ContainerBlock dummyTarget = _mockRepository.Create <ContainerBlock>(null).Object;
dummyTarget.Column = dummyColumn;
dummyTarget.Line = dummyLineIndex;
ExposedCollectionBlockFactory testSubject = CreateExposedCollectionBlockFactory();
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => testSubject.ExposedMoveChildren(dummyProxyFencedContainerBlock, dummyTarget));
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
dummyTarget.GetType().Name,
dummyLineIndex + 1,
dummyColumn,
string.Format(Strings.BlockException_Shared_BlockMustOnlyContainASpecificTypeOfBlock,
nameof(ContainerBlock),
nameof(DummyChildBlock),
dummyChildBlock2.GetType().Name)),
result.Message);
}
public void BlockException_CanBeSerialized()
{
// Arrange
const int dummyLineIndex = 1;
const int dummyColumn = 2;
var dummyBlock = new DummyBlock(null)
{
Column = dummyColumn,
Line = dummyLineIndex
};
const string dummyDescription = "dummyDescription";
IFormatter dummyFormatter = new BinaryFormatter();
var dummyStream = new MemoryStream();
var testSubject = new BlockException(dummyBlock, dummyDescription);
// Act
dummyFormatter.Serialize(dummyStream, testSubject);
dummyStream.Position = 0;
var result = (BlockException)dummyFormatter.Deserialize(dummyStream);
// Assert
Assert.Equal(BlockExceptionContext.Block, result.Context);
Assert.Equal(dummyLineIndex + 1, result.LineNumber);
Assert.Equal(dummyColumn, result.Column);
Assert.Equal(dummyDescription, result.Description);
Assert.Equal(nameof(DummyBlock), result.BlockTypeName);
}
public void TryOpenBlock_ThrowsBlockExceptionIfAnExceptionIsThrownWhileCreatingProxyFencedBlock()
{
// Arrange
int dummyFenceCharCount = 3;
const int dummyLineIndex = 6;
const int dummyIndent = 2;
const string dummyText = "dummyText";
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(dummyText);
dummyBlockProcessor.Column = dummyIndent;
dummyBlockProcessor.LineIndex = dummyLineIndex;
DummyProxyFencedBlock dummyProxyFencedBlock = _mockRepository.Create <DummyProxyFencedBlock>(null).Object;
Mock <IFencedBlockFactory <Block, DummyProxyFencedBlock> > mockFencedBlockFactory = _mockRepository.Create <IFencedBlockFactory <Block, DummyProxyFencedBlock> >();
var dummyException = new Exception();
Mock <ExposedFencedBlockParser> mockTestSubject = CreateMockExposedFencedBlockParser(mockFencedBlockFactory.Object);
mockFencedBlockFactory.
Setup(f => f.CreateProxyFencedBlock(dummyIndent, dummyFenceCharCount, dummyBlockProcessor, mockTestSubject.Object)).
Throws(dummyException);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.LineContainsOpeningFence(It.Is <StringSlice>(s => s.Text == dummyText), out dummyFenceCharCount)).Returns(true);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.ExposedTryOpenBlock(dummyBlockProcessor));
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock, nameof(Block), dummyLineIndex + 1, dummyIndent,
Strings.BlockException_Shared_ExceptionOccurredWhileCreatingBlock),
result.Message);
Assert.Same(dummyException, result.InnerException);
_mockRepository.VerifyAll();
}
public void TryOpen_WrapsNonBlockExceptionsAndBlockExceptionsWithoutBlockContextInBlockExceptionWithsBlockContextIfABlockIsCreated(Exception dummyException)
{
// Arrange
Mock <Block> mockBlock = _mockRepository.Create <Block>(null);
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.NewBlocks.Push(mockBlock.Object);
Mock <BlockParser <Block> > mockTestSubject = CreateMockBlockParser <Block>();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("TryOpenBlock", dummyBlockProcessor).Throws(dummyException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.TryOpen(dummyBlockProcessor));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
mockBlock.Object.GetType().Name,
mockBlock.Object.Line + 1,
mockBlock.Object.Column,
Strings.BlockException_BlockException_ExceptionOccurredWhileProcessingBlock),
result.Message,
ignoreLineEndingDifferences: true);
Assert.Same(dummyException, result.InnerException);
}
public void FlexiIncludeBlocks_ThrowsBlockExceptionIfAnIncludedContentHasAnInvalidBlock()
{
// Arrange
const int dummyRenderingMode = 12;
const string dummyRootContent = @"
i{
""type"": ""markdown"",
""source"": ""./dummyContent1.md""
}";
string dummyContent1 = $@"This is valid markdown.
o{{
""renderingMode"": ""{dummyRenderingMode}""
}}
```
This is a FlexiCodeBlock with an invalid option.
```
";
// Need to dispose of services after each test so that the in-memory cache doesn't affect results
var services = new ServiceCollection();
services.
AddFlexiOptionsBlocks().
AddFlexiIncludeBlocks().
AddFlexiCodeBlocks();
// Write to file
var dummySource1Uri = new Uri($"{_fixture.TempDirectory}/{nameof(dummyContent1)}.md");
File.WriteAllText(dummySource1Uri.AbsolutePath, dummyContent1);
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
var dummyMarkdownPipelineBuilder = new MarkdownPipelineBuilder();
dummyMarkdownPipelineBuilder.Extensions.Add(serviceProvider.GetRequiredService <IBlockExtension <FlexiIncludeBlock> >());
dummyMarkdownPipelineBuilder.Extensions.Add(serviceProvider.GetRequiredService <IBlockExtension <FlexiOptionsBlock> >());
dummyMarkdownPipelineBuilder.Extensions.Add(serviceProvider.GetRequiredService <IBlockExtension <FlexiCodeBlock> >());
MarkdownPipeline dummyMarkdownPipeline = dummyMarkdownPipelineBuilder.Build();
var dummyMarkdownParserContext = new MarkdownParserContext();
dummyMarkdownParserContext.Properties[typeof(IFlexiIncludeBlocksExtensionOptions)] = new FlexiIncludeBlocksExtensionOptions(baseUri: _fixture.TempDirectory + "/");
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => MarkdownParser.Parse(dummyRootContent, dummyMarkdownPipeline, dummyMarkdownParserContext));
// From bottom to top, this is the exception chain:
// OptionsException > BlockException for invalid FlexiCodeBlock > BlockException for invalid FlexiIncludeBlock
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock, nameof(FlexiIncludeBlock), 2, 0,
string.Format(Strings.BlockException_FlexiIncludeBlockFactory_ExceptionOccurredWhileProcessingContent, dummySource1Uri.AbsoluteUri)),
result.Message);
Assert.IsType <BlockException>(result.InnerException);
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock, nameof(FlexiCodeBlock), 6, 0,
Strings.BlockException_BlockException_ExceptionOccurredWhileProcessingBlock),
result.InnerException.Message);
Assert.IsType <OptionsException>(result.InnerException.InnerException);
Assert.Equal(string.Format(Strings.OptionsException_OptionsException_InvalidOption,
nameof(IFlexiCodeBlockOptions.RenderingMode),
string.Format(Strings.OptionsException_Shared_ValueMustBeAValidEnumValue, dummyRenderingMode, nameof(FlexiCodeBlockRenderingMode))),
result.InnerException.InnerException.Message);
}
}
public void Message_ReturnsBaseMessageIfContextIsNone(string dummyMessage, string expectedResult)
{
// Arrange
var testSubject = new BlockException(dummyMessage);
// Act
string result = testSubject.Message;
// Assert
Assert.Equal(expectedResult, result);
}
public void FlexiIncludeBlocks_ThrowsBlockExceptionIfACycleIsFound(string dummyRootContent, int dummyEntryInvalidFlexiIncludeBlockLineNumber,
string dummyContent1, int dummyContent1InvalidFlexiIncludeBlockLineNumber,
string dummyContent2, int dummyContent2InvalidFlexiIncludeBlockLineNumber,
string dummyContent3,
string expectedCycleDescription)
{
// Arrange
var dummySource1Uri = new Uri($"{_fixture.TempDirectory}/{nameof(dummyContent1)}.md");
var dummySource2Uri = new Uri($"{_fixture.TempDirectory}/{nameof(dummyContent2)}.md");
var dummySource3Uri = new Uri($"{_fixture.TempDirectory}/{nameof(dummyContent3)}.md");
File.WriteAllText(dummySource1Uri.AbsolutePath, dummyContent1);
File.WriteAllText(dummySource2Uri.AbsolutePath, dummyContent2);
File.WriteAllText(dummySource3Uri.AbsolutePath, dummyContent3);
// Need to dispose of services after each test so that the in-memory cache doesn't affect results
var services = new ServiceCollection();
services.AddFlexiIncludeBlocks();
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
// TODO use service provider to manually add extension instead of UseFlexiIncludeBlocks!
var dummyMarkdownPipelineBuilder = new MarkdownPipelineBuilder();
dummyMarkdownPipelineBuilder.Extensions.Add(serviceProvider.GetRequiredService <IBlockExtension <FlexiIncludeBlock> >());
MarkdownPipeline dummyMarkdownPipeline = dummyMarkdownPipelineBuilder.Build();
var dummyMarkdownParserContext = new MarkdownParserContext();
dummyMarkdownParserContext.Properties[typeof(IFlexiIncludeBlocksExtensionOptions)] = new FlexiIncludeBlocksExtensionOptions(baseUri: _fixture.TempDirectory + "/");
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => MarkdownParser.Parse(dummyRootContent, dummyMarkdownPipeline, dummyMarkdownParserContext));
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock, nameof(FlexiIncludeBlock), dummyEntryInvalidFlexiIncludeBlockLineNumber, 0,
string.Format(Strings.BlockException_FlexiIncludeBlockFactory_ExceptionOccurredWhileProcessingContent,
dummySource1Uri.AbsoluteUri)),
result.Message);
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock, nameof(FlexiIncludeBlock), dummyContent1InvalidFlexiIncludeBlockLineNumber, 0,
string.Format(Strings.BlockException_FlexiIncludeBlockFactory_ExceptionOccurredWhileProcessingContent,
dummySource2Uri.AbsoluteUri)),
result.InnerException.Message);
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock, nameof(FlexiIncludeBlock), dummyContent2InvalidFlexiIncludeBlockLineNumber, 0,
string.Format(Strings.BlockException_FlexiIncludeBlockFactory_ExceptionOccurredWhileProcessingContent,
dummySource1Uri.AbsoluteUri)),
result.InnerException.InnerException.Message);
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock, nameof(FlexiIncludeBlock), dummyContent1InvalidFlexiIncludeBlockLineNumber, 0,
Strings.BlockException_BlockException_ExceptionOccurredWhileProcessingBlock),
result.InnerException.InnerException.InnerException.Message);
Assert.Equal(string.Format(Strings.InvalidOperationException_FlexiIncludeBlockFactory_CycleFound,
string.Format(expectedCycleDescription, dummySource1Uri.AbsoluteUri, dummySource2Uri.AbsoluteUri)),
result.InnerException.InnerException.InnerException.InnerException.Message,
ignoreLineEndingDifferences: true);
}
}
public void TryOpen_DoesNotInterfereWithBlockExceptionWithLineContextIfNoBlockIsCreated()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
var dummyBlockException = new BlockException(1, 0);
Mock <BlockParser <Block> > mockTestSubject = CreateMockBlockParser <Block>();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("TryOpenBlock", dummyBlockProcessor).Throws(dummyBlockException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.TryOpen(dummyBlockProcessor));
_mockRepository.VerifyAll();
Assert.Same(dummyBlockException, result);
Assert.Null(result.InnerException);
}
public void Write_DoesNotInterfereWithBlockExceptionsWithBlockContext()
{
// Arrange
var dummyRenderer = new HtmlRenderer(new StringWriter());
Mock <Block> dummyBlock = _mockRepository.Create <Block>(null);
var dummyBlockException = new BlockException(dummyBlock.Object);
Mock <BlockRenderer <Block> > mockTestSubject = _mockRepository.Create <BlockRenderer <Block> >();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("WriteBlock", dummyRenderer, dummyBlock.Object).Throws(dummyBlockException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.Write(dummyRenderer, dummyBlock.Object));
_mockRepository.VerifyAll();
Assert.Same(dummyBlockException, result);
Assert.Null(result.InnerException);
}
public void Close_DoesNotInterfereWithBlockExceptionWithBlockContext()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <Block> dummyBlock = _mockRepository.Create <Block>(null);
var dummyBlockException = new BlockException(dummyBlock.Object); // So it has block context
Mock <BlockParser <Block> > mockTestSubject = CreateMockBlockParser <Block>();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("CloseBlock", dummyBlockProcessor, dummyBlock.Object).Throws(dummyBlockException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.Close(dummyBlockProcessor, dummyBlock.Object));
_mockRepository.VerifyAll();
Assert.Same(dummyBlockException, result);
Assert.Null(result.InnerException);
}
public void OnClosed_DoesNotInterfereWithBlockExceptionsWithBlockContext()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <Block> mockBlock = _mockRepository.Create <Block>(null);
var dummyBlockException = new BlockException(mockBlock.Object);
Mock <ExposedBlockExtension> mockTestSubject = CreateMockExposedBlockExtension();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("OnBlockClosed", dummyBlockProcessor, mockBlock.Object).Throws(dummyBlockException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.ExposedOnClosed(dummyBlockProcessor, mockBlock.Object));
_mockRepository.VerifyAll();
Assert.Same(dummyBlockException, result);
Assert.Null(result.InnerException);
}
public void Message_ReturnsInvalidBlockMessageIfContextIsLine(string dummyDescription, string dummyExpectedDescription)
{
// Arrange
const int dummyColumn = 2; // Arbitrary
const int dummyLineNumber = 5; // Arbitrary
var testSubject = new BlockException(dummyLineNumber, dummyColumn, dummyDescription);
// Act
string result = testSubject.Message;
// Assert
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
"block of unknown type",
dummyLineNumber,
dummyColumn,
dummyExpectedDescription),
result,
ignoreLineEndingDifferences: true);
}
public void Message_ReturnsInvalidBlockMessageIfContextIsBlock(string dummyDescription, string dummyExpectedDescription)
{
// Arrange
const int dummyColumn = 2; // Arbitrary
const int dummyLineIndex = 5; // Arbitrary
var dummyBlock = new DummyBlock(null)
{
Column = dummyColumn, Line = dummyLineIndex
};
var testSubject = new BlockException(dummyBlock, dummyDescription);
// Act
string result = testSubject.Message;
// Assert
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
nameof(DummyBlock),
dummyLineIndex + 1,
dummyColumn,
dummyExpectedDescription),
result, ignoreLineEndingDifferences: true);
}
public void Message_IfContextIsBlockAndBlockIsProxyBlockWithMainTypeNamePrintsMainTypeName(string dummyMainTypeName, string expectedTypeName)
{
// Arrange
const string dummyDescription = "dummyDescription";
const int dummyColumn = 2; // Arbitrary
const int dummyLineNumber = 5; // Arbitrary
Mock <IProxyBlock> mockProxyBlock = _mockRepository.Create <IProxyBlock>();
mockProxyBlock.Setup(p => p.MainTypeName).Returns(dummyMainTypeName);
var testSubject = new BlockException(mockProxyBlock.Object, dummyDescription, null, dummyLineNumber, dummyColumn);
// Act
string result = testSubject.Message;
// Assert
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
expectedTypeName,
dummyLineNumber,
dummyColumn,
dummyDescription),
result, ignoreLineEndingDifferences: true);
}
public void TryOpen_WrapsNonBlockExceptionsAndBlockExceptionsWithNoContextInBlockExceptionsWithLineContextIfNoBlockIsCreated(Exception dummyException)
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <BlockParser <Block> > mockTestSubject = CreateMockBlockParser <Block>();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("TryOpenBlock", dummyBlockProcessor).Throws(dummyException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.TryOpen(dummyBlockProcessor));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
"block of unknown type",
dummyBlockProcessor.LineIndex + 1,
dummyBlockProcessor.Column,
string.Format(Strings.BlockException_BlockParser_ExceptionOccurredWhileAttemptingToOpenBlock, mockTestSubject.Object.GetType().Name)),
result.Message,
ignoreLineEndingDifferences: true);
Assert.Same(dummyException, result.InnerException);
}
public void OnClosed_WrapsNonBlockExceptionsAndBlockExceptionsWithoutBlockContextInBlockExceptionsWithBlockContext(Exception dummyException)
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <Block> mockBlock = _mockRepository.Create <Block>(null);
Mock <ExposedBlockExtension> mockTestSubject = CreateMockExposedBlockExtension();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("OnBlockClosed", dummyBlockProcessor, mockBlock.Object).Throws(dummyException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.ExposedOnClosed(dummyBlockProcessor, mockBlock.Object));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
mockBlock.Object.GetType().Name,
mockBlock.Object.Line + 1,
mockBlock.Object.Column,
Strings.BlockException_BlockException_ExceptionOccurredWhileProcessingBlock),
result.Message,
ignoreLineEndingDifferences: true);
Assert.Same(dummyException, result.InnerException);
}
public void Write_WrapsNonBlockExceptionsAndBlockExceptionsWithoutBlockContextInBlockExceptionsWithBlockContext(Exception dummyException)
{
// Arrange
var dummyRenderer = new HtmlRenderer(new StringWriter());
Mock <Block> dummyBlock = _mockRepository.Create <Block>(null);
Mock <BlockRenderer <Block> > mockTestSubject = _mockRepository.Create <BlockRenderer <Block> >();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("WriteBlock", dummyRenderer, dummyBlock.Object).Throws(dummyException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.Write(dummyRenderer, dummyBlock.Object));
_mockRepository.VerifyAll();
Assert.Equal(string.Format(Strings.BlockException_BlockException_InvalidBlock,
dummyBlock.Object.GetType().Name,
dummyBlock.Object.Line + 1,
dummyBlock.Object.Column,
Strings.BlockException_BlockException_ExceptionOccurredWhileProcessingBlock),
result.Message,
ignoreLineEndingDifferences: true);
Assert.Same(dummyException, result.InnerException);
}
