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 ResolveLocalAbsolutePath_ReturnsNullIfEnableFileOperationsIsFalse()
        {
            // Arrange
            ExposedMediaBlockFactory testSubject = CreateExposedMediaBlockFactory();

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

            // Assert
            Assert.Null(result);
        }
        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 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);
        }