public static void ModifiedPathsShouldNotContain(FileSystemRunner fileSystem, string dotGVFSRoot, params string[] gitPaths) { string modifiedPathsDatabase = Path.Combine(dotGVFSRoot, TestConstants.Databases.ModifiedPaths); modifiedPathsDatabase.ShouldBeAFile(fileSystem); GVFSHelpers.ReadAllTextFromWriteLockedFile(modifiedPathsDatabase).ShouldNotContain(ignoreCase: true, unexpectedSubstrings: gitPaths); }
public string GetObjectRoot(FileSystemRunner fileSystem) { string mappingFile = Path.Combine(this.LocalCacheRoot, "mapping.dat"); mappingFile.ShouldBeAFile(fileSystem); HashSet <string> allowedFileNames = new HashSet <string>(FileSystemHelpers.PathComparer) { "mapping.dat", "mapping.dat.lock" // mapping.dat.lock can be present, but doesn't have to be present }; this.LocalCacheRoot.ShouldBeADirectory(fileSystem).WithFiles().ShouldNotContain(f => !allowedFileNames.Contains(f.Name)); string mappingFileContents = File.ReadAllText(mappingFile); mappingFileContents.ShouldNotBeNull(); string[] objectRootEntries = mappingFileContents.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries) .Where(x => x.IndexOf(this.RepoUrl, StringComparison.OrdinalIgnoreCase) >= 0) .ToArray(); objectRootEntries.Length.ShouldEqual(1, $"Should be only one entry for repo url: {this.RepoUrl} mapping file content: {mappingFileContents}"); objectRootEntries[0].Substring(0, 2).ShouldEqual("A ", $"Invalid mapping entry for repo: {objectRootEntries[0]}"); JObject rootEntryJson = JObject.Parse(objectRootEntries[0].Substring(2)); string objectRootFolder = rootEntryJson.GetValue("Value").ToString(); objectRootFolder.ShouldNotBeNull(); objectRootFolder.Length.ShouldBeAtLeast(1, $"Invalid object root folder: {objectRootFolder} for {this.RepoUrl} mapping file content: {mappingFileContents}"); return(Path.Combine(this.LocalCacheRoot, objectRootFolder, "gitObjects")); }
public void CloneWithDefaultLocalCacheLocation() { FileSystemRunner fileSystem = FileSystemRunner.DefaultRunner; string homeDirectory = Environment.GetEnvironmentVariable("HOME"); homeDirectory.ShouldBeADirectory(fileSystem); string newEnlistmentRoot = GVFSFunctionalTestEnlistment.GetUniqueEnlistmentRoot(); ProcessStartInfo processInfo = new ProcessStartInfo(GVFSTestConfig.PathToGVFS); processInfo.Arguments = $"clone {Properties.Settings.Default.RepoToClone} {newEnlistmentRoot} --no-mount --no-prefetch"; processInfo.WindowStyle = ProcessWindowStyle.Hidden; processInfo.CreateNoWindow = true; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = true; ProcessResult result = ProcessHelper.Run(processInfo); result.ExitCode.ShouldEqual(0, result.Errors); string dotGVFSRoot = Path.Combine(newEnlistmentRoot, ".gvfs"); dotGVFSRoot.ShouldBeADirectory(fileSystem); string localCacheRoot = GVFSHelpers.GetPersistedLocalCacheRoot(dotGVFSRoot); string gitObjectsRoot = GVFSHelpers.GetPersistedGitObjectsRoot(dotGVFSRoot); string defaultGVFSCacheRoot = Path.Combine(homeDirectory, ".gvfsCache"); localCacheRoot.StartsWith(defaultGVFSCacheRoot, StringComparison.Ordinal).ShouldBeTrue($"Local cache root did not default to using {homeDirectory}"); gitObjectsRoot.StartsWith(defaultGVFSCacheRoot, StringComparison.Ordinal).ShouldBeTrue($"Git objects root did not default to using {homeDirectory}"); RepositoryHelpers.DeleteTestDirectory(newEnlistmentRoot); }
public static void ModifiedPathsContentsShouldEqual(FileSystemRunner fileSystem, string dotGVFSRoot, string contents) { string modifiedPathsDatabase = Path.Combine(dotGVFSRoot, TestConstants.Databases.ModifiedPaths); modifiedPathsDatabase.ShouldBeAFile(fileSystem); GVFSHelpers.ReadAllTextFromWriteLockedFile(modifiedPathsDatabase).ShouldEqual(contents); }
public void ModifiedPathsCorrectAfterHardLinkingInsideRepo(FileSystemRunner fileSystem) { string[] expectedModifiedFilesContentsAfterHardlinks = { "A .gitattributes", "A LinkToReadme.md", "A Readme.md", }; // Create a link from src\LinkToReadme.md to src\Readme.md string existingFileInRepoPath = this.Enlistment.GetVirtualPathTo("Readme.md"); string contents = existingFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(); string hardLinkToFileInRepoPath = this.Enlistment.GetVirtualPathTo("LinkToReadme.md"); hardLinkToFileInRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.CreateHardLink(hardLinkToFileInRepoPath, existingFileInRepoPath); hardLinkToFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(contents); this.Enlistment.WaitForBackgroundOperations(); string modifiedPathsDatabase = Path.Combine(this.Enlistment.DotGVFSRoot, TestConstants.Databases.ModifiedPaths); modifiedPathsDatabase.ShouldBeAFile(fileSystem); using (StreamReader reader = new StreamReader(File.Open(modifiedPathsDatabase, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { reader.ReadToEnd().Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).OrderBy(x => x) .ShouldMatchInOrder(expectedModifiedFilesContentsAfterHardlinks.OrderBy(x => x)); } }
public MountTests() { this.fileSystem = new SystemIORunner(); this.fileDeletedBackgroundOperationCode = 3; this.directoryDeletedBackgroundOperationCode = 11; }
private string CreateDirectory(FileSystemRunner fileSystem, string relativePath) { string tempFolder = this.Enlistment.GetVirtualPathTo(relativePath); fileSystem.CreateDirectory(tempFolder); tempFolder.ShouldBeADirectory(fileSystem); return(tempFolder); }
public static void ModifiedPathsShouldContain(FileSystemRunner fileSystem, string dotGVFSRoot, params string[] gitPaths) { string modifiedPathsDatabase = Path.Combine(dotGVFSRoot, TestConstants.Databases.ModifiedPaths); modifiedPathsDatabase.ShouldBeAFile(fileSystem); GVFSHelpers.ReadAllTextFromWriteLockedFile(modifiedPathsDatabase).ShouldContain( gitPaths.Select(path => path + ModifiedPathsNewLine).ToArray()); }
private string CreateFile(FileSystemRunner fileSystem, string relativePath) { string tempFile = this.Enlistment.GetVirtualPathTo(relativePath); fileSystem.WriteAllText(tempFile, $"Contents for the {relativePath} file"); tempFile.ShouldBeAFile(fileSystem); return(tempFile); }
public void PrefetchIsAllowedToDoNothing(FileSystemRunner fileSystem) { string output = this.Enlistment.PrefetchFolder("NoFileHasThisName.IHope"); output.ShouldContain("\"TotalMissingObjects\":0"); // It is expected to have .gitattributes files always. But that is all. this.AllFetchedFilePathsShouldPassCheck(file => file.Equals(".gitattributes", StringComparison.OrdinalIgnoreCase)); }
public string GetObjectRoot(FileSystemRunner fileSystem) { IEnumerable <FileSystemInfo> localCacheRootItems = this.LocalCacheRoot.ShouldBeADirectory(fileSystem).WithItems(); localCacheRootItems.Count().ShouldEqual(2, "Expected local cache root to contain 2 items. Actual items: " + string.Join(",", localCacheRootItems)); DirectoryInfo[] directories = localCacheRootItems.Where(info => info is DirectoryInfo).Cast <DirectoryInfo>().ToArray(); directories.Length.ShouldEqual(1, this.LocalCacheRoot + " is expected to have only one folder. Actual: " + directories.Count()); return(Path.Combine(directories[0].FullName, "gitObjects")); }
public void DeletedTempFolderIsRemovedFromModifiedFiles(FileSystemRunner fileSystem) { string tempFolder = this.CreateDirectory(fileSystem, "Temp"); fileSystem.DeleteDirectory(tempFolder); tempFolder.ShouldNotExistOnDisk(fileSystem); GVFSHelpers.ModifiedPathsShouldNotContain(this.Enlistment, fileSystem, "Temp/"); }
public void CaseRenameFoldersAndRemountAndReanmeAgain(FileSystemRunner fileSystem) { // Projected folder without a physical folder string parentFolderName = "GVFS"; string oldGVFSSubFolderName = "GVFS"; string oldGVFSSubFolderPath = Path.Combine(parentFolderName, oldGVFSSubFolderName); string newGVFSSubFolderName = "gvfs"; string newGVFSSubFolderPath = Path.Combine(parentFolderName, newGVFSSubFolderName); this.Enlistment.GetVirtualPathTo(oldGVFSSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(oldGVFSSubFolderName); // Use NativeMethods rather than the runner as it supports case-only rename NativeMethods.MoveFile(this.Enlistment.GetVirtualPathTo(oldGVFSSubFolderPath), this.Enlistment.GetVirtualPathTo(newGVFSSubFolderPath)); this.Enlistment.GetVirtualPathTo(newGVFSSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(newGVFSSubFolderName); // Projected folder with a physical folder string oldTestsSubFolderName = "GVFS.FunctionalTests"; string oldTestsSubFolderPath = Path.Combine(parentFolderName, oldTestsSubFolderName); string newTestsSubFolderName = "gvfs.functionaltests"; string newTestsSubFolderPath = Path.Combine(parentFolderName, newTestsSubFolderName); string fileToAdd = "NewFile.txt"; string fileToAddContent = "This is new file text."; string fileToAddPath = this.Enlistment.GetVirtualPathTo(Path.Combine(oldTestsSubFolderPath, fileToAdd)); fileSystem.WriteAllText(fileToAddPath, fileToAddContent); this.Enlistment.GetVirtualPathTo(oldTestsSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(oldTestsSubFolderName); // Use NativeMethods rather than the runner as it supports case-only rename NativeMethods.MoveFile(this.Enlistment.GetVirtualPathTo(oldTestsSubFolderPath), this.Enlistment.GetVirtualPathTo(newTestsSubFolderPath)); this.Enlistment.GetVirtualPathTo(newTestsSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(newTestsSubFolderName); // Remount this.Enlistment.UnmountGVFS(); this.Enlistment.MountGVFS(); this.Enlistment.GetVirtualPathTo(newGVFSSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(newGVFSSubFolderName); this.Enlistment.GetVirtualPathTo(newTestsSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(newTestsSubFolderName); this.Enlistment.GetVirtualPathTo(Path.Combine(newTestsSubFolderPath, fileToAdd)).ShouldBeAFile(fileSystem).WithContents().ShouldEqual(fileToAddContent); // Rename each folder again string finalGVFSSubFolderName = "gvFS"; string finalGVFSSubFolderPath = Path.Combine(parentFolderName, finalGVFSSubFolderName); NativeMethods.MoveFile(this.Enlistment.GetVirtualPathTo(newGVFSSubFolderPath), this.Enlistment.GetVirtualPathTo(finalGVFSSubFolderPath)); this.Enlistment.GetVirtualPathTo(finalGVFSSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(finalGVFSSubFolderName); string finalTestsSubFolderName = "gvfs.FunctionalTESTS"; string finalTestsSubFolderPath = Path.Combine(parentFolderName, finalTestsSubFolderName); NativeMethods.MoveFile(this.Enlistment.GetVirtualPathTo(newTestsSubFolderPath), this.Enlistment.GetVirtualPathTo(finalTestsSubFolderPath)); this.Enlistment.GetVirtualPathTo(finalTestsSubFolderPath).ShouldBeADirectory(fileSystem).WithCaseMatchingName(finalTestsSubFolderName); this.Enlistment.GetVirtualPathTo(Path.Combine(finalTestsSubFolderPath, fileToAdd)).ShouldBeAFile(fileSystem).WithContents().ShouldEqual(fileToAddContent); }
public void CanReadHydratedPlaceholderInParallel() { FileSystemRunner fileSystem = FileSystemRunner.DefaultRunner; string fileName = Path.Combine("GVFS", "GVFS.FunctionalTests", "Tests", "LongRunningEnlistment", "WorkingDirectoryTests.cs"); string virtualPath = this.Enlistment.GetVirtualPathTo(fileName); virtualPath.ShouldBeAFile(fileSystem); // Not using the runner because reading specific bytes isn't common // Can't use ReadAllText because it will remove some bytes that the stream won't. byte[] actualContents = File.ReadAllBytes(virtualPath); Thread[] threads = new Thread[4]; // Readers bool keepRunning = true; for (int i = 0; i < threads.Length; ++i) { int myIndex = i; threads[i] = new Thread(() => { // Create random seeks (seeded for repeatability) Random randy = new Random(myIndex); // Small buffer so we hit the drive a lot. // Block larger than the buffer to hit the drive more const int SmallBufferSize = 128; const int LargerBlockSize = SmallBufferSize * 10; using (Stream reader = new FileStream(virtualPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, SmallBufferSize, false)) { while (keepRunning) { byte[] block = new byte[LargerBlockSize]; // Always try to grab a full block (easier for asserting) int position = randy.Next((int)reader.Length - block.Length - 1); reader.Position = position; reader.Read(block, 0, block.Length).ShouldEqual(block.Length); block.ShouldEqual(actualContents, position, block.Length); } } }); threads[i].Start(); } Thread.Sleep(2500); keepRunning = false; for (int i = 0; i < threads.Length; ++i) { threads[i].Join(); } }
public UpgradeReminderTests() { this.fileSystem = new SystemIORunner(); this.upgradeDownloadsDirectory = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData, Environment.SpecialFolderOption.Create), "GVFS", "GVFS.Upgrade", "Downloads"); }
public void DeletedTempFileIsRemovedFromModifiedFiles(FileSystemRunner fileSystem) { string tempFile = this.CreateFile(fileSystem, "temp.txt"); fileSystem.DeleteFile(tempFile); tempFile.ShouldNotExistOnDisk(fileSystem); GVFSHelpers.ModifiedPathsShouldNotContain(this.Enlistment, fileSystem, "temp.txt"); }
public DirectoryAdapter WithDeepStructure( FileSystemRunner fileSystem, string otherPath, bool ignoreCase = false, bool compareContent = false) { otherPath.ShouldBeADirectory(this.runner); CompareDirectories(fileSystem, otherPath, this.Path, ignoreCase, compareContent); return(this); }
public void DeletedTempFolderIsRemovedFromModifiedFiles(FileSystemRunner fileSystem) { string tempFolder = this.CreateDirectory(fileSystem, "Temp"); fileSystem.DeleteDirectory(tempFolder); tempFolder.ShouldNotExistOnDisk(fileSystem); this.Enlistment.UnmountGVFS(); this.ValidateModifiedPathsDoNotContain(fileSystem, "Temp/"); }
public void DeletedTempFileIsRemovedFromModifiedFiles(FileSystemRunner fileSystem) { string tempFile = this.CreateFile(fileSystem, "temp.txt"); fileSystem.DeleteFile(tempFile); tempFile.ShouldNotExistOnDisk(fileSystem); this.Enlistment.UnmountGVFS(); this.ValidateModifiedPathsDoNotContain(fileSystem, "temp.txt"); }
public void DeletedTempFolderDeletesFilesFromModifiedFiles(FileSystemRunner fileSystem) { string tempFolder = this.CreateDirectory(fileSystem, "Temp"); string tempFile1 = this.CreateFile(fileSystem, Path.Combine("Temp", "temp1.txt")); string tempFile2 = this.CreateFile(fileSystem, Path.Combine("Temp", "temp2.txt")); fileSystem.DeleteDirectory(tempFolder); tempFolder.ShouldNotExistOnDisk(fileSystem); tempFile1.ShouldNotExistOnDisk(fileSystem); tempFile2.ShouldNotExistOnDisk(fileSystem); GVFSHelpers.ModifiedPathsShouldNotContain(this.Enlistment, fileSystem, "Temp/", "Temp/temp1.txt", "Temp/temp2.txt"); }
public static void ModifiedPathsShouldContain(FileSystemRunner fileSystem, string dotGVFSRoot, params string[] gitPaths) { string modifiedPathsDatabase = Path.Combine(dotGVFSRoot, TestConstants.Databases.ModifiedPaths); modifiedPathsDatabase.ShouldBeAFile(fileSystem); string modifedPathsContents = GVFSHelpers.ReadAllTextFromWriteLockedFile(modifiedPathsDatabase); string[] modifedPathLines = modifedPathsContents.Split(new[] { ModifiedPathsNewLine }, StringSplitOptions.None); foreach (string gitPath in gitPaths) { modifedPathLines.ShouldContain(path => path.Equals(ModifedPathsLineAddPrefix + gitPath)); } }
public void ModifiedPathsCorrectAfterHardLinking(FileSystemRunner fileSystem) { string[] expectedModifiedFilesContentsAfterHardlinks = { "A .gitattributes", "A LinkToReadme.md", "A LinkToFileOutsideSrc.txt", }; // Create a link from src\LinkToReadme.md to src\Readme.md string existingFileInRepoPath = this.Enlistment.GetVirtualPathTo("Readme.md"); string contents = existingFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(); string hardLinkToFileInRepoPath = this.Enlistment.GetVirtualPathTo("LinkToReadme.md"); hardLinkToFileInRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.CreateHardLink(hardLinkToFileInRepoPath, existingFileInRepoPath); hardLinkToFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(contents); // Create a link from src\LinkToFileOutsideSrc.txt to FileOutsideRepo.txt string fileOutsideOfRepoPath = Path.Combine(this.Enlistment.EnlistmentRoot, "FileOutsideRepo.txt"); string fileOutsideOfRepoContents = "File outside of repo"; fileOutsideOfRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.WriteAllText(fileOutsideOfRepoPath, fileOutsideOfRepoContents); string hardLinkToFileOutsideRepoPath = this.Enlistment.GetVirtualPathTo("LinkToFileOutsideSrc.txt"); hardLinkToFileOutsideRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.CreateHardLink(hardLinkToFileOutsideRepoPath, fileOutsideOfRepoPath); hardLinkToFileOutsideRepoPath.ShouldBeAFile(fileSystem).WithContents(fileOutsideOfRepoContents); // Create a link from LinkOutsideSrcToInsideSrc.cs to src\GVFS\GVFS\Program.cs string secondFileInRepoPath = this.Enlistment.GetVirtualPathTo("GVFS", "GVFS", "Program.cs"); contents = secondFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(); string hardLinkOutsideRepoToFileInRepoPath = Path.Combine(this.Enlistment.EnlistmentRoot, "LinkOutsideSrcToInsideSrc.cs"); hardLinkOutsideRepoToFileInRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.CreateHardLink(hardLinkOutsideRepoToFileInRepoPath, secondFileInRepoPath); hardLinkOutsideRepoToFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(contents); this.Enlistment.WaitForBackgroundOperations().ShouldEqual(true, "Background operations failed to complete."); string modifiedPathsDatabase = Path.Combine(this.Enlistment.DotGVFSRoot, TestConstants.Databases.ModifiedPaths); modifiedPathsDatabase.ShouldBeAFile(fileSystem); using (StreamReader reader = new StreamReader(File.Open(modifiedPathsDatabase, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { reader.ReadToEnd().Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).OrderBy(x => x) .ShouldMatchInOrder(expectedModifiedFilesContentsAfterHardlinks.OrderBy(x => x)); } }
public void PersistedDirectoryLazyLoad(FileSystemRunner fileSystem) { const string EnumerateDirectoryName = "GVFS\\GVFS"; string[] subFolders = new string[] { Path.Combine(EnumerateDirectoryName, "Properties"), Path.Combine(EnumerateDirectoryName, "CommandLine") }; string[] subFiles = new string[] { Path.Combine(EnumerateDirectoryName, "App.config"), Path.Combine(EnumerateDirectoryName, "GitVirtualFileSystem.ico"), Path.Combine(EnumerateDirectoryName, "GVFS.csproj"), Path.Combine(EnumerateDirectoryName, "packages.config"), Path.Combine(EnumerateDirectoryName, "Program.cs"), Path.Combine(EnumerateDirectoryName, "Setup.iss") }; string enumerateDirectoryPath = this.Enlistment.GetVirtualPathTo(EnumerateDirectoryName); fileSystem.DirectoryExists(enumerateDirectoryPath).ShouldEqual(true); foreach (string folder in subFolders) { string directoryPath = this.Enlistment.GetVirtualPathTo(folder); fileSystem.DirectoryExists(directoryPath).ShouldEqual(true); } foreach (string file in subFiles) { string filePath = this.Enlistment.GetVirtualPathTo(file); fileSystem.FileExists(filePath).ShouldEqual(true); } this.Enlistment.UnmountGVFS(); this.Enlistment.MountGVFS(); foreach (string folder in subFolders) { string directoryPath = this.Enlistment.GetVirtualPathTo(folder); fileSystem.DirectoryExists(directoryPath).ShouldEqual(true); } foreach (string file in subFiles) { string filePath = this.Enlistment.GetVirtualPathTo(file); fileSystem.FileExists(filePath).ShouldEqual(true); } }
public MountTests() { this.fileSystem = new SystemIORunner(); if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { this.fileDeletedBackgroundOperationCode = 16; this.directoryDeletedBackgroundOperationCode = 17; } else { this.fileDeletedBackgroundOperationCode = 3; this.directoryDeletedBackgroundOperationCode = 11; } }
public void PrefetchFetchesDirectoriesRecursively(FileSystemRunner fileSystem) { // Everything under the gvfs folder. Include some duplicates for variety. string tempFilePath = Path.Combine(Path.GetTempPath(), "temp.file"); File.WriteAllLines(tempFilePath, new[] { "gvfs/", "gvfs/gvfs", "gvfs/" }); string output = this.Enlistment.PrefetchFolderBasedOnFile(tempFilePath); File.Delete(tempFilePath); output.ShouldContain("\"TotalMissingObjects\":283"); this.AllFetchedFilePathsShouldPassCheck(file => file.StartsWith("gvfs/", StringComparison.OrdinalIgnoreCase) || file.Equals(".gitattributes", StringComparison.OrdinalIgnoreCase)); }
public void ModifiedPathsCorrectAfterHardLinking(FileSystemRunner fileSystem) { const string ExpectedModifiedFilesContentsAfterHardlinks = @"A .gitattributes A LinkToReadme.md A LinkToFileOutsideSrc.txt "; // Create a link from src\LinkToReadme.md to src\Readme.md string existingFileInRepoPath = this.Enlistment.GetVirtualPathTo("Readme.md"); string contents = existingFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(); string hardLinkToFileInRepoPath = this.Enlistment.GetVirtualPathTo("LinkToReadme.md"); hardLinkToFileInRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.CreateHardLink(hardLinkToFileInRepoPath, existingFileInRepoPath); hardLinkToFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(contents); // Create a link from src\LinkToFileOutsideSrc.txt to FileOutsideRepo.txt string fileOutsideOfRepoPath = Path.Combine(this.Enlistment.EnlistmentRoot, "FileOutsideRepo.txt"); string fileOutsideOfRepoContents = "File outside of repo"; fileOutsideOfRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.WriteAllText(fileOutsideOfRepoPath, fileOutsideOfRepoContents); string hardLinkToFileOutsideRepoPath = this.Enlistment.GetVirtualPathTo("LinkToFileOutsideSrc.txt"); hardLinkToFileOutsideRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.CreateHardLink(hardLinkToFileOutsideRepoPath, fileOutsideOfRepoPath); hardLinkToFileOutsideRepoPath.ShouldBeAFile(fileSystem).WithContents(fileOutsideOfRepoContents); // Create a link from LinkOutsideSrcToInsideSrc.cs to src\GVFS\GVFS\Program.cs string secondFileInRepoPath = this.Enlistment.GetVirtualPathTo("GVFS", "GVFS", "Program.cs"); contents = secondFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(); string hardLinkOutsideRepoToFileInRepoPath = Path.Combine(this.Enlistment.EnlistmentRoot, "LinkOutsideSrcToInsideSrc.cs"); hardLinkOutsideRepoToFileInRepoPath.ShouldNotExistOnDisk(fileSystem); fileSystem.CreateHardLink(hardLinkOutsideRepoToFileInRepoPath, secondFileInRepoPath); hardLinkOutsideRepoToFileInRepoPath.ShouldBeAFile(fileSystem).WithContents(contents); string modifiedPathsDatabase = Path.Combine(this.Enlistment.DotGVFSRoot, TestConstants.Databases.ModifiedPaths); modifiedPathsDatabase.ShouldBeAFile(fileSystem); using (StreamReader reader = new StreamReader(File.Open(modifiedPathsDatabase, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { reader.ReadToEnd().ShouldEqual(ExpectedModifiedFilesContentsAfterHardlinks); } }
public void PrefetchFetchesAtRootLevel(FileSystemRunner fileSystem) { // Root-level files and folders starting with R (currently just Readme.md) and gvflt\gvflt.nuspec string output = this.Enlistment.PrefetchFolder("R;gvflt_fileeatest\\oneeaattributewillpass.txt"); output.ShouldContain("\"TotalMissingObjects\":2"); // Note: It is expected to always have .gitattributes HashSet <string> expectedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { ".gitattributes", "Readme.md", "GVFlt_FileEATest/OneEAAttributeWillPass.txt" }; this.AllFetchedFilePathsShouldPassCheck(expectedFiles.Contains); }
public string GetObjectRoot(FileSystemRunner fileSystem) { Path.Combine(this.LocalCacheRoot, "mapping.dat").ShouldBeAFile(fileSystem); HashSet <string> allowedFileNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { "mapping.dat", "mapping.dat.lock" // mapping.dat.lock can be present, but doesn't have to be present }; this.LocalCacheRoot.ShouldBeADirectory(fileSystem).WithFiles().ShouldNotContain(f => !allowedFileNames.Contains(f.Name)); DirectoryInfo[] directories = this.LocalCacheRoot.ShouldBeADirectory(fileSystem).WithDirectories().ToArray(); directories.Length.ShouldEqual( 1, this.LocalCacheRoot + " is expected to have only one folder. Actual folders: " + string.Join <DirectoryInfo>(",", directories)); return(Path.Combine(directories[0].FullName, "gitObjects")); }
public void PrefetchFetchesDirectoriesRecursively(FileSystemRunner fileSystem) { string tempFilePath = Path.Combine(Path.GetTempPath(), "temp.file"); File.WriteAllLines( tempFilePath, new[] { "# A comment", " ", "gvfs/", "gvfs/gvfs", "gvfs/" }); string output = this.Enlistment.PrefetchFolderBasedOnFile(tempFilePath); File.Delete(tempFilePath); output.ShouldContain("\"RequiredBlobsCount\":283"); }
public void ExcludeSparseFileSavedAfterRemount(FileSystemRunner fileSystem) { string fileToAdd = this.Enlistment.GetVirtualPathTo(FileToAdd); fileSystem.WriteAllText(fileToAdd, "Contents for the new file"); string fileToUpdate = this.Enlistment.GetVirtualPathTo(FileToUpdate); fileSystem.AppendAllText(fileToUpdate, "// Testing"); string fileToDelete = this.Enlistment.GetVirtualPathTo(FileToDelete); fileSystem.DeleteFile(fileToDelete); string folderToCreate = this.Enlistment.GetVirtualPathTo(FolderToCreate); fileSystem.CreateDirectory(folderToCreate); // Remount this.Enlistment.UnmountGVFS(); this.Enlistment.MountGVFS(); string excludeFile = this.Enlistment.GetVirtualPathTo(ExcludeFilePath); string excludeFileContents = excludeFile.ShouldBeAFile(fileSystem).WithContents(); excludeFileContents.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries) .Where(x => !x.StartsWith("#")) // Exclude comments .OrderBy(x => x) .ShouldMatchInOrder(expectedExcludeFileContents.OrderBy(x => x)); string sparseFile = this.Enlistment.GetVirtualPathTo(SparseCheckoutFilePath); sparseFile.ShouldBeAFile(fileSystem).WithContents() .Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries) .Where(x => expectedSparseFileContents.Contains(x)) // Exclude extra entries for files hydrated during test .OrderBy(x => x) .ShouldMatchInOrder(expectedSparseFileContents.OrderBy(x => x)); }