public void SetUp()
{
fileSystem = new MockFileSystem();
var rnd = new Random();
var rndBytes = new byte[2048];
rnd.NextBytes(rndBytes);
var rndBytesFile = new MockFileData(rndBytes);
fileSystem.AddDirectory(@"C:\Archive");
fileSystem.AddFile(@"C:\source1\file.bin", rndBytesFile);
fileSystem.AddFile(@"C:\source1\1\file2.bin", rndBytesFile);
fileSystem.AddFile(@"C:\source1\2\file3.bin", rndBytesFile);
fileSystem.AddFile(@"C:\source2\1\1\file4.bin", rndBytesFile);
fileSystem.AddDirectory(@"C:\source3");
}
public void ItCanLoadLocalRepositoryWithTemplates()
{
var logger = NullLogger <RepositoryLoader> .Instance;
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory("/opt/stamp/repos/.local/templates/TestTemplate@1");
var stampConfig = Mock.Of <IStampConfig>(config =>
config.GetLocalRepositoryPath() == PurePath.Create("/opt/stamp/repos/.local")
);
var expectedTemplateName = "TestTemplate";
var expectedTemplateVersion = SemVersion.Parse("1.0.0");
var templateLoader = Mock.Of <ITemplateLoader>(loader =>
loader.LoadFromTemplateDirectory(It.IsAny <IPurePath>()) == Mock.Of <ITemplate>(template =>
template.Name == expectedTemplateName &&
template.Version == expectedTemplateVersion
)
);
var repositoryLoader = new RepositoryLoader(fileSystem, templateLoader, stampConfig, logger);
var repository = repositoryLoader.LoadLocalRepository();
repository.Should().NotBeNull();
repository.Name.Should().Be(".local");
repository.Description.Should().Be("Local repository");
repository.Templates.Count.Should().Be(1);
repository.Templates[0].Name.Should().Be(expectedTemplateName);
repository.Templates[0].Version.Should().Be(expectedTemplateVersion);
}
public static IEnumerable ForDifferentEncoding()
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"c:\something");
var fileContentEnumerable = new List <string> {
"first line", "second line", "third line", "fourth and last line"
};
var fileContentArray = fileContentEnumerable.ToArray();
Action writeEnumberable = () => fileSystem.File.WriteAllLines(Path, fileContentEnumerable);
Action writeEnumberableUtf32 = () => fileSystem.File.WriteAllLines(Path, fileContentEnumerable, Encoding.UTF32);
Action writeArray = () => fileSystem.File.WriteAllLines(Path, fileContentArray);
Action writeArrayUtf32 = () => fileSystem.File.WriteAllLines(Path, fileContentArray, Encoding.UTF32);
var expectedContent = string.Format(CultureInfo.InvariantCulture,
"first line{0}second line{0}third line{0}fourth and last line{0}", Environment.NewLine);
// IEnumerable
yield return
(new object[] { fileSystem, writeEnumberable, expectedContent, "WriteAllLines(string, IEnumerable<string>)" });
yield return
(new object[]
{
fileSystem, writeEnumberableUtf32, expectedContent,
"WriteAllLines(string, IEnumerable<string>, Encoding.UTF32)"
});
// string[]
yield return(new object[] { fileSystem, writeArray, expectedContent, "WriteAllLines(string, string[])" });
yield return
(new object[] { fileSystem, writeArrayUtf32, expectedContent, "WriteAllLines(string, string[], Encoding.UTF32)" });
}
private static MockFileSystem CreateEmptyMockFileSystem()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>(), "c:\\Test");
fileSystem.AddDirectory("Test");
return(fileSystem);
}
public void MakeSecondLineUpperCase()
{
// Create a mock input file
var mockInputFile = new MockFileData("Line 1\nLine 2\nLine 3");
// Setup mock file system starting state
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddFile(@"c:\root\in\myfile.txt", mockInputFile);
mockFileSystem.AddDirectory(@"c:\root\out");
// Create TextFileProcessor with mock file system
var sut = new TextFileProcessor(@"c:\root\in\myfile.txt",
@"c:\root\out\myfile.txt",
mockFileSystem);
// Process test file
sut.Process();
// Check mock file system for output file
Assert.True(mockFileSystem.FileExists(@"c:\root\out\myfile.txt"));
// Check content of output file in mock file system
MockFileData processedFile = mockFileSystem.GetFile(@"c:\root\out\myfile.txt");
string[] lines = processedFile.TextContents.SplitLines();
Assert.Equal("Line 1", lines[0]);
Assert.Equal("LINE 2", lines[1]);
Assert.Equal("Line 3", lines[2]);
}
public static IEnumerable ForContentsIsNull()
{
var fileSystem = new MockFileSystem();
var path = XFS.Path(@"c:\something\file.txt");
var mockFileData = new MockFileData(string.Empty);
mockFileData.Attributes = FileAttributes.ReadOnly;
fileSystem.AddDirectory(@"c:\something");
fileSystem.AddFile(path, mockFileData);
List <string> fileContentEnumerable = null;
string[] fileContentArray = null;
// ReSharper disable ExpressionIsAlwaysNull
Action writeEnumberable = () => fileSystem.File.WriteAllLines(path, fileContentEnumerable);
Action writeEnumberableUtf32 = () => fileSystem.File.WriteAllLines(path, fileContentEnumerable, Encoding.UTF32);
Action writeArray = () => fileSystem.File.WriteAllLines(path, fileContentArray);
Action writeArrayUtf32 = () => fileSystem.File.WriteAllLines(path, fileContentArray, Encoding.UTF32);
// ReSharper restore ExpressionIsAlwaysNull
// IEnumerable
yield return(new object[] { writeEnumberable, "WriteAllLines(string, IEnumerable<string>)" });
yield return(new object[] { writeEnumberableUtf32, "WriteAllLines(string, IEnumerable<string>, Encoding.UTF32)" });
// string[]
yield return(new object[] { writeArray, "WriteAllLines(string, string[])" });
yield return(new object[] { writeArrayUtf32, "WriteAllLines(string, string[], Encoding.UTF32)" });
}
public void WriteBackupFile_WritesBackupFile_EveryoneIsHappy(
[Frozen] IMainModel model,
string fileContent)
{
var directory = @"C:\Temp\";
var fileName = "temp";
var fileExtension = ".txt";
var filePath = directory + fileName + fileExtension;
var mockedFileSystem = new MockFileSystem();
var mockedFileContent = new MockFileData(fileContent);
mockedFileSystem.AddDirectory(directory);
mockedFileSystem.AddFile(filePath, mockedFileContent);
model.FileName = filePath;
var sut = new BackupService(model, mockedFileSystem);
sut.WriteBackupFile();
var expectedPath = $"{directory}{fileName}_backup_{DateTime.Now:yyyyMMddHHmmss}{fileExtension}";
mockedFileSystem.FileExists(expectedPath).Should().BeTrue();
}
public void CopyFilesWhenIndicated(bool shouldInitialize)
{
var initializationDeterminer = new MockLevelInitializationDeterminer(shouldInitialize);
var copyDir = new MockCopyDir();
var levelId = "level";
var levelToInitialize = new Level(id: levelId, folderFilepath: ".");
var levelsProvider = new FakeLevelsProvider(new[] { levelToInitialize });
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddDirectory(levelToInitialize.GetMasterFolder()); //will throw error if no master folder
var masterFolderLevelInitializer = new MasterFolderLevelInitializer(initializationDeterminer,
copyDir,
levelsProvider,
mockFileSystem.Path);
var someUser = "******";
masterFolderLevelInitializer.InitializeIfNecessary(levelId, someUser);
Assert.Equal(shouldInitialize, copyDir.DidCopy);
Assert.Equal(shouldInitialize, initializationDeterminer.IsMarkedAsInitialized);
}
public void AddLargestNumber()
{
//Assert
var mockInputFile =
new MockFileData(new byte[] { 0xFF, 0x34, 0x56, 0xD2 });
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddFile(@"a:\root\in\myfile.data", mockInputFile);
mockFileSystem.AddDirectory(@"a:\root\out");
var sut = new BinaryFileProcessor(
@"a:\root\in\myfile.data",
@"a:\root\out\myfile.data", mockFileSystem);
//act
sut.Process();
//Assert
Assert.True(mockFileSystem.FileExists(@"a:\root\out\myfile.data"));
var processedFile = mockFileSystem.GetFile(@"a:\root\out\myfile.data");
var data = processedFile.Contents;
Assert.Equal(5, data.Length);
Assert.Equal(0xFF, data[4]);
}
public void Mockfile_Create_OverwritesExistingFile()
{
string path = XFS.Path(@"c:\some\file.txt");
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"c:\some"));
var mockFile = new MockFile(fileSystem);
// Create a file
using (var stream = mockFile.Create(path))
{
var contents = new UTF8Encoding(false).GetBytes("Test 1");
stream.Write(contents, 0, contents.Length);
}
// Create new file that should overwrite existing file
var expectedContents = new UTF8Encoding(false).GetBytes("Test 2");
using (var stream = mockFile.Create(path))
{
stream.Write(expectedContents, 0, expectedContents.Length);
}
var actualContents = fileSystem.GetFile(path).Contents;
Assert.That(actualContents, Is.EqualTo(expectedContents));
}
public void TestNoSettingsFileReloadTouchSaveCycle(string SettingName, string SettingValue, string SettingSerializeAs)
{
string referenceConfigFileContent = Helpers.GenerateFileContent(new List <Tuple <string, string, string> > {
new Tuple <string, string, string>(SettingName, SettingValue, SettingSerializeAs)
}, typeof(TestSettingsAllValid));
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory("c:\\");
StaticMockFileSystem.MockFileSystem = fileSystem;
TestSettingsAllValid.Default.Reload();
if (SettingName == "StringSetting")
{
TestSettingsAllValid.Default.StringSetting = TestSettingsAllValid.Default.StringSetting;
}
if (SettingName == "BinarySetting")
{
TestSettingsAllValid.Default.BinarySetting = TestSettingsAllValid.Default.BinarySetting;
}
if (SettingName == "XmlSetting")
{
TestSettingsAllValid.Default.XmlSetting = TestSettingsAllValid.Default.XmlSetting;
}
TestSettingsAllValid.Default.Save();
var result = StaticMockFileSystem.MockFileSystem.File.ReadAllText(Consts.SettingsPath);
Assert.AreEqual(Helpers.GetCanonicalXml(referenceConfigFileContent), Helpers.GetCanonicalXml(result));
StaticMockFileSystem.MockFileSystem = null;
}
public async Task CanImportPackageWithFiles()
{
var writer = new MockTextWriter();
var settings = Substitute.For <IChauffeurSettings>();
const string siteRootPath = "C:\\SiteRoot";
settings.TryGetSiteRootDirectory(out string dir).Returns(x =>
{
x[0] = siteRootPath;
return(true);
});
var fs = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ "C:\\Path\\Text.xml", new MockFileData(filesXml) },
{ "C:\\Path\\foo.txt", new MockFileData("something") }
});
fs.AddDirectory(siteRootPath);
var package = new PackageDeliverable(null, writer, fs, settings, null, null, null);
await package.Run(null, new[] { "Text", "-f:C:\\Path" });
Assert.Collection(
fs.Directory.GetFiles(siteRootPath),
item => Assert.Equal("foo.txt", fs.Path.GetFileName(item))
);
}
public void InitializeBase()
{
FileSystem = new MockFileSystem();
TestDirectoryName = @"C:\ProgramFiles";
TestFileName = $@"{TestDirectoryName}\text.txt";
FileSystem.AddDirectory(TestDirectoryName);
JsonOperations = new Library.JsonOperations();
Configuration = new Library.Configuration(FileSystem);
LockFinder = new Library.LockFinder(FileSystem, Configuration);
LockReader = new Library.LockReader(FileSystem, LockFinder, JsonOperations);
LockBuilder = new Library.LockBuilder(Configuration);
LockWriter = new Library.LockWriter(FileSystem, JsonOperations, LockBuilder);
Communicator = new ListCommunicator();
Unlocker = new Library.Unlocker(FileSystem, LockReader, LockBuilder);
Launcher = new Launcher();
LaunchLockProcess =
new Library.LaunchLockProcess(
Configuration,
LockFinder,
LockReader,
LockBuilder,
LockWriter,
Communicator,
FileSystem,
Unlocker,
Launcher);
Intialize();
}
public async Task RescanLocationAsync_RemovesScannedFilesNotFoundInDiretory()
{
// ARRANGE
MockFileSystem fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"C:\foobar");
Mock <IFileHashService> service = new Mock <IFileHashService>();
ScannedFileStore scannedFileStore = new ScannedFileStore(fileSystem, service.Object);
MockScannedFileStoreProgress progress = new MockScannedFileStoreProgress();
List <string> locations = new List <string>()
{
@"C:\foobar"
};
service.Setup(t => t.ListScannedFilePathsAsync(It.IsAny <List <string> >())).ReturnsAsync((List <string> locs) =>
{
return(new List <string>()
{
@"C:\foobar\foo.bar"
});
});
// ACT
await scannedFileStore.RescanLocationsAsync(locations, progress);
// ASSERT
service.Verify(t => t.RemoveScannedFilesByFilePathAsync(It.Is <string>(s => s.Equals(@"C:\foobar\foo.bar"))));
}
public void AddLargestNumber()
{
const string inputDir = @"d:\root\in";
const string inputFileName = @"myfile.csv";
var inputFilePath = Path.Combine(inputDir, inputFileName);
const string outputDir = @"d:\root\out";
const string outputFileName = @"myfileout.csv";
var outputFilePath = Path.Combine(outputDir, outputFileName);
var csvLines = new StringBuilder();
csvLines.AppendLine("OrderNumber,CustomerNumber,Description,Quantity");
csvLines.AppendLine("42, 100001, Shirt, II");
csvLines.AppendLine("43, 200002, Shorts, I");
csvLines.AppendLine("@ This is a comment");
csvLines.AppendLine("");
csvLines.AppendLine("44, 300003, Cap, V");
var mockFileInput = new MockFileData(csvLines.ToString());
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddFile(inputFilePath, mockFileInput);
mockFileSystem.AddDirectory(outputDir);
var sut = new CsvFileProcessor(inputFilePath, outputFilePath, mockFileSystem);
sut.Process();
Assert.True(mockFileSystem.FileExists(outputFilePath));
MockFileData processedFile = mockFileSystem.GetFile(outputFilePath);
Approvals.Verify(processedFile.TextContents);
}
private static MockFileSystem CreateVirtualFileSystemWithFolder(string folder)
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(folder);
return(fileSystem);
}
public static MockFileSystem CreateMockFileSystem()
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"C:\");
return(fileSystem);
}
public IFileSystem GetFileSystem()
{
MockFileSystem fs = new MockFileSystem();
fs.AddFile(@"C:\test\staticsql.json", new MockFileData("{ \"entity_folder\": \"StaticSQL\"}"));
fs.AddDirectory(@"C:\test\subfolder");
fs.AddFile(@"C:\test\StaticSQL\entity.json", new MockFileData("{\"attributes\": \"\"}"));
fs.AddDirectory(@"C:\empty");
fs.AddFile(@"C:\double\staticsql1.json", new MockFileData("{ \"entity_folder\": \"StaticSQL\"}"));
fs.AddFile(@"C:\double\staticsql2.json", new MockFileData("{ \"entity_folder\": \"StaticSQL\"}"));
return fs;
}
public void It_should_create_limelight_image_directory_if_it_does_not_exist()
{
_fileSystemMock.AddDirectory(Constants.SpotlightImageDirectoryPath);
_spotlightImageSaver.Save();
Assert.AreEqual(true, _fileSystemMock.Directory.Exists(Constants.LimelightImageDirectoryPath));
}
public void MockDirectory_EnumerateDirectories_WithTopDirectories_ShouldOnlyReturnTopDirectories()
{
// Arrange
MockFileSystem fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo.foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\.foo"));
fileSystem.AddFile(XFS.Path(@"C:\Folder\.foo\bar"), new MockFileData(string.Empty));
// Act
IEnumerable <string> actualResult = fileSystem.Directory.EnumerateDirectories(XFS.Path(@"c:\Folder\"), "*.foo");
// Assert
Assert.Equal(actualResult, new[] { XFS.Path(@"C:\Folder\.foo\"), XFS.Path(@"C:\Folder\foo.foo\") });
}
public void MockDirectory_GetDirectories_WithAllDirectories_ShouldReturnsAllMatchingSubFolders()
{
// Arrange
MockFileSystem fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo.foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\.foo"));
fileSystem.AddFile(XFS.Path(@"C:\Folder\.foo\bar"), new MockFileData(string.Empty));
// Act
string[] actualResult = fileSystem.Directory.GetDirectories(XFS.Path(@"c:\Folder\"), "*.foo", SearchOption.AllDirectories);
// Assert
Assert.Equal(actualResult, new[] { XFS.Path(@"C:\Folder\.foo\"), XFS.Path(@"C:\Folder\foo.foo\"), XFS.Path(@"C:\Folder\.foo\.foo\") });
}
public void SetUp()
{
_filesystem = new MockFileSystem();
_filesystem.AddDirectory(SDKUtil.GetUserConfigPath());
_jsonUtil = new JsonUtil(_filesystem);
_configFactory = new SdkConfig.Factory(_jsonUtil);
}
public void MockDriveInfoFactory_GetDrives_ShouldReturnDrives()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Test"));
fileSystem.AddDirectory(XFS.Path(@"Z:\Test"));
fileSystem.AddDirectory(XFS.Path(@"d:\Test"));
var factory = new MockDriveInfoFactory(fileSystem);
// Act
var actualResults = factory.GetDrives();
var actualNames = actualResults.Select(d => d.Name);
// Assert
Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" }));
}
public void MockFile_Delete_No_File_Does_Nothing()
{
const string filePath = @"c:\something\demo.txt";
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(fileSystem.Path.GetDirectoryName(filePath));
fileSystem.File.Delete(filePath);
}
public void MockDirectory_GetDirectories_WithTopDirectories_ShouldOnlyReturnTopDirectories()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo.foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\.foo"));
fileSystem.AddFile(XFS.Path(@"C:\Folder\.foo\bar"), new MockFileData(string.Empty));
// Act
var actualResult = fileSystem.Directory.GetDirectories(XFS.Path(@"c:\Folder\"), "*.foo");
// Assert
Assert.That(actualResult, Is.EquivalentTo(new [] { XFS.Path(@"C:\Folder\.foo\"), XFS.Path(@"C:\Folder\foo.foo\") }));
}
public void MockFileSystem_AddFile_ShouldMatchCapitalization_PerfectMatch()
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\test"));
fileSystem.AddDirectory(XFS.Path(@"C:\LOUD"));
fileSystem.AddFile(XFS.Path(@"C:\test\file.txt"), "foo");
fileSystem.AddFile(XFS.Path(@"C:\LOUD\file.txt"), "foo");
fileSystem.AddDirectory(XFS.Path(@"C:\test\SUBDirectory"));
fileSystem.AddDirectory(XFS.Path(@"C:\LOUD\SUBDirectory"));
Assert.Contains(XFS.Path(@"C:\test\file.txt"), fileSystem.AllFiles.ToList());
Assert.Contains(XFS.Path(@"C:\LOUD\file.txt"), fileSystem.AllFiles.ToList());
Assert.Contains(XFS.Path(@"C:\test\SUBDirectory"), fileSystem.AllDirectories.ToList());
Assert.Contains(XFS.Path(@"C:\LOUD\SUBDirectory"), fileSystem.AllDirectories.ToList());
}
public void MockDirectory_EnumerateDirectories_WithAllDirectories_ShouldReturnsAllMatchingSubFolders()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo.foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\.foo"));
fileSystem.AddFile(XFS.Path(@"C:\Folder\.foo\bar"), new MockFileData(string.Empty));
// Act
var actualResult = fileSystem.Directory.EnumerateDirectories(XFS.Path(@"c:\Folder\"), "*.foo", SearchOption.AllDirectories);
// Assert
Assert.That(actualResult, Is.EquivalentTo(new[] { XFS.Path(@"C:\Folder\.foo\"), XFS.Path(@"C:\Folder\foo.foo\"), XFS.Path(@"C:\Folder\.foo\.foo\") }));
}
public void MockFileSystem_AddFile_ShouldMatchCapitalization_PartialMatch_FurtherLeft()
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\test\subtest"));
fileSystem.AddDirectory(XFS.Path(@"C:\LOUD\SUBLOUD"));
fileSystem.AddFile(XFS.Path(@"C:\test\SUBTEST\new\file.txt"), "foo");
fileSystem.AddFile(XFS.Path(@"C:\LOUD\subloud\new\file.txt"), "foo");
fileSystem.AddDirectory(XFS.Path(@"C:\test\SUBTEST\new\SUBDirectory"));
fileSystem.AddDirectory(XFS.Path(@"C:\LOUD\subloud\new\SUBDirectory"));
Assert.Contains(XFS.Path(@"C:\test\subtest\new\file.txt"), fileSystem.AllFiles.ToList());
Assert.Contains(XFS.Path(@"C:\LOUD\SUBLOUD\new\file.txt"), fileSystem.AllFiles.ToList());
Assert.Contains(XFS.Path(@"C:\test\subtest\new\SUBDirectory"), fileSystem.AllDirectories.ToList());
Assert.Contains(XFS.Path(@"C:\LOUD\SUBLOUD\new\SUBDirectory"), fileSystem.AllDirectories.ToList());
}
public void MockFileSystem_AddDirectory_ShouldCreateDirectory()
{
string baseDirectory = XFS.Path(@"C:\Test");
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(baseDirectory);
Assert.IsTrue(fileSystem.Directory.Exists(baseDirectory));
}
public void MockDriveInfoFactory_GetDrives_ShouldReturnDrives()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Test"));
fileSystem.AddDirectory(XFS.Path(@"Z:\Test"));
fileSystem.AddDirectory(XFS.Path(@"d:\Test"));
var factory = new MockDriveInfoFactory(fileSystem);
// Act
var actualResults = factory.GetDrives();
var actualNames = actualResults.Select(d => d.Name);
// Assert
actualNames.Should().BeEquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" });
}
public void MockFileSystem_AddDirectory_TrailingSlashAllowedButNotRequired(string path)
{
var fileSystem = new MockFileSystem();
var path2 = XFS.Path(path);
fileSystem.AddDirectory(path2);
Assert.IsTrue(fileSystem.FileExists(path2));
}
public void MockDriveInfo_Constructor_ShouldInitializeLocalWindowsDrives(string driveName)
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"c:\Test"));
var path = XFS.Path(driveName);
// Act
var driveInfo = new MockDriveInfo(fileSystem, path);
// Assert
Assert.AreEqual(@"C:\", driveInfo.Name);
}
public void MockDriveInfo_RootDirectory_ShouldReturnTheDirectoryBase()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"c:\Test"));
var driveInfo = new MockDriveInfo(fileSystem, "c:");
var expectedDirectory = XFS.Path(@"C:\");
// Act
var actualDirectory = driveInfo.RootDirectory;
// Assert
Assert.AreEqual(expectedDirectory, actualDirectory.FullName);
}
public void MockFile_AppendAllText_ShouldCreateIfNotExistWithBom()
{
// Arrange
var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());
const string path = @"c:\something\demo3.txt";
fileSystem.AddDirectory(@"c:\something\");
// Act
fileSystem.File.AppendAllText(path, "AA", Encoding.UTF32);
// Assert
CollectionAssert.AreEqual(
new byte[] {255, 254, 0, 0, 65, 0, 0, 0, 65, 0, 0, 0},
fileSystem.GetFile(path).Contents);
}
public void MockFile_WriteAllBytes_ShouldWriteDataToMemoryFileSystem()
{
// Arrange
string path = XFS.Path(@"c:\something\demo.txt");
var fileSystem = new MockFileSystem();
var fileContent = new byte[] { 1, 2, 3, 4 };
fileSystem.AddDirectory(@"c:\something");
// Act
fileSystem.File.WriteAllBytes(path, fileContent);
// Assert
Assert.AreEqual(
fileContent,
fileSystem.GetFile(path).Contents);
}
public void MockFile_WriteAllText_ShouldWriteTextFileToMemoryFileSystem()
{
// Arrange
string path = XFS.Path(@"c:\something\demo.txt");
string fileContent = "Hello there!";
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"c:\something");
// Act
fileSystem.File.WriteAllText(path, fileContent);
// Assert
Assert.AreEqual(
fileContent,
fileSystem.GetFile(path).TextContents);
}
public void MockFile_WriteAllText_ShouldOverriteAnExistingFile()
{
// http://msdn.microsoft.com/en-us/library/ms143375.aspx
// Arrange
string path = XFS.Path(@"c:\something\demo.txt");
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"c:\something");
// Act
fileSystem.File.WriteAllText(path, "foo");
fileSystem.File.WriteAllText(path, "bar");
// Assert
Assert.AreEqual("bar", fileSystem.GetFile(path).TextContents);
}
public void MockFile_WriteAllText_ShouldNotThrowAnArgumentNullExceptionIfTheContentIsNull()
{
// Arrange
var fileSystem = new MockFileSystem();
string directoryPath = XFS.Path(@"c:\something");
string filePath = XFS.Path(@"c:\something\demo.txt");
fileSystem.AddDirectory(directoryPath);
// Act
fileSystem.File.WriteAllText(filePath, null);
// Assert
// no exception should be thrown, also the documentation says so
var data = fileSystem.GetFile(filePath);
Assert.That(data.Contents, Is.Empty);
}
public void MockDriveInfo_Constructor_ShouldInitializeLocalWindowsDrives_SpecialForWindows()
{
if (XFS.IsUnixPlatform())
{
Assert.Inconclusive("Using XFS.Path transform c into c:.");
}
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"c:\Test"));
// Act
var driveInfo = new MockDriveInfo(fileSystem, "c");
// Assert
Assert.AreEqual(@"C:\", driveInfo.Name);
}
public void MockFileSystem_AddDirectory_ShouldCreateDirectory()
{
// Arrange
string baseDirectory = MockUnixSupport.Path(@"C:\Test");
var fileSystem = new MockFileSystem();
// Act
fileSystem.AddDirectory(baseDirectory);
// Assert
Assert.IsTrue(fileSystem.Directory.Exists(baseDirectory));
}
public void MockFileSystem_AddDirectory_ShouldThrowExceptionIfDirectoryIsReadOnly()
{
// Arrange
const string baseDirectory = @"C:\Test";
var fileSystem = new MockFileSystem();
fileSystem.AddFile(baseDirectory, new MockFileData(string.Empty));
fileSystem.File.SetAttributes(baseDirectory, FileAttributes.ReadOnly);
// Act
TestDelegate act = () => fileSystem.AddDirectory(baseDirectory);
// Assert
Assert.Throws<UnauthorizedAccessException>(act);
}
public void MockFile_ReadAllBytes_ShouldReturnDataSavedByWriteAllBytes()
{
// Arrange
string path = XFS.Path(@"c:\something\demo.txt");
var fileSystem = new MockFileSystem();
var fileContent = new byte[] { 1, 2, 3, 4 };
fileSystem.AddDirectory(@"c:\something");
// Act
fileSystem.File.WriteAllBytes(path, fileContent);
// Assert
Assert.AreEqual(
fileContent,
fileSystem.File.ReadAllBytes(path));
}
public void MockDirectoryInfo_GetParent_ShouldReturnDirectoriesAndNamesWithSearchPattern()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"c:\a\b\c"));
var directoryInfo = new MockDirectoryInfo(fileSystem, XFS.Path(@"c:\a\b\c"));
// Act
var result = directoryInfo.Parent;
// Assert
Assert.AreEqual(XFS.Path(@"c:\a\b"), result.FullName);
}
public void Move_DirectoryExistsWithDifferentCase_DirectorySuccessfullyMoved()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"C:\OLD_LOCATION\Data");
fileSystem.AddFile(@"C:\old_location\Data\someFile.txt", new MockFileData("abc"));
// Act
fileSystem.Directory.Move(@"C:\old_location", @"C:\NewLocation\");
// Assert
Assert.IsTrue(fileSystem.File.Exists(@"C:\NewLocation\Data\someFile.txt"));
}
public void MockFile_WriteAllTextMultipleLines_ShouldWriteTextFileToMemoryFileSystem()
{
// Arrange
string path = XFS.Path(@"c:\something\demo.txt");
var fileContent = new List<string> {"Hello there!", "Second line!"};
var expected = "Hello there!" + Environment.NewLine + "Second line!" + Environment.NewLine;
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"c:\something");
// Act
fileSystem.File.WriteAllLines(path, fileContent);
// Assert
Assert.AreEqual(
expected,
fileSystem.GetFile(path).TextContents);
}
public void MockDirectory_GetFiles_ShouldThrowAnArgumentException_IfSearchPatternHasIllegalCharacters(string searchPattern)
{
// Arrange
var directoryPath = XFS.Path(@"c:\Foo");
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(directoryPath);
// Act
TestDelegate action = () => fileSystem.Directory.GetFiles(directoryPath, searchPattern);
// Assert
Assert.Throws<ArgumentException>(action);
}
public void MockDirectory_GetFiles_ShouldThrowAnArgumentException_IfSearchPatternEndsWithTwoDots()
{
// Arrange
var directoryPath = XFS.Path(@"c:\Foo");
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(directoryPath);
// Act
TestDelegate action = () => fileSystem.Directory.GetFiles(directoryPath, "*a..");
// Assert
Assert.Throws<ArgumentException>(action);
}
public void MockDirectory_Move_ShouldThrowAnIOExceptionIfDirectoriesAreOnDifferentVolumes()
{
// Arrange
string sourcePath = XFS.Path(@"c:\a");
string destPath = XFS.Path(@"d:\v");
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(sourcePath);
// Act
TestDelegate action = () => fileSystem.Directory.Move(sourcePath, destPath);
// Assert
Assert.Throws<IOException>(action, "Source and destination path must have identical roots. Move will not work across volumes.");
}
public void MockDirectory_Move_ShouldThrowAnIOExceptionIfBothPathAreIdentical()
{
// Arrange
string path = XFS.Path(@"c:\a");
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(path);
// Act
TestDelegate action = () => fileSystem.Directory.Move(path, path);
// Assert
Assert.Throws<IOException>(action, "Source and destination path must be different.");
}
public void MockDirectory_GetParent_ShouldReturnNullIfPathIsRoot()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"c:\"));
// Act
var actualResult = fileSystem.Directory.GetParent(XFS.Path(@"c:\"));
// Assert
Assert.IsNull(actualResult);
}
public void MockFile_WriteAllText_ShouldThrowAnUnauthorizedAccessExceptionIfThePathIsOneDirectory()
{
// Arrange
var fileSystem = new MockFileSystem();
string directoryPath = XFS.Path(@"c:\something");
fileSystem.AddDirectory(directoryPath);
// Act
TestDelegate action = () => fileSystem.File.WriteAllText(directoryPath, null);
// Assert
Assert.Throws<UnauthorizedAccessException>(action);
}
public void MockDirectory_GetDirectories_WithTopDirectories_ShouldOnlyReturnTopDirectories()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo.foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\.foo"));
fileSystem.AddFile(XFS.Path(@"C:\Folder\.foo\bar"), new MockFileData(string.Empty));
// Act
var actualResult = fileSystem.Directory.GetDirectories(XFS.Path(@"c:\Folder\"), "*.foo");
// Assert
Assert.That(actualResult, Is.EquivalentTo(new []{XFS.Path(@"C:\Folder\.foo\"), XFS.Path(@"C:\Folder\foo.foo\")}));
}
public void MockFile_WriteAllText_Encoding_ShouldWriteTextFileToMemoryFileSystem(KeyValuePair<Encoding, byte[]> encodingsWithContents)
{
// Arrange
const string FileContent = "Hello there! Dzięki.";
string path = XFS.Path(@"c:\something\demo.txt");
byte[] expectedBytes = encodingsWithContents.Value;
Encoding encoding = encodingsWithContents.Key;
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"c:\something");
// Act
fileSystem.File.WriteAllText(path, FileContent, encoding);
// Assert
var actualBytes = fileSystem.GetFile(path).Contents;
Assert.AreEqual(expectedBytes, actualBytes);
}
public void MockDirectory_EnumerateDirectories_WithAllDirectories_ShouldReturnsAllMatchingSubFolders()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\foo.foo"));
fileSystem.AddDirectory(XFS.Path(@"C:\Folder\.foo\.foo"));
fileSystem.AddFile(XFS.Path(@"C:\Folder\.foo\bar"), new MockFileData(string.Empty));
// Act
var actualResult = fileSystem.Directory.EnumerateDirectories(XFS.Path(@"c:\Folder\"), "*.foo", SearchOption.AllDirectories);
// Assert
Assert.That(actualResult, Is.EquivalentTo(new[] { XFS.Path(@"C:\Folder\.foo\"), XFS.Path(@"C:\Folder\foo.foo\"), XFS.Path(@"C:\Folder\.foo\.foo\") }));
}
public void MockDirectory_GetParent_ShouldReturnTheParentWithoutTrailingDirectorySeparatorChar(string path, string expectedResult)
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(path);
// Act
var actualResult = fileSystem.Directory.GetParent(path);
// Assert
Assert.AreEqual(expectedResult, actualResult.FullName);
}
public void MockFile_GetAttributeOfNonExistantFileButParentDirectoryExists_ShouldThrowOneFileNotFoundException()
{
// Arrange
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(XFS.Path(@"c:\something"));
// Act
TestDelegate action = () => fileSystem.File.GetAttributes(XFS.Path(@"c:\something\demo.txt"));
// Assert
Assert.Throws<FileNotFoundException>(action);
}