public void ResolveLocalAbsolutePath_ThrowsOptionsExceptionIfMultipleFilesAreFoundInLocalMediaDirectory()
        {
            // Arrange
            const string dummyLocalMediaDirectory = "file:///host/dummy/local/images"; // /dummy/local/images isn't considered absolute on windows and c:/dummy/local/images isn't considered absolute on linux
            const string dummyFileName            = "dummyFileName";
            var          dummyRetrievedFiles      = new string[] { "dummyFile1", "dummyFile2" };
            Mock <IDummyMediaBlockExtensionOptions> mockMediaBlockExtensionOptions = _mockRepository.Create <IDummyMediaBlockExtensionOptions>();

            mockMediaBlockExtensionOptions.Setup(m => m.LocalMediaDirectory).Returns(dummyLocalMediaDirectory);
            Mock <IDirectoryService> mockDirectoryService = _mockRepository.Create <IDirectoryService>();

            mockDirectoryService.
            Setup(d => d.GetFiles(new Uri(dummyLocalMediaDirectory).AbsolutePath, dummyFileName, SearchOption.AllDirectories)).
            Returns(dummyRetrievedFiles);
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory(directoryService: mockDirectoryService.Object);

            // Act and assert
            OptionsException result = Assert.Throws <OptionsException>(() => testSubject.ExposedResolveLocalAbsolutePath(true,
                                                                                                                         dummyFileName,
                                                                                                                         mockMediaBlockExtensionOptions.Object));

            _mockRepository.VerifyAll();
            Assert.Equal(string.Format(Strings.OptionsException_OptionsException_InvalidOption,
                                       nameof(IDummyMediaBlockExtensionOptions.LocalMediaDirectory),
                                       string.Format(Strings.OptionsException_Shared_MultipleFilesFoundInDirectory,
                                                     dummyRetrievedFiles.Length,
                                                     dummyFileName,
                                                     dummyLocalMediaDirectory,
                                                     string.Join("\n", dummyRetrievedFiles))),
                         result.Message,
                         ignoreLineEndingDifferences: true);
        }
        public void ResolveLocalAbsolutePath_ThrowsOptionsExceptionIfUnableToRetrieveFilesFromLocalMediaDirectory()
        {
            // Arrange
            const string dummyLocalMediaDirectory = "file:///host/dummy/local/images"; // /dummy/local/images isn't considered absolute on windows and c:/dummy/local/images isn't considered absolute on linux
            const string dummyFileName            = "dummyFileName";
            Mock <IDummyMediaBlockExtensionOptions> mockMediaBlockExtensionOptions = _mockRepository.Create <IDummyMediaBlockExtensionOptions>();

            mockMediaBlockExtensionOptions.Setup(m => m.LocalMediaDirectory).Returns(dummyLocalMediaDirectory);
            var dummyException = new Exception();
            Mock <IDirectoryService> mockDirectoryService = _mockRepository.Create <IDirectoryService>();

            mockDirectoryService.
            Setup(d => d.GetFiles(new Uri(dummyLocalMediaDirectory).AbsolutePath, dummyFileName, SearchOption.AllDirectories)).
            Throws(dummyException);
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory(directoryService: mockDirectoryService.Object);

            // Act and assert
            OptionsException result = Assert.Throws <OptionsException>(() => testSubject.ExposedResolveLocalAbsolutePath(true,
                                                                                                                         dummyFileName,
                                                                                                                         mockMediaBlockExtensionOptions.Object));

            _mockRepository.VerifyAll();
            Assert.Same(dummyException, result.InnerException);
            Assert.Equal(string.Format(Strings.OptionsException_OptionsException_InvalidOption,
                                       nameof(IDummyMediaBlockExtensionOptions.LocalMediaDirectory),
                                       string.Format(Strings.OptionsException_Shared_UnableToRetrieveFilesFromDirectory, dummyLocalMediaDirectory)),
                         result.Message);
        }
        public void CreateProxyJsonBlock_ThrowsArgumentNullExceptionIfBlockProcessorIsNull()
        {
            // Arrange
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory();

            // Act and assert
            Assert.Throws <ArgumentNullException>(() => testSubject.CreateProxyJsonBlock(null, _mockRepository.Create <BlockParser>().Object));
        }
        public void ResolveLocalAbsolutePath_ReturnsNullIfEnableFileOperationsIsFalse()
        {
            // Arrange
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory();

            // Act
            string result = testSubject.ExposedResolveLocalAbsolutePath(false, null, null);

            // Assert
            Assert.Null(result);
        }
        public void ValidateSrcAndResolveFileName_ResolvesFileName(string dummySrc, string expectedFileName)
        {
            // Arrange
            Mock <IDummyMediaBlockOptions> mockMediaBlockOptions = _mockRepository.Create <IDummyMediaBlockOptions>();

            mockMediaBlockOptions.Setup(m => m.Src).Returns(dummySrc);
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory();

            // Act
            string result = testSubject.ExposedValidateSrcAndResolveFileName(mockMediaBlockOptions.Object);

            // Assert
            _mockRepository.VerifyAll();
            Assert.Equal(expectedFileName, result);
        }
        public void ValidateSrcAndResolveFileName_ThrowsOptionsExceptionIfSrcDoesNotPointToAFile(string dummySrc)
        {
            // Arrange
            Mock <IDummyMediaBlockOptions> mockMediaBlockOptions = _mockRepository.Create <IDummyMediaBlockOptions>();

            mockMediaBlockOptions.Setup(m => m.Src).Returns(dummySrc);
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory();

            // Act and assert
            OptionsException result = Assert.Throws <OptionsException>(() => testSubject.ExposedValidateSrcAndResolveFileName(mockMediaBlockOptions.Object));

            _mockRepository.VerifyAll();
            Assert.Equal(string.Format(Strings.OptionsException_OptionsException_InvalidOption,
                                       nameof(IDummyMediaBlockOptions.Src),
                                       string.Format(Strings.OptionsException_Shared_ValueMustPointToAFile, dummySrc)),
                         result.Message);
        }
        public void ResolveLocalAbsolutePath_ThrowsOptionsExceptionIfLocalMediaDirectorySchemeIsNotFile(string dummyLocalMediaDirectory, string dummyScheme)
        {
            // Arrange
            Mock <IDummyMediaBlockExtensionOptions> mockMediaBlockExtensionOptions = _mockRepository.Create <IDummyMediaBlockExtensionOptions>();

            mockMediaBlockExtensionOptions.Setup(m => m.LocalMediaDirectory).Returns(dummyLocalMediaDirectory);
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory();

            // Act and assert
            OptionsException result = Assert.Throws <OptionsException>(() => testSubject.ExposedResolveLocalAbsolutePath(true,
                                                                                                                         null,
                                                                                                                         mockMediaBlockExtensionOptions.Object));

            _mockRepository.VerifyAll();
            Assert.Equal(string.Format(Strings.OptionsException_OptionsException_InvalidOption,
                                       nameof(IDummyMediaBlockExtensionOptions.LocalMediaDirectory),
                                       string.Format(Strings.OptionsException_Shared_ValueMustBeAUriWithASupportedScheme, dummyLocalMediaDirectory, dummyScheme, "FILE")),
                         result.Message);
        }
        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);
        }
        public void ResolveLocalAbsolutePath_ReturnsLocalAbsolutePath()
        {
            // Arrange
            const string dummyLocalMediaDirectory = "file:///host/dummy/local/images"; // /dummy/local/images isn't considered absolute on windows and c:/dummy/local/images isn't considered absolute on linux
            const string dummyFileName            = "dummyFileName";
            const string dummyRetrievedFile       = "dummyRetrievedFile";
            Mock <IDummyMediaBlockExtensionOptions> mockMediaBlockExtensionOptions = _mockRepository.Create <IDummyMediaBlockExtensionOptions>();

            mockMediaBlockExtensionOptions.Setup(m => m.LocalMediaDirectory).Returns(dummyLocalMediaDirectory);
            Mock <IDirectoryService> mockDirectoryService = _mockRepository.Create <IDirectoryService>();

            mockDirectoryService.
            Setup(d => d.GetFiles(new Uri(dummyLocalMediaDirectory).AbsolutePath, dummyFileName, SearchOption.AllDirectories)).
            Returns(new string[] { dummyRetrievedFile });
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory(directoryService: mockDirectoryService.Object);

            // Act
            string result = testSubject.ExposedResolveLocalAbsolutePath(true,
                                                                        dummyFileName,
                                                                        mockMediaBlockExtensionOptions.Object);

            _mockRepository.VerifyAll();
            Assert.Equal(dummyRetrievedFile, result);
        }