public void OnEnumerateDirectorySetsFileModes()
        {
            const string TestFile644Name = "test644.txt";
            const string TestFile664Name = "test664.txt";
            const string TestFile755Name = "test755.txt";
            const string TestFolderName  = "testFolder";
            string       testFile644Path = Path.Combine(TestFolderName, TestFile644Name);
            string       testFile664Path = Path.Combine(TestFolderName, TestFile664Name);
            string       testFile755Path = Path.Combine(TestFolderName, TestFile755Name);

            // Don't include TestFolderName as MockGitIndexProjection returns the same list of files regardless of what folder name
            // it is passed
            using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo, new[] { TestFile644Name, TestFile664Name, TestFile755Name }))
            {
                tester.GitIndexProjection.MockFileTypesAndModes.TryAdd(
                    testFile644Path,
                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.Regular, GitIndexProjection.FileMode644));
                tester.GitIndexProjection.MockFileTypesAndModes.TryAdd(
                    testFile664Path,
                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.Regular, GitIndexProjection.FileMode664));
                tester.GitIndexProjection.MockFileTypesAndModes.TryAdd(
                    testFile755Path,
                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.Regular, GitIndexProjection.FileMode755));

                tester.GitIndexProjection.EnumerationInMemory = true;
                tester.MockVirtualization.OnEnumerateDirectory(1, TestFolderName, triggeringProcessId: 1, triggeringProcessName: "UnitTests").ShouldEqual(Result.Success);
                tester.MockVirtualization.CreatedPlaceholders.ShouldContain(
                    kvp => kvp.Key.Equals(testFile644Path, GVFSPlatform.Instance.Constants.PathComparison) && kvp.Value == GitIndexProjection.FileMode644);
                tester.MockVirtualization.CreatedPlaceholders.ShouldContain(
                    kvp => kvp.Key.Equals(testFile664Path, GVFSPlatform.Instance.Constants.PathComparison) && kvp.Value == GitIndexProjection.FileMode664);
                tester.MockVirtualization.CreatedPlaceholders.ShouldContain(
                    kvp => kvp.Key.Equals(testFile755Path, GVFSPlatform.Instance.Constants.PathComparison) && kvp.Value == GitIndexProjection.FileMode755);
            }
        }
 public void OnNewFileCreatedInsideDotGitDirectoryShouldNotScheduleBackgroundTask()
 {
     using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo))
     {
         tester.MockVirtualization.OnNewFileCreated(Path.Combine(".git", "testing.txt"), isDirectory: false);
         tester.BackgroundTaskRunner.Count.ShouldEqual(0);
     }
 }
 public void OnGetFileStreamReturnsErrorWhenWriteFileContentsFails()
 {
     using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo))
     {
         tester.MockVirtualization.WriteFileReturnResult = Result.EIOError;
         tester.InvokeOnGetFileStream(expectedResult: Result.EIOError);
     }
 }
 public void OnNewFileCreatedFileShouldScheduleBackgroundTask()
 {
     using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo))
     {
         tester.MockVirtualization.OnNewFileCreated("testing.txt", isDirectory: false);
         tester.BackgroundTaskShouldBeScheduled("testing.txt", FileSystemTask.OperationType.OnFileCreated);
         tester.GitIndexProjection.SparseEntries.Count.ShouldEqual(0);
     }
 }
 public void OnGetFileStreamReturnsSuccessWhenFileStreamAvailable()
 {
     using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo))
     {
         tester.MockVirtualization.WriteFileReturnResult = Result.Success;
         tester.InvokeOnGetFileStream(expectedResult: Result.Success);
         tester.MockVirtualization.BytesWritten.ShouldEqual(MockGVFSGitObjects.DefaultFileLength);
     }
 }
 public void OnNewFileCreatedDirectoryNotFoundShouldScheduleBackgroundTask()
 {
     using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo))
     {
         tester.GitIndexProjection.GetFolderPathSparseStateValue = GitIndexProjection.PathSparseState.NotFound;
         tester.MockVirtualization.OnNewFileCreated("testing", isDirectory: true);
         tester.BackgroundTaskShouldBeScheduled("testing", FileSystemTask.OperationType.OnFolderCreated);
         tester.GitIndexProjection.SparseEntries.Count.ShouldEqual(0);
     }
 }
        public void OnNewFileCreatedDirectoryExcludedShouldNotScheduleBackgroundTask()
        {
            const string TestFileName   = "test.txt";
            const string TestFolderName = "testFolder";
            string       testFilePath   = Path.Combine(TestFolderName, TestFileName);

            using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo))
            {
                tester.GitIndexProjection.MockFileTypesAndModes.TryAdd(
                    testFilePath,
                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.Regular, GitIndexProjection.FileMode644));

                tester.GitIndexProjection.GetFolderPathSparseStateValue = GitIndexProjection.PathSparseState.Excluded;
                tester.MockVirtualization.OnNewFileCreated(TestFolderName, isDirectory: true);
                tester.BackgroundTaskRunner.Count.ShouldEqual(0);
                tester.GitIndexProjection.SparseEntries.Count.ShouldEqual(1);
                tester.GitIndexProjection.SparseEntries.First().ShouldEqual(TestFolderName);
                tester.MockVirtualization.CreatedPlaceholders.ShouldContain(
                    kvp => kvp.Key.Equals(testFilePath, GVFSPlatform.Instance.Constants.PathComparison) && kvp.Value == GitIndexProjection.FileMode644);
            }
        }
        public void WritePlaceholderForSymLink()
        {
            const string WriteSymLinkFileName = "testWriteSymLink.txt";

            using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo, new[] { WriteSymLinkFileName }))
            {
                tester.GitIndexProjection.MockFileTypesAndModes.TryAdd(
                    WriteSymLinkFileName,
                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.SymLink, fileMode: 0));

                tester.Virtualizer.WritePlaceholderFile(
                    WriteSymLinkFileName,
                    endOfFile: 0,
                    sha: string.Empty).ShouldEqual(new FileSystemResult(FSResult.Ok, (int)Result.Success));

                tester.MockVirtualization.CreatedPlaceholders.ShouldBeEmpty();
                tester.MockVirtualization.CreatedSymLinks.Count.ShouldEqual(1);
                tester.MockVirtualization.CreatedSymLinks.ShouldContain(entry => entry.Equals(WriteSymLinkFileName));

                tester.BackgroundTaskShouldBeScheduled(WriteSymLinkFileName, FileSystemTask.OperationType.OnFileSymLinkCreated);
            }
        }
        public void UpdatePlaceholderIfNeeded()
        {
            const string UpdatePlaceholderFileName = "testUpdatePlaceholder.txt";

            using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo, new[] { UpdatePlaceholderFileName }))
            {
                tester.GitIndexProjection.MockFileTypesAndModes.TryAdd(
                    UpdatePlaceholderFileName,
                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.Regular, GitIndexProjection.FileMode644));

                tester.MockVirtualization.UpdatePlaceholderIfNeededResult       = Result.Success;
                tester.MockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                tester.InvokeUpdatePlaceholderIfNeeded(
                    UpdatePlaceholderFileName,
                    expectedResult: new FileSystemResult(FSResult.Ok, (int)Result.Success),
                    expectedFailureCause: UpdateFailureCause.NoFailure);

                tester.MockVirtualization.UpdatedPlaceholders.ShouldContain(path => path.Key.Equals(UpdatePlaceholderFileName) && path.Value == GitIndexProjection.FileMode644);
                tester.MockVirtualization.UpdatedPlaceholders.Clear();

                tester.MockVirtualization.UpdatePlaceholderIfNeededResult       = Result.EFileNotFound;
                tester.MockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                tester.InvokeUpdatePlaceholderIfNeeded(
                    UpdatePlaceholderFileName,
                    expectedResult: new FileSystemResult(FSResult.FileOrPathNotFound, (int)Result.EFileNotFound),
                    expectedFailureCause: UpdateFailureCause.NoFailure);

                // TODO: What will the result be when the UpdateFailureCause is DirtyData
                tester.MockVirtualization.UpdatePlaceholderIfNeededResult       = Result.EInvalidOperation;
                tester.MockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.DirtyData;

                // TODO: The result should probably be VirtualizationInvalidOperation but for now it's IOError
                tester.InvokeUpdatePlaceholderIfNeeded(
                    UpdatePlaceholderFileName,
                    expectedResult: new FileSystemResult(FSResult.IOError, (int)Result.EInvalidOperation),
                    expectedFailureCause: UpdateFailureCause.DirtyData);
            }
        }
        public void UpdatePlaceholderToSymLink()
        {
            const string PlaceholderToLinkFileName = "testUpdatePlaceholderToLink.txt";

            using (LinuxFileSystemVirtualizerTester tester = new LinuxFileSystemVirtualizerTester(this.Repo, new[] { PlaceholderToLinkFileName }))
            {
                tester.GitIndexProjection.MockFileTypesAndModes.TryAdd(
                    PlaceholderToLinkFileName,
                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.SymLink, fileMode: 0));

                tester.MockVirtualization.UpdatePlaceholderIfNeededResult       = Result.Success;
                tester.MockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                tester.InvokeUpdatePlaceholderIfNeeded(
                    PlaceholderToLinkFileName,
                    expectedResult: new FileSystemResult(FSResult.Ok, (int)Result.Success),
                    expectedFailureCause: UpdateFailureCause.NoFailure);

                tester.MockVirtualization.UpdatedPlaceholders.Count.ShouldEqual(0, "UpdatePlaceholderIfNeeded should not be called when converting a placeholder to a link");
                tester.MockVirtualization.CreatedSymLinks.Count.ShouldEqual(1);
                tester.MockVirtualization.CreatedSymLinks.ShouldContain(entry => entry.Equals(PlaceholderToLinkFileName));

                tester.BackgroundTaskShouldBeScheduled(PlaceholderToLinkFileName, FileSystemTask.OperationType.OnFileSymLinkCreated);
            }
        }