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 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 TryContinueBlock_ReturnsBlockStateBreadDiscardAndUpdatesSpanEndIfLineContainsAClosingFence()
{
// Arrange
const string dummyText = "dummyText";
const int dummyOpeningFenceCharCount = 3;
Mock <DummyProxyFencedBlock> mockProxyFencedBlock = _mockRepository.Create <DummyProxyFencedBlock>(null);
mockProxyFencedBlock.Setup(p => p.OpeningFenceCharCount).Returns(dummyOpeningFenceCharCount);
const int dummyLineEnd = 10;
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(dummyText, 0, dummyLineEnd);
Mock <ExposedFencedBlockParser> mockTestSubject = CreateMockExposedFencedBlockParser();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.LineContainsClosingFence(It.Is <StringSlice>(s => s.Text == dummyText), dummyOpeningFenceCharCount)).Returns(true);
// Act
BlockState result = mockTestSubject.Object.ExposedTryContinueBlock(dummyBlockProcessor, mockProxyFencedBlock.Object);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(BlockState.BreakDiscard, result);
Assert.Equal(dummyLineEnd, mockProxyFencedBlock.Object.Span.End);
}
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 CloseBlock_ReturnsTrueAndReplacesProxyIfThereIsAReplacement()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <LeafBlock> dummySiblingBlock1 = _mockRepository.Create <LeafBlock>(null);
Mock <LeafBlock> dummySiblingBlock2 = _mockRepository.Create <LeafBlock>(null);
var dummyProxyBlock = new DummyProxyBlock(null);
Mock <ContainerBlock> dummyParentBlock = _mockRepository.Create <ContainerBlock>(null);
dummyParentBlock.CallBase = true;
dummyParentBlock.Object.Add(dummySiblingBlock1.Object); // So we can verify replacement position
dummyParentBlock.Object.Add(dummyProxyBlock);
dummyParentBlock.Object.Add(dummySiblingBlock2.Object); // So we can verify replacement position
Mock <Block> dummyReplacementBlock = _mockRepository.Create <Block>(null);
Mock <ExposedProxyBlockParser <Block, DummyProxyBlock> > testSubject = CreateMockExposedBlockParser();
testSubject.CallBase = true;
testSubject.Protected().Setup <Block>("CloseProxy", dummyBlockProcessor, dummyProxyBlock).Returns(dummyReplacementBlock.Object);
// Act
bool result = testSubject.Object.ExposedCloseBlock(dummyBlockProcessor, dummyProxyBlock);
// Assert
Assert.True(result);
Assert.Equal(3, dummyParentBlock.Object.Count);
Assert.Same(dummySiblingBlock1.Object, dummyParentBlock.Object[0]);
Assert.Same(dummyReplacementBlock.Object, dummyParentBlock.Object[1]); // Replacement must be in position of proxy it replaced
Assert.Same(dummySiblingBlock2.Object, dummyParentBlock.Object[2]);
}
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 CreateOptions_FromFlexiOptionsBlock_CreatesOptions()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <IDummyBlockOptions> dummyDefaultBlockOptions = _mockRepository.Create <IDummyBlockOptions>();
Mock <IDummyBlockOptions> dummyNewBlockOptions = _mockRepository.Create <IDummyBlockOptions>();
Mock <IDummyBlocksExtensionOptions> mockBlocksExtensionOptions = _mockRepository.Create <IDummyBlocksExtensionOptions>();
mockBlocksExtensionOptions.Setup(f => f.DefaultBlockOptions).Returns(dummyDefaultBlockOptions.Object);
Mock <IBlockOptionsFactory <IDummyBlockOptions> > mockBlockOptionsFactory = _mockRepository.Create <IBlockOptionsFactory <IDummyBlockOptions> >();
mockBlockOptionsFactory.Setup(f => f.Create(dummyDefaultBlockOptions.Object, dummyBlockProcessor)).Returns(dummyNewBlockOptions.Object);
Mock <IExtensionOptionsFactory <IDummyBlocksExtensionOptions, IDummyBlockOptions> > mockBlocksExtensionOptionsFactory =
_mockRepository.Create <IExtensionOptionsFactory <IDummyBlocksExtensionOptions, IDummyBlockOptions> >();
mockBlocksExtensionOptionsFactory.Setup(f => f.Create(dummyBlockProcessor)).Returns(mockBlocksExtensionOptions.Object);
OptionsService <IDummyBlockOptions, IDummyBlocksExtensionOptions> testSubject = CreateOptionsService(mockBlockOptionsFactory.Object, mockBlocksExtensionOptionsFactory.Object);
// Act
(IDummyBlockOptions resultBlockOptions, IDummyBlocksExtensionOptions resultExtensionOptions) = testSubject.CreateOptions(dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Same(dummyNewBlockOptions.Object, resultBlockOptions);
Assert.Same(mockBlocksExtensionOptions.Object, resultExtensionOptions);
}
public void TryOpenBlock_ReturnsContinueDiscardAndAddsNewProxyFencedBlockToNewBlocksIfLineContainsAnOpeningFence()
{
// Arrange
int dummyFenceCharCount = 3;
const int dummyIndent = 2;
const string dummyText = "dummyText";
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(dummyText);
dummyBlockProcessor.Column = dummyIndent;
DummyProxyFencedBlock dummyProxyFencedBlock = _mockRepository.Create <DummyProxyFencedBlock>(null).Object;
Mock <IFencedBlockFactory <Block, DummyProxyFencedBlock> > mockFencedBlockFactory = _mockRepository.Create <IFencedBlockFactory <Block, DummyProxyFencedBlock> >();
Mock <ExposedFencedBlockParser> mockTestSubject = CreateMockExposedFencedBlockParser(mockFencedBlockFactory.Object);
mockFencedBlockFactory.
Setup(f => f.CreateProxyFencedBlock(dummyIndent, dummyFenceCharCount, dummyBlockProcessor, mockTestSubject.Object)).
Returns(dummyProxyFencedBlock);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.LineContainsOpeningFence(It.Is <StringSlice>(s => s.Text == dummyText), out dummyFenceCharCount)).Returns(true);
// Act
BlockState result = mockTestSubject.Object.ExposedTryOpenBlock(dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(BlockState.ContinueDiscard, result);
Assert.Same(dummyProxyFencedBlock, dummyBlockProcessor.NewBlocks.Peek());
}
public void OnClosed_ThrowsArgumentNullExceptionIfBlockIsNull()
{
// Arrange
ExposedBlockExtension testSubject = CreatedExposedBlockExtension();
// Act and assert
Assert.Throws <ArgumentNullException>(() => testSubject.ExposedOnClosed(MarkdigTypesFactory.CreateBlockProcessor(), null));
}
public void TryGetFlexiOptionsBlock_ReturnsNullIfAnFlexiOptionsBlockDoesNotExist()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
BlockOptionsFactory <IDummyOptions> testSubject = CreateBlockOptionsFactory();
// Act
FlexiOptionsBlock result = testSubject.TryGetFlexiOptionsBlock(dummyBlockProcessor);
// Assert
Assert.Null(result);
}
public void TryOpenBlock_ReturnsBlockStateNoneIfLineDoesNotBeginWithExpectedCharacters(string line)
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(line);
ExposedJsonBlockParser testSubject = CreateExposedJsonBlockParser();
// Act
BlockState result = testSubject.ExposedTryOpenBlock(dummyBlockProcessor);
// Assert
Assert.Equal(BlockState.None, result);
}
public void TryOpenBlock_ReturnsBlockStateNoneIfLineHasCodeIndent()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Column = 4; // Code indent
dummyBlockProcessor.Line = new StringSlice(""); // To avoid null reference exception
ExposedFencedBlockParser testSubject = CreateExposedFencedBlockParser();
// Act
BlockState result = testSubject.ExposedTryOpenBlock(dummyBlockProcessor);
// Assert
Assert.Equal(BlockState.None, result);
}
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);
}
public void CloseBlock_ReturnsFalseIfThereIsNoReplacement()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
var dummyProxyBlock = new DummyProxyBlock(null);
Mock <ExposedProxyBlockParser <Block, DummyProxyBlock> > testSubject = CreateMockExposedBlockParser();
testSubject.CallBase = true;
testSubject.Protected().Setup <Block>("CloseProxy", dummyBlockProcessor, dummyProxyBlock).Returns((Block)null);
// Act
bool result = testSubject.Object.ExposedCloseBlock(dummyBlockProcessor, dummyProxyBlock);
// Assert
Assert.False(result);
}
public void TryGetFlexiOptionsBlock_IfSuccessfulReturnsFlexiOptionsBlockAndRemovesItFromDocumentData()
{
// Arrange
var dummyFlexiOptionsBlock = new FlexiOptionsBlock(null);
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Document.SetData(FlexiOptionsBlockFactory.PENDING_FLEXI_OPTIONS_BLOCK, dummyFlexiOptionsBlock);
BlockOptionsFactory <IDummyOptions> testSubject = CreateBlockOptionsFactory();
// Act
FlexiOptionsBlock result = testSubject.TryGetFlexiOptionsBlock(dummyBlockProcessor);
// Assert
Assert.Same(dummyFlexiOptionsBlock, result);
Assert.Null(dummyBlockProcessor.Document.GetData(FlexiOptionsBlockFactory.PENDING_FLEXI_OPTIONS_BLOCK));
}
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 Create_FromFlexiOptionsBlock_ReturnsDefaultBlockOptionsIfThereIsNoFlexiOptionsBlock()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <IDummyOptions> dummyOptions = _mockRepository.Create <IDummyOptions>();
Mock <BlockOptionsFactory <IDummyOptions> > mockTestSubject = CreateMockBlockOptionsFactory();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.TryGetFlexiOptionsBlock(dummyBlockProcessor)).Returns((FlexiOptionsBlock)null);
// Act
IDummyOptions result = mockTestSubject.Object.Create(dummyOptions.Object, dummyBlockProcessor);
// Assert
Assert.Same(dummyOptions.Object, result);
_mockRepository.VerifyAll();
}
public void Create_ReturnsNewExtensionOptionsIfThereIsNoContextObjectForTheGivenKey()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
object dummyValue = null;
Mock <IContextObjectsService> mockContextObjectsService = _mockRepository.Create <IContextObjectsService>();
mockContextObjectsService.Setup(c => c.TryGetContextObject(typeof(IDummyExtensionOptions), dummyBlockProcessor, out dummyValue)).Returns(false);
ExtensionOptionsFactory <IDummyExtensionOptions, DummyExtensionOptions, IDummyBlockOptions> testSubject =
CreateExtensionOptionsFactory(mockContextObjectsService.Object);
// Act
IDummyExtensionOptions result = testSubject.Create(dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.IsType <DummyExtensionOptions>(result);
}
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 CloseProxy_CreatesFencedBlock()
{
// Arrange
Mock <DummyProxyFencedBlock> dummyProxyFencedBlock = _mockRepository.Create <DummyProxyFencedBlock>(null);
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <Block> dummyBlock = _mockRepository.Create <Block>(null);
Mock <IFencedBlockFactory <Block, DummyProxyFencedBlock> > mockFencedBlockFactory = _mockRepository.Create <IFencedBlockFactory <Block, DummyProxyFencedBlock> >();
mockFencedBlockFactory.Setup(f => f.Create(dummyProxyFencedBlock.Object, dummyBlockProcessor)).Returns(dummyBlock.Object);
ExposedFencedBlockParser testSubject = CreateExposedFencedBlockParser(mockFencedBlockFactory.Object);
// Act
Block result = testSubject.ExposedCloseProxy(dummyBlockProcessor, dummyProxyFencedBlock.Object);
// Assert
_mockRepository.VerifyAll();
Assert.Same(dummyBlock.Object, result);
}
public void TryOpenBlock_ReturnsBlockStateNoneIfInCodeIndent()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
// These three lines set IsCodeIndent to true
dummyBlockProcessor.Column = 0;
dummyBlockProcessor.RestartIndent();
dummyBlockProcessor.Column = 4;
ExposedJsonBlockParser testSubject = CreateExposedJsonBlockParser();
// Act
BlockState result = testSubject.ExposedTryOpenBlock(dummyBlockProcessor);
// Assert
Assert.True(dummyBlockProcessor.IsCodeIndent);
Assert.Equal(BlockState.None, result);
}
public void Create_ReturnsIExtensionOptionsFromContextObjectsIfItExists()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <IContextObjectsService> mockContextObjectsService = _mockRepository.Create <IContextObjectsService>();
Mock <IDummyExtensionOptions> dummyExtensionOptions = _mockRepository.Create <IDummyExtensionOptions>();
object dummyValue = dummyExtensionOptions.Object;
mockContextObjectsService.Setup(c => c.TryGetContextObject(typeof(IDummyExtensionOptions), dummyBlockProcessor, out dummyValue)).Returns(true);
ExtensionOptionsFactory <IDummyExtensionOptions, DummyExtensionOptions, IDummyBlockOptions> testSubject =
CreateExtensionOptionsFactory(mockContextObjectsService.Object);
// Act
IDummyExtensionOptions result = testSubject.Create(dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Same(dummyValue, result);
}
public void TryContinueBlock_ReturnsBlockStateContinueAndUpdatesLineStartIfLineHasCodeIndent()
{
// Arrange
Mock <DummyProxyFencedBlock> dummyProxyFencedBlock = _mockRepository.Create <DummyProxyFencedBlock>(null);
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Column = 4; // Code indent
Mock <ExposedFencedBlockParser> mockTestSubject = CreateMockExposedFencedBlockParser();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.UpdateLineStart(dummyBlockProcessor, dummyProxyFencedBlock.Object));
// Act
BlockState result = mockTestSubject.Object.ExposedTryContinueBlock(dummyBlockProcessor, dummyProxyFencedBlock.Object);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(BlockState.Continue, result);
}
public void UpdateLineStart_UpdatesLineStart(string dummyLineText, int dummyOpeningFenceIndent, int dummyLineIndent, int expectedResult)
{
// Arrange
var dummyLine = new StringSlice(dummyLineText);
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = dummyLine;
dummyBlockProcessor.Column = dummyLineIndent;
Mock <DummyProxyFencedBlock> mockProxyFencedBlock = _mockRepository.Create <DummyProxyFencedBlock>(null);
mockProxyFencedBlock.Setup(p => p.OpeningFenceIndent).Returns(dummyOpeningFenceIndent);
ExposedFencedBlockParser testSubject = CreateExposedFencedBlockParser();
// Act
testSubject.UpdateLineStart(dummyBlockProcessor, mockProxyFencedBlock.Object);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(expectedResult, dummyBlockProcessor.Indent);
}
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 Create_FromFlexiOptionsBlock_CreatesOptions()
{
// Arrange
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
Mock <IDummyOptions> dummyClonedDummyOptions = _mockRepository.Create <IDummyOptions>();
Mock <IDummyOptions> dummyOptions = _mockRepository.Create <IDummyOptions>();
var dummyFlexiOptionsBlock = new FlexiOptionsBlock(null);
Mock <BlockOptionsFactory <IDummyOptions> > mockTestSubject = CreateMockBlockOptionsFactory();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.TryGetFlexiOptionsBlock(dummyBlockProcessor)).Returns(dummyFlexiOptionsBlock);
mockTestSubject.Setup(t => t.Create(dummyOptions.Object, dummyFlexiOptionsBlock)).Returns(dummyClonedDummyOptions.Object);
// Act
IDummyOptions result = mockTestSubject.Object.Create(dummyOptions.Object, dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Same(dummyClonedDummyOptions.Object, result);
}
public void TryOpenBlock_ReturnsBlockStateNoneIfLineDoesNotContainAnOpeningFence()
{
// Arrange
const string dummyText = "dummyText";
BlockProcessor dummyBlockProcessor = MarkdigTypesFactory.CreateBlockProcessor();
dummyBlockProcessor.Line = new StringSlice(dummyText);
Mock <ExposedFencedBlockParser> mockTestSubject = CreateMockExposedFencedBlockParser();
mockTestSubject.CallBase = true;
int dummyFenceCharCount;
mockTestSubject.Setup(t => t.LineContainsOpeningFence(It.Is <StringSlice>(s => s.Text == dummyText), out dummyFenceCharCount)).Returns(false);
// Act
BlockState result = mockTestSubject.Object.ExposedTryOpenBlock(dummyBlockProcessor);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(BlockState.None, result);
}
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 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);
}