Exemplo n.º 1
0
        public void DeleteFile()
        {
            using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                using (WindowsFileSystemVirtualizer virtualizer = new WindowsFileSystemVirtualizer(this.Repo.Context, this.Repo.GitObjects, mockVirtualization, numWorkThreads))
                {
                    UpdateFailureReason failureReason = UpdateFailureReason.NoFailure;

                    mockVirtualization.DeleteFileResult             = HResult.Ok;
                    mockVirtualization.DeleteFileUpdateFailureCause = UpdateFailureCause.NoFailure;
                    virtualizer
                    .DeleteFile("test.txt", UpdatePlaceholderType.AllowReadOnly, out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.Ok, (int)mockVirtualization.DeleteFileResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.DeleteFileUpdateFailureCause);

                    mockVirtualization.DeleteFileResult             = HResult.FileNotFound;
                    mockVirtualization.DeleteFileUpdateFailureCause = UpdateFailureCause.NoFailure;
                    virtualizer
                    .DeleteFile("test.txt", UpdatePlaceholderType.AllowReadOnly, out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.FileOrPathNotFound, (int)mockVirtualization.DeleteFileResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.DeleteFileUpdateFailureCause);

                    mockVirtualization.DeleteFileResult             = HResult.VirtualizationInvalidOp;
                    mockVirtualization.DeleteFileUpdateFailureCause = UpdateFailureCause.DirtyData;
                    virtualizer
                    .DeleteFile("test.txt", UpdatePlaceholderType.AllowReadOnly, out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.VirtualizationInvalidOperation, (int)mockVirtualization.DeleteFileResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.DeleteFileUpdateFailureCause);
                }
        }
        public void DeleteFile()
        {
            using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                using (MacFileSystemVirtualizer virtualizer = new MacFileSystemVirtualizer(this.Repo.Context, this.Repo.GitObjects, mockVirtualization))
                {
                    const string        DeleteTestFileName = "deleteMe.txt";
                    UpdateFailureReason failureReason      = UpdateFailureReason.NoFailure;

                    mockVirtualization.DeleteFileResult             = Result.Success;
                    mockVirtualization.DeleteFileUpdateFailureCause = UpdateFailureCause.NoFailure;
                    virtualizer
                    .DeleteFile(DeleteTestFileName, UpdatePlaceholderType.AllowReadOnly, out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.Ok, (int)mockVirtualization.DeleteFileResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.DeleteFileUpdateFailureCause);

                    mockVirtualization.DeleteFileResult             = Result.EFileNotFound;
                    mockVirtualization.DeleteFileUpdateFailureCause = UpdateFailureCause.NoFailure;
                    virtualizer
                    .DeleteFile(DeleteTestFileName, UpdatePlaceholderType.AllowReadOnly, out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.FileOrPathNotFound, (int)mockVirtualization.DeleteFileResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.DeleteFileUpdateFailureCause);

                    // TODO: What will the result be when the UpdateFailureCause is DirtyData
                    mockVirtualization.DeleteFileResult = Result.EInvalidOperation;

                    // TODO: The result should probably be VirtualizationInvalidOperation but for now it's IOError
                    mockVirtualization.DeleteFileUpdateFailureCause = UpdateFailureCause.DirtyData;
                    virtualizer
                    .DeleteFile(DeleteTestFileName, UpdatePlaceholderType.AllowReadOnly, out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.IOError, (int)mockVirtualization.DeleteFileResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.DeleteFileUpdateFailureCause);
                }
        }
        public void UpdatePlaceholderToSymLink()
        {
            const string PlaceholderToLinkFileName          = "testUpdatePlaceholderToLink.txt";
            Mock <IPlaceholderCollection> mockPlaceholderDb = new Mock <IPlaceholderCollection>(MockBehavior.Strict);

            mockPlaceholderDb.Setup(x => x.GetCount()).Returns(1);
            using (MockBackgroundFileSystemTaskRunner backgroundTaskRunner = new MockBackgroundFileSystemTaskRunner())
                using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                    using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { PlaceholderToLinkFileName }))
                        using (MacFileSystemVirtualizer virtualizer = new MacFileSystemVirtualizer(this.Repo.Context, this.Repo.GitObjects, mockVirtualization))
                            using (FileSystemCallbacks fileSystemCallbacks = new FileSystemCallbacks(
                                       this.Repo.Context,
                                       this.Repo.GitObjects,
                                       RepoMetadata.Instance,
                                       new MockBlobSizes(),
                                       gitIndexProjection,
                                       backgroundTaskRunner,
                                       virtualizer,
                                       mockPlaceholderDb.Object))
                            {
                                gitIndexProjection.MockFileTypesAndModes.TryAdd(
                                    PlaceholderToLinkFileName,
                                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.SymLink, fileMode: 0));

                                string error;
                                fileSystemCallbacks.TryStart(out error).ShouldEqual(true);

                                UpdateFailureReason failureReason = UpdateFailureReason.NoFailure;

                                mockVirtualization.UpdatePlaceholderIfNeededResult       = Result.Success;
                                mockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                                virtualizer
                                .UpdatePlaceholderIfNeeded(
                                    PlaceholderToLinkFileName,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    0,
                                    15,
                                    string.Empty,
                                    UpdatePlaceholderType.AllowReadOnly,
                                    out failureReason)
                                .ShouldEqual(new FileSystemResult(FSResult.Ok, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                                failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);
                                mockVirtualization.UpdatedPlaceholders.Count.ShouldEqual(0, "UpdatePlaceholderIfNeeded should not be called when converting a placeholder to a link");
                                mockVirtualization.CreatedSymLinks.Count.ShouldEqual(1);
                                mockVirtualization.CreatedSymLinks.ShouldContain(entry => entry.Equals(PlaceholderToLinkFileName));

                                // Creating a symlink should schedule a background task
                                backgroundTaskRunner.Count.ShouldEqual(1);
                                backgroundTaskRunner.BackgroundTasks[0].Operation.ShouldEqual(GVFS.Virtualization.Background.FileSystemTask.OperationType.OnFileSymLinkCreated);
                                backgroundTaskRunner.BackgroundTasks[0].VirtualPath.ShouldEqual(PlaceholderToLinkFileName);

                                fileSystemCallbacks.Stop();
                            }

            mockPlaceholderDb.VerifyAll();
        }
        public void InvokeUpdatePlaceholderIfNeeded(string fileName, FileSystemResult expectedResult, UpdateFailureCause expectedFailureCause)
        {
            UpdateFailureReason failureReason = UpdateFailureReason.NoFailure;

            this.MacVirtualizer.UpdatePlaceholderIfNeeded(
                fileName,
                DateTime.Now,
                DateTime.Now,
                DateTime.Now,
                DateTime.Now,
                0,
                15,
                string.Empty,
                UpdatePlaceholderType.AllowReadOnly,
                out failureReason)
            .ShouldEqual(expectedResult);
            failureReason.ShouldEqual((UpdateFailureReason)expectedFailureCause);
        }
Exemplo n.º 5
0
        public void UpdatePlaceholderIfNeeded()
        {
            const string UpdatePlaceholderFileName = "testUpdatePlaceholder.txt";

            using (MockBackgroundFileSystemTaskRunner backgroundTaskRunner = new MockBackgroundFileSystemTaskRunner())
                using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                    using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { UpdatePlaceholderFileName }))
                        using (MacFileSystemVirtualizer virtualizer = new MacFileSystemVirtualizer(this.Repo.Context, this.Repo.GitObjects, mockVirtualization))
                            using (FileSystemCallbacks fileSystemCallbacks = new FileSystemCallbacks(
                                       this.Repo.Context,
                                       this.Repo.GitObjects,
                                       RepoMetadata.Instance,
                                       new MockBlobSizes(),
                                       gitIndexProjection,
                                       backgroundTaskRunner,
                                       virtualizer))
                            {
                                gitIndexProjection.MockFileTypesAndModes.TryAdd(
                                    UpdatePlaceholderFileName,
                                    ConvertFileTypeAndModeToIndexFormat(GitIndexProjection.FileType.Regular, GitIndexProjection.FileMode644));

                                string error;
                                fileSystemCallbacks.TryStart(out error).ShouldEqual(true);

                                UpdateFailureReason failureReason = UpdateFailureReason.NoFailure;

                                mockVirtualization.UpdatePlaceholderIfNeededResult       = Result.Success;
                                mockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                                virtualizer
                                .UpdatePlaceholderIfNeeded(
                                    UpdatePlaceholderFileName,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    0,
                                    15,
                                    string.Empty,
                                    UpdatePlaceholderType.AllowReadOnly,
                                    out failureReason)
                                .ShouldEqual(new FileSystemResult(FSResult.Ok, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                                failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);
                                mockVirtualization.UpdatedPlaceholders.ShouldContain(path => path.Key.Equals(UpdatePlaceholderFileName) && path.Value == GitIndexProjection.FileMode644);
                                mockVirtualization.UpdatedPlaceholders.Clear();

                                mockVirtualization.UpdatePlaceholderIfNeededResult       = Result.EFileNotFound;
                                mockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                                virtualizer
                                .UpdatePlaceholderIfNeeded(
                                    UpdatePlaceholderFileName,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    0,
                                    15,
                                    string.Empty,
                                    UpdatePlaceholderType.AllowReadOnly,
                                    out failureReason)
                                .ShouldEqual(new FileSystemResult(FSResult.FileOrPathNotFound, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                                failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);

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

                                // TODO: The result should probably be VirtualizationInvalidOperation but for now it's IOError
                                virtualizer
                                .UpdatePlaceholderIfNeeded(
                                    UpdatePlaceholderFileName,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    0,
                                    15,
                                    string.Empty,
                                    UpdatePlaceholderType.AllowReadOnly,
                                    out failureReason)
                                .ShouldEqual(new FileSystemResult(FSResult.IOError, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                                failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);
                                fileSystemCallbacks.Stop();
                            }
        }
        public void UpdatePlaceholderIfNeeded()
        {
            using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                using (MacFileSystemVirtualizer virtualizer = new MacFileSystemVirtualizer(this.Repo.Context, this.Repo.GitObjects, mockVirtualization))
                {
                    UpdateFailureReason failureReason = UpdateFailureReason.NoFailure;

                    mockVirtualization.UpdatePlaceholderIfNeededResult       = Result.Success;
                    mockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                    virtualizer
                    .UpdatePlaceholderIfNeeded(
                        "test.txt",
                        DateTime.Now,
                        DateTime.Now,
                        DateTime.Now,
                        DateTime.Now,
                        0,
                        15,
                        string.Empty,
                        UpdatePlaceholderType.AllowReadOnly,
                        out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.Ok, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);

                    mockVirtualization.UpdatePlaceholderIfNeededResult       = Result.EFileNotFound;
                    mockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                    virtualizer
                    .UpdatePlaceholderIfNeeded(
                        "test.txt",
                        DateTime.Now,
                        DateTime.Now,
                        DateTime.Now,
                        DateTime.Now,
                        0,
                        15,
                        string.Empty,
                        UpdatePlaceholderType.AllowReadOnly,
                        out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.FileOrPathNotFound, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);

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

                    // TODO: The result should probably be VirtualizationInvalidOperation but for now it's IOError
                    virtualizer
                    .UpdatePlaceholderIfNeeded(
                        "test.txt",
                        DateTime.Now,
                        DateTime.Now,
                        DateTime.Now,
                        DateTime.Now,
                        0,
                        15,
                        string.Empty,
                        UpdatePlaceholderType.AllowReadOnly,
                        out failureReason)
                    .ShouldEqual(new FileSystemResult(FSResult.IOError, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                    failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);
                }
        }
        public void UpdatePlaceholderIfNeeded()
        {
            using (MockBackgroundFileSystemTaskRunner backgroundTaskRunner = new MockBackgroundFileSystemTaskRunner())
                using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                    using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { "test.txt" }))
                        using (MacFileSystemVirtualizer virtualizer = new MacFileSystemVirtualizer(this.Repo.Context, this.Repo.GitObjects, mockVirtualization))
                            using (FileSystemCallbacks fileSystemCallbacks = new FileSystemCallbacks(
                                       this.Repo.Context,
                                       this.Repo.GitObjects,
                                       RepoMetadata.Instance,
                                       new MockBlobSizes(),
                                       gitIndexProjection,
                                       backgroundTaskRunner,
                                       virtualizer))
                            {
                                gitIndexProjection.MockFileModes.TryAdd("test" + Path.DirectorySeparatorChar + "test.txt", FileMode644);
                                string error;
                                fileSystemCallbacks.TryStart(out error).ShouldEqual(true);

                                UpdateFailureReason failureReason = UpdateFailureReason.NoFailure;

                                mockVirtualization.UpdatePlaceholderIfNeededResult       = Result.Success;
                                mockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                                virtualizer
                                .UpdatePlaceholderIfNeeded(
                                    "test.txt",
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    0,
                                    15,
                                    string.Empty,
                                    UpdatePlaceholderType.AllowReadOnly,
                                    out failureReason)
                                .ShouldEqual(new FileSystemResult(FSResult.Ok, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                                failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);

                                mockVirtualization.UpdatePlaceholderIfNeededResult       = Result.EFileNotFound;
                                mockVirtualization.UpdatePlaceholderIfNeededFailureCause = UpdateFailureCause.NoFailure;
                                virtualizer
                                .UpdatePlaceholderIfNeeded(
                                    "test.txt",
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    0,
                                    15,
                                    string.Empty,
                                    UpdatePlaceholderType.AllowReadOnly,
                                    out failureReason)
                                .ShouldEqual(new FileSystemResult(FSResult.FileOrPathNotFound, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                                failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);

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

                                // TODO: The result should probably be VirtualizationInvalidOperation but for now it's IOError
                                virtualizer
                                .UpdatePlaceholderIfNeeded(
                                    "test.txt",
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    DateTime.Now,
                                    0,
                                    15,
                                    string.Empty,
                                    UpdatePlaceholderType.AllowReadOnly,
                                    out failureReason)
                                .ShouldEqual(new FileSystemResult(FSResult.IOError, (int)mockVirtualization.UpdatePlaceholderIfNeededResult));
                                failureReason.ShouldEqual((UpdateFailureReason)mockVirtualization.UpdatePlaceholderIfNeededFailureCause);
                                fileSystemCallbacks.Stop();
                            }
        }