public void GitAliasInSubfolderNamedAfterKnownCommandAcquiresLock()
{
string alias = nameof(this.GitAliasInSubfolderNamedAfterKnownCommandAcquiresLock);
int pid;
GitHelpers.AcquireGVFSLock(this.Enlistment, out pid, resetTimeout: AcquireGVFSLockTimeout);
GitHelpers.CheckGitCommandAgainstGVFSRepo(this.Enlistment.RepoRoot, "config --local alias." + alias + " rebase");
ProcessResult statusWait = GitHelpers.InvokeGitAgainstGVFSRepo(
Path.Combine(this.Enlistment.RepoRoot, "GVFS"),
alias + " origin/FunctionalTests/RebaseTestsSource_20170208",
removeWaitingMessages: false);
statusWait.Errors.ShouldContain(ExpectedStatusWaitingText);
GitHelpers.CheckGitCommandAgainstGVFSRepo(this.Enlistment.RepoRoot, "rebase --abort");
}
public void GitStatusAfterFileRename()
{
string oldFilename = "New.cs";
this.Enlistment.GetVirtualPathTo(oldFilename).ShouldBeAFile(this.fileSystem);
string newFilename = "test.cs";
this.fileSystem.MoveFile(this.Enlistment.GetVirtualPathTo(oldFilename), this.Enlistment.GetVirtualPathTo(newFilename));
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"On branch " + Properties.Settings.Default.Commitish,
"Untracked files:",
newFilename);
}
public void CheckoutBranchWhereFilesTransitionToSymLinks()
{
GitHelpers.InvokeGitAgainstGVFSRepo(this.Enlistment.RepoRoot, "checkout FunctionalTests/20201014_SymLinksPart3");
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"On branch FunctionalTests/20201014_SymLinksPart3",
"nothing to commit, working tree clean");
// In this branch testFilePath has been changed to point to newGrandChildFilePath
string testFilePath = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, TestFileName));
testFilePath.ShouldBeAFile(this.bashRunner).WithContents(GrandChildFileContents);
this.bashRunner.IsSymbolicLink(testFilePath).ShouldBeTrue($"{testFilePath} should be a symlink");
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.bashRunner, TestFolderName + "/" + TestFileName);
// There should be a new ChildFolder2Name directory
string childFolder2Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, ChildFolder2Name));
this.bashRunner.IsSymbolicLink(childFolder2Path).ShouldBeFalse($"{childFolder2Path} should not be a symlink");
childFolder2Path.ShouldBeADirectory(this.bashRunner);
GVFSHelpers.ModifiedPathsShouldNotContain(this.Enlistment, this.bashRunner, TestFolderName + "/" + ChildFolder2Name);
// The rest of the files are unchanged from FunctionalTests/20180925_SymLinksPart2
string testFile2Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, TestFile2Name));
testFile2Path.ShouldBeAFile(this.bashRunner).WithContents(TestFile2Contents);
this.bashRunner.IsSymbolicLink(testFile2Path).ShouldBeFalse($"{testFile2Path} should not be a symlink");
string childLinkPath = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, ChildLinkName));
this.bashRunner.IsSymbolicLink(childLinkPath).ShouldBeTrue($"{childLinkPath} should be a symlink");
childLinkPath.ShouldBeAFile(this.bashRunner).WithContents(TestFile2Contents);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.bashRunner, TestFolderName + "/" + ChildLinkName);
string grandChildLinkPath = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, ChildFolderName, GrandChildLinkName));
this.bashRunner.IsSymbolicLink(grandChildLinkPath).ShouldBeFalse($"{grandChildLinkPath} should not be a symlink");
grandChildLinkPath.ShouldBeAFile(this.bashRunner).WithContents(GrandChildLinkNowAFileContents);
string newGrandChildFilePath = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, ChildFolderName, GrandChildFileName));
newGrandChildFilePath.ShouldBeAFile(this.bashRunner).WithContents(GrandChildFileContents);
this.bashRunner.IsSymbolicLink(newGrandChildFilePath).ShouldBeFalse($"{newGrandChildFilePath} should not be a symlink");
}
public void GitStatusAfterUnstage()
{
string existingFilename = "test.cs";
this.Enlistment.GetVirtualPathTo(existingFilename).ShouldBeAFile(this.fileSystem);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"reset HEAD " + existingFilename,
new string[] { });
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"On branch " + Properties.Settings.Default.Commitish,
"Untracked files:",
existingFilename);
}
public void GitStatusAfterNewFile()
{
string filename = "new.cs";
string filePath = this.Enlistment.GetVirtualPathTo(filename);
filePath.ShouldNotExistOnDisk(this.fileSystem);
this.fileSystem.WriteAllText(filePath, this.testFileContents);
filePath.ShouldBeAFile(this.fileSystem).WithContents(this.testFileContents);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"On branch " + Properties.Settings.Default.Commitish,
"Untracked files:",
filename);
this.fileSystem.DeleteFile(filePath);
}
public void GitStatusAfterFileNameCaseChange()
{
string oldFilename = "new.cs";
this.EnsureTestFileExists(oldFilename);
string newFilename = "New.cs";
string newFilePath = this.Enlistment.GetVirtualPathTo(newFilename);
this.fileSystem.MoveFile(this.Enlistment.GetVirtualPathTo(oldFilename), newFilePath);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"On branch " + Properties.Settings.Default.Commitish,
"Untracked files:",
newFilename);
this.fileSystem.DeleteFile(newFilePath);
}
public void CheckoutBranchWhereSymLinkTransistionsToFolderAndFolderTransitionsToSymlink()
{
GitHelpers.InvokeGitAgainstGVFSRepo(this.Enlistment.RepoRoot, "checkout FunctionalTests/20201014_SymLinksPart4");
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"On branch FunctionalTests/20201014_SymLinksPart4",
"nothing to commit, working tree clean");
// In this branch ChildLinkName has been changed to a directory and ChildFolder2Name has been changed to a link to ChildFolderName
string linkNowADirectoryPath = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, ChildLinkName));
this.bashRunner.IsSymbolicLink(linkNowADirectoryPath).ShouldBeFalse($"{linkNowADirectoryPath} should not be a symlink");
linkNowADirectoryPath.ShouldBeADirectory(this.bashRunner);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.bashRunner, TestFolderName + "/" + ChildLinkName);
string directoryNowALinkPath = this.Enlistment.GetVirtualPathTo(Path.Combine(TestFolderName, ChildFolder2Name));
this.bashRunner.IsSymbolicLink(directoryNowALinkPath).ShouldBeTrue($"{directoryNowALinkPath} should be a symlink");
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.bashRunner, TestFolderName + "/" + ChildFolder2Name);
}
public void GitStatusAfterRenameFileIntoRepo()
{
string filename = "GitStatusAfterRenameFileIntoRepo.cs";
// Create the test file in this.Enlistment.EnlistmentRoot as it's outside of src
// and is cleaned up when the functional tests run
string filePath = Path.Combine(this.Enlistment.EnlistmentRoot, filename);
this.fileSystem.WriteAllText(filePath, this.testFileContents);
filePath.ShouldBeAFile(this.fileSystem).WithContents(this.testFileContents);
string renamedFileName = "GVFlt_MoveFileTest\\GitStatusAfterRenameFileIntoRepo.cs";
this.fileSystem.MoveFile(filePath, this.Enlistment.GetVirtualPathTo(renamedFileName));
this.Enlistment.GetVirtualPathTo(filePath).ShouldNotExistOnDisk(this.fileSystem);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"On branch " + Properties.Settings.Default.Commitish,
"Untracked files:",
renamedFileName.Replace('\\', '/'));
}
public void LockToPreventDelete_SingleFile()
{
string testFile1Contents = "TestContentsLockToPreventDelete \r\n";
string testFile1Name = "test.txt";
string testFile1Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventDelete", testFile1Name));
testFile1Path.ShouldBeAFile(this.fileSystem).WithContents(testFile1Contents);
using (SafeFileHandle testFile1Handle = this.CreateFile(testFile1Path, FileShare.Read))
{
testFile1Handle.IsInvalid.ShouldEqual(false);
ProcessResult result = this.InvokeGitAgainstGVFSRepo("checkout " + OldCommitId);
result.Errors.ShouldContain(
"GVFS was unable to delete the following files. To recover, close all handles to the files and run these commands:",
"git clean -f " + TestParentFolderName + "/LockToPreventDelete/" + testFile1Name);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status -u",
"HEAD detached at " + OldCommitId,
"Untracked files:",
TestParentFolderName + "/LockToPreventDelete/" + testFile1Name);
testFile1Path.ShouldBeAFile(this.fileSystem).WithContents(testFile1Contents);
}
this.GitCleanFile(TestParentFolderName + "/LockToPreventDelete/" + testFile1Name);
this.GitStatusShouldBeClean(OldCommitId);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventDelete/" + testFile1Name);
testFile1Path.ShouldNotExistOnDisk(this.fileSystem);
this.GitCheckoutCommitId(NewFilesAndChangesCommitId);
this.GitStatusShouldBeClean(NewFilesAndChangesCommitId);
testFile1Path.ShouldBeAFile(this.fileSystem).WithContents(testFile1Contents);
}
public void GitLog()
{
GitHelpers.CheckGitCommandAgainstGVFSRepo(this.Enlistment.RepoRoot, "log -n1", "commit", "Author:", "Date:");
}
private void GitCheckoutToDiscardChanges(string gitPath)
{
GitHelpers.CheckGitCommandAgainstGVFSRepo(this.Enlistment.RepoRoot, "checkout -- " + gitPath);
}
public void LockMoreThanMaxReportedFileNames()
{
string updateFilesFolder = "FilesToUpdate";
string deleteFilesFolder = "FilesToDelete";
for (int i = 1; i <= 51; ++i)
{
this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "MaxFileListCount", updateFilesFolder, i.ToString() + ".txt")).ShouldBeAFile(this.fileSystem);
this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "MaxFileListCount", deleteFilesFolder, i.ToString() + ".txt")).ShouldBeAFile(this.fileSystem);
}
List <SafeFileHandle> openHandles = new List <SafeFileHandle>();
try
{
for (int i = 1; i <= 51; ++i)
{
SafeFileHandle handle = this.CreateFile(
this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "MaxFileListCount", updateFilesFolder, i.ToString() + ".txt")),
FileShare.Read);
openHandles.Add(handle);
handle.IsInvalid.ShouldEqual(false);
handle = this.CreateFile(
this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "MaxFileListCount", deleteFilesFolder, i.ToString() + ".txt")),
FileShare.Read);
openHandles.Add(handle);
handle.IsInvalid.ShouldEqual(false);
}
ProcessResult result = this.InvokeGitAgainstGVFSRepo("checkout " + OldCommitId);
result.Errors.ShouldContain(
"GVFS failed to update 102 files, run 'git status' to check the status of files in the repo");
List <string> expectedOutputStrings = new List <string>()
{
"HEAD detached at " + OldCommitId,
"no changes added to commit (use \"git add\" and/or \"git commit -a\")\n"
};
for (int expectedFilePrefix = 1; expectedFilePrefix <= 51; ++expectedFilePrefix)
{
expectedOutputStrings.Add("modified: Test_EPF_UpdatePlaceholderTests/MaxFileListCount/" + updateFilesFolder + "/" + expectedFilePrefix.ToString() + ".txt");
expectedOutputStrings.Add("Test_EPF_UpdatePlaceholderTests/MaxFileListCount/" + deleteFilesFolder + "/" + expectedFilePrefix.ToString() + ".txt");
}
GitHelpers.CheckGitCommandAgainstGVFSRepo(this.Enlistment.RepoRoot, "status -u", expectedOutputStrings.ToArray());
}
finally
{
foreach (SafeFileHandle handle in openHandles)
{
handle.Dispose();
}
}
for (int i = 1; i <= 51; ++i)
{
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/MaxFileListCount/" + updateFilesFolder + "/" + i.ToString() + ".txt");
this.GitCleanFile(TestParentFolderName + "/MaxFileListCount/" + deleteFilesFolder + "/" + i.ToString() + ".txt");
}
this.GitStatusShouldBeClean(OldCommitId);
this.GitCheckoutCommitId(NewFilesAndChangesCommitId);
this.GitStatusShouldBeClean(NewFilesAndChangesCommitId);
}
public void LockToPreventUpdateAndDelete()
{
string testFileUpdate1Contents = "Commit2LockToPreventUpdateAndDelete \r\n";
string testFileUpdate2Contents = "Commit2LockToPreventUpdateAndDelete2 \r\n";
string testFileUpdate3Contents = "Commit2LockToPreventUpdateAndDelete3 \r\n";
string testFileDelete1Contents = "PreventDelete \r\n";
string testFileDelete2Contents = "PreventDelete2 \r\n";
string testFileDelete3Contents = "PreventDelete3 \r\n";
string testFileUpdate1OldContents = "TestFileLockToPreventUpdateAndDelete \r\n";
string testFileUpdate2OldContents = "TestFileLockToPreventUpdateAndDelete2 \r\n";
string testFileUpdate3OldContents = "TestFileLockToPreventUpdateAndDelete3 \r\n";
string testFileUpdate1Name = "test.txt";
string testFileUpdate2Name = "test2.txt";
string testFileUpdate3Name = "test3.txt";
string testFileDelete1Name = "test_delete.txt";
string testFileDelete2Name = "test_delete2.txt";
string testFileDelete3Name = "test_delete3.txt";
string testFileUpdate1Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileUpdate1Name));
string testFileUpdate2Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileUpdate2Name));
string testFileUpdate3Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileUpdate3Name));
string testFileDelete1Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileDelete1Name));
string testFileDelete2Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileDelete2Name));
string testFileDelete3Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileDelete3Name));
testFileUpdate1Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate1Contents);
testFileUpdate2Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate2Contents);
testFileUpdate3Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate3Contents);
testFileDelete1Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete1Contents);
testFileDelete2Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete2Contents);
testFileDelete3Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete3Contents);
using (SafeFileHandle testFileUpdate1Handle = this.CreateFile(testFileUpdate1Path, FileShare.Read))
using (SafeFileHandle testFileUpdate2Handle = this.CreateFile(testFileUpdate2Path, FileShare.Read))
using (SafeFileHandle testFileUpdate3Handle = this.CreateFile(testFileUpdate3Path, FileShare.Read))
using (SafeFileHandle testFileDelete1Handle = this.CreateFile(testFileDelete1Path, FileShare.Read))
using (SafeFileHandle testFileDelete2Handle = this.CreateFile(testFileDelete2Path, FileShare.Read))
using (SafeFileHandle testFileDelete3Handle = this.CreateFile(testFileDelete3Path, FileShare.Read))
{
testFileUpdate1Handle.IsInvalid.ShouldEqual(false);
testFileUpdate2Handle.IsInvalid.ShouldEqual(false);
testFileUpdate3Handle.IsInvalid.ShouldEqual(false);
testFileDelete1Handle.IsInvalid.ShouldEqual(false);
testFileDelete2Handle.IsInvalid.ShouldEqual(false);
testFileDelete3Handle.IsInvalid.ShouldEqual(false);
ProcessResult checkoutResult = GitProcess.InvokeProcess(this.Enlistment.RepoRoot, "checkout " + OldCommitId);
checkoutResult.Errors.ShouldContain(
"HEAD is now at " + OldCommitId,
"GVFS was unable to delete the following files. To recover, close all handles to the files and run these commands:",
"git clean -f " + TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete1Name,
"git clean -f " + TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete2Name,
"git clean -f " + TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete3Name,
"GVFS was unable to update the following files. To recover, close all handles to the files and run these commands:",
"git checkout -- " + TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate1Name,
"git checkout -- " + TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate2Name,
"git checkout -- " + TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate3Name);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"HEAD detached at " + OldCommitId,
"modified: Test_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test.txt",
"modified: Test_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test2.txt",
"modified: Test_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test3.txt",
"Untracked files:\n (use \"git add <file>...\" to include in what will be committed)\n\tTest_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test_delete.txt\n\tTest_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test_delete2.txt\n\tTest_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test_delete3.txt",
"no changes added to commit (use \"git add\" and/or \"git commit -a\")\n");
}
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate1Name);
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate2Name);
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate3Name);
this.GitCleanFile(TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete1Name);
this.GitCleanFile(TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete2Name);
this.GitCleanFile(TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete3Name);
this.GitStatusShouldBeClean(OldCommitId);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate1Name);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate2Name);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate3Name);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete1Name);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete2Name);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileDelete3Name);
testFileUpdate1Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate1OldContents);
testFileUpdate2Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate2OldContents);
testFileUpdate3Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate3OldContents);
testFileDelete1Path.ShouldNotExistOnDisk(this.fileSystem);
testFileDelete2Path.ShouldNotExistOnDisk(this.fileSystem);
testFileDelete3Path.ShouldNotExistOnDisk(this.fileSystem);
this.GitCheckoutCommitId(NewFilesAndChangesCommitId);
this.GitStatusShouldBeClean(NewFilesAndChangesCommitId);
testFileUpdate1Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate1Contents);
testFileUpdate2Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate2Contents);
testFileUpdate3Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate3Contents);
testFileDelete1Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete1Contents);
testFileDelete2Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete2Contents);
testFileDelete3Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete3Contents);
}
public void LockToPreventUpdate_MultipleFiles()
{
string testFile2Contents = "Commit2LockToPreventUpdate2 \r\n";
string testFile3Contents = "Commit2LockToPreventUpdate3 \r\n";
string testFile4Contents = "Commit2LockToPreventUpdate4 \r\n";
string testFile2OldContents = "TestFileLockToPreventUpdate2 \r\n";
string testFile3OldContents = "TestFileLockToPreventUpdate3 \r\n";
string testFile4OldContents = "TestFileLockToPreventUpdate4 \r\n";
string testFile2Name = "test2.txt";
string testFile3Name = "test3.txt";
string testFile4Name = "test4.txt";
string testFile2Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdate", testFile2Name));
string testFile3Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdate", testFile3Name));
string testFile4Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdate", testFile4Name));
testFile2Path.ShouldBeAFile(this.fileSystem).WithContents(testFile2Contents);
testFile3Path.ShouldBeAFile(this.fileSystem).WithContents(testFile3Contents);
testFile4Path.ShouldBeAFile(this.fileSystem).WithContents(testFile4Contents);
using (SafeFileHandle testFile2Handle = this.CreateFile(testFile2Path, FileShare.Read))
using (SafeFileHandle testFile3Handle = this.CreateFile(testFile3Path, FileShare.Read))
using (SafeFileHandle testFile4Handle = this.CreateFile(testFile4Path, FileShare.Read))
{
testFile2Handle.IsInvalid.ShouldEqual(false);
testFile3Handle.IsInvalid.ShouldEqual(false);
testFile4Handle.IsInvalid.ShouldEqual(false);
ProcessResult result = this.InvokeGitAgainstGVFSRepo("checkout " + OldCommitId);
result.Errors.ShouldContain(
"GVFS was unable to update the following files. To recover, close all handles to the files and run these commands:",
"git checkout -- " + TestParentFolderName + "/LockToPreventUpdate/" + testFile2Name,
"git checkout -- " + TestParentFolderName + "/LockToPreventUpdate/" + testFile3Name,
"git checkout -- " + TestParentFolderName + "/LockToPreventUpdate/" + testFile4Name);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"HEAD detached at " + OldCommitId,
"Changes not staged for commit:",
TestParentFolderName + "/LockToPreventUpdate/" + testFile2Name,
TestParentFolderName + "/LockToPreventUpdate/" + testFile3Name,
TestParentFolderName + "/LockToPreventUpdate/" + testFile4Name);
}
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/LockToPreventUpdate/" + testFile2Name);
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/LockToPreventUpdate/" + testFile3Name);
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/LockToPreventUpdate/" + testFile4Name);
this.GitStatusShouldBeClean(OldCommitId);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdate/" + testFile2Name);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdate/" + testFile3Name);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, TestParentFolderName + "/LockToPreventUpdate/" + testFile4Name);
testFile2Path.ShouldBeAFile(this.fileSystem).WithContents(testFile2OldContents);
testFile3Path.ShouldBeAFile(this.fileSystem).WithContents(testFile3OldContents);
testFile4Path.ShouldBeAFile(this.fileSystem).WithContents(testFile4OldContents);
this.GitCheckoutCommitId(NewFilesAndChangesCommitId);
this.GitStatusShouldBeClean(NewFilesAndChangesCommitId);
testFile2Path.ShouldBeAFile(this.fileSystem).WithContents(testFile2Contents);
testFile3Path.ShouldBeAFile(this.fileSystem).WithContents(testFile3Contents);
testFile4Path.ShouldBeAFile(this.fileSystem).WithContents(testFile4Contents);
}
public void LockWithFullShareUpdateAndDelete()
{
string testFileUpdate4Contents = "Commit2LockToPreventUpdateAndDelete4 \r\n";
string testFileDelete4Contents = "PreventDelete4 \r\n";
string testFileUpdate4OldContents = "TestFileLockToPreventUpdateAndDelete4 \r\n";
string testFileUpdate4Name = "test4.txt";
string testFileDelete4Name = "test_delete4.txt";
string testFileUpdate4Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileUpdate4Name));
string testFileDelete4Path = this.Enlistment.GetVirtualPathTo(Path.Combine(TestParentFolderName, "LockToPreventUpdateAndDelete", testFileDelete4Name));
testFileUpdate4Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate4Contents);
testFileDelete4Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete4Contents);
if (this.CanUpdateAndDeletePlaceholdersWithOpenHandles())
{
using (SafeFileHandle testFileUpdate4Handle = this.CreateFile(testFileUpdate4Path, FileShare.Read | FileShare.Delete))
using (SafeFileHandle testFileDelete4Handle = this.CreateFile(testFileDelete4Path, FileShare.Read | FileShare.Delete))
{
testFileUpdate4Handle.IsInvalid.ShouldEqual(false);
testFileDelete4Handle.IsInvalid.ShouldEqual(false);
this.GitCheckoutCommitId(OldCommitId);
this.GitStatusShouldBeClean(OldCommitId);
}
}
else
{
using (SafeFileHandle testFileUpdate4Handle = this.CreateFile(testFileUpdate4Path, FileShare.Read | FileShare.Delete))
using (SafeFileHandle testFileDelete4Handle = this.CreateFile(testFileDelete4Path, FileShare.Read | FileShare.Delete))
{
testFileUpdate4Handle.IsInvalid.ShouldEqual(false);
testFileDelete4Handle.IsInvalid.ShouldEqual(false);
ProcessResult checkoutResult = GitProcess.InvokeProcess(this.Enlistment.RepoRoot, "checkout " + OldCommitId);
checkoutResult.Errors.ShouldContain(
"HEAD is now at " + OldCommitId,
"GVFS was unable to update the following files. To recover, close all handles to the files and run these commands:",
"git checkout -- Test_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test4.txt");
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
"HEAD detached at " + OldCommitId,
"modified: Test_EPF_UpdatePlaceholderTests/LockToPreventUpdateAndDelete/test4.txt",
"no changes added to commit (use \"git add\" and/or \"git commit -a\")\n");
}
this.GitCheckoutToDiscardChanges(TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate4Name);
this.GitStatusShouldBeClean(OldCommitId);
GVFSHelpers.ModifiedPathsShouldContain(this.fileSystem, this.Enlistment.DotGVFSRoot, TestParentFolderName + "/LockToPreventUpdateAndDelete/" + testFileUpdate4Name);
}
testFileUpdate4Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate4OldContents);
testFileDelete4Path.ShouldNotExistOnDisk(this.fileSystem);
this.GitCheckoutCommitId(NewFilesAndChangesCommitId);
this.GitStatusShouldBeClean(NewFilesAndChangesCommitId);
testFileUpdate4Path.ShouldBeAFile(this.fileSystem).WithContents(testFileUpdate4Contents);
testFileDelete4Path.ShouldBeAFile(this.fileSystem).WithContents(testFileDelete4Contents);
}
public void TruncatedObjectRedownloaded()
{
GitProcess.InvokeProcess(this.Enlistment.RepoRoot, "checkout " + this.Enlistment.Commitish);
ProcessResult revParseResult = GitProcess.InvokeProcess(this.Enlistment.RepoRoot, "rev-parse :Test_EPF_WorkingDirectoryTests/TruncatedObjectRedownloaded.txt");
string sha = revParseResult.Output.Trim();
sha.Length.ShouldEqual(40);
string objectPath = Path.Combine(this.Enlistment.GetObjectRoot(this.fileSystem), sha.Substring(0, 2), sha.Substring(2, 38));
objectPath.ShouldNotExistOnDisk(this.fileSystem);
string corruptObjectFolderPath = Path.Combine(this.Enlistment.DotGVFSRoot, "CorruptObjects");
int initialCorruptObjectCount = 0;
if (this.fileSystem.DirectoryExists(corruptObjectFolderPath))
{
initialCorruptObjectCount = new DirectoryInfo(corruptObjectFolderPath).EnumerateFileSystemInfos().Count();
}
// Read a copy of TruncatedObjectRedownloaded.txt to force the object to be downloaded
GitProcess.InvokeProcess(this.Enlistment.RepoRoot, "rev-parse :Test_EPF_WorkingDirectoryTests/TruncatedObjectRedownloaded_copy.txt").Output.Trim().ShouldEqual(sha);
string testFileContents = this.Enlistment.GetVirtualPathTo("Test_EPF_WorkingDirectoryTests", "TruncatedObjectRedownloaded_copy.txt").ShouldBeAFile(this.fileSystem).WithContents();
objectPath.ShouldBeAFile(this.fileSystem);
string modifedFile = "Test_EPF_WorkingDirectoryTests/TruncatedObjectRedownloaded.txt";
GVFSHelpers.ModifiedPathsShouldNotContain(this.Enlistment, this.fileSystem, modifedFile);
// Truncate the contents of objectPath
string tempTruncatedObjectPath = objectPath + "truncated";
FileInfo objectFileInfo = new FileInfo(objectPath);
long objectLength = objectFileInfo.Length;
using (FileStream objectStream = new FileStream(objectPath, FileMode.Open))
using (FileStream truncatedObjectStream = new FileStream(tempTruncatedObjectPath, FileMode.CreateNew))
{
for (int i = 0; i < (objectStream.Length - 16); ++i)
{
truncatedObjectStream.WriteByte((byte)objectStream.ReadByte());
}
}
this.fileSystem.DeleteFile(objectPath);
this.fileSystem.MoveFile(tempTruncatedObjectPath, objectPath);
tempTruncatedObjectPath.ShouldNotExistOnDisk(this.fileSystem);
objectPath.ShouldBeAFile(this.fileSystem);
new FileInfo(objectPath).Length.ShouldEqual(objectLength - 16);
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
// Mac can't correct corrupt objects, but it should detect them and add to ModifiedPaths.dat
this.Enlistment.GetVirtualPathTo("Test_EPF_WorkingDirectoryTests", "TruncatedObjectRedownloaded.txt").ShouldBeAFile(this.fileSystem);
GVFSHelpers.ModifiedPathsShouldContain(this.Enlistment, this.fileSystem, modifedFile);
GitHelpers.CheckGitCommandAgainstGVFSRepo(
this.Enlistment.RepoRoot,
"status",
$"modified: {modifedFile}");
}
else
{
// Windows should correct a corrupt obect
// Read the original path and verify its contents are correct
this.Enlistment.GetVirtualPathTo("Test_EPF_WorkingDirectoryTests", "TruncatedObjectRedownloaded.txt").ShouldBeAFile(this.fileSystem).WithContents(testFileContents);
// Confirm there's a new item in the corrupt objects folder
corruptObjectFolderPath.ShouldBeADirectory(this.fileSystem).WithItems().Count().ShouldEqual(initialCorruptObjectCount + 1);
// File should not be in ModifiedPaths.dat
GVFSHelpers.ModifiedPathsShouldNotContain(this.Enlistment, this.fileSystem, "Test_EPF_WorkingDirectoryTests/TruncatedObjectRedownloaded.txt");
}
}