public void OnGetFileStreamReturnsSuccessWhenFileStreamAvailable()
        {
            const string TestFileName = "test.txt";
            Mock <IPlaceholderCollection> mockPlaceholderDb = new Mock <IPlaceholderCollection>(MockBehavior.Strict);

            mockPlaceholderDb.Setup(x => x.GetCount()).Returns(1);
            Mock <ISparseCollection> mockSparseDb = new Mock <ISparseCollection>(MockBehavior.Strict);

            using (MockBackgroundFileSystemTaskRunner backgroundTaskRunner = new MockBackgroundFileSystemTaskRunner())
                using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                    using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { TestFileName }))
                        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,
                                       mockSparseDb.Object))
                            {
                                string error;
                                fileSystemCallbacks.TryStart(out error).ShouldEqual(true);

                                byte[] contentId          = FileSystemVirtualizer.ConvertShaToContentId("0123456789012345678901234567890123456789");
                                byte[] placeholderVersion = MacFileSystemVirtualizer.PlaceholderVersionId;

                                uint fileLength = 100;
                                MockGVFSGitObjects mockGVFSGitObjects = this.Repo.GitObjects as MockGVFSGitObjects;
                                mockGVFSGitObjects.FileLength            = fileLength;
                                mockVirtualization.WriteFileReturnResult = Result.Success;

                                mockVirtualization.OnGetFileStream(
                                    commandId: 1,
                                    relativePath: TestFileName,
                                    providerId: placeholderVersion,
                                    contentId: contentId,
                                    triggeringProcessId: 2,
                                    triggeringProcessName: "UnitTest",
                                    fileHandle: IntPtr.Zero).ShouldEqual(Result.Success);

                                mockVirtualization.BytesWritten.ShouldEqual(fileLength);

                                fileSystemCallbacks.Stop();
                            }

            mockPlaceholderDb.VerifyAll();
            mockSparseDb.VerifyAll();
        }
Пример #2
0
        public void OnGetFileStreamHandlesTryCopyBlobContentStreamThrowingOperationCanceled()
        {
            using (WindowsFileSystemVirtualizerTester tester = new WindowsFileSystemVirtualizerTester(this.Repo))
            {
                MockTracer mockTracker = this.Repo.Context.Tracer as MockTracer;
                mockTracker.WaitRelatedEventName = "GetFileStreamHandlerAsyncHandler_OperationCancelled";
                MockGVFSGitObjects mockGVFSGitObjects = this.Repo.GitObjects as MockGVFSGitObjects;
                mockGVFSGitObjects.CancelTryCopyBlobContentStream = true;

                tester.InvokeGetFileDataCallback(expectedResult: HResult.Pending);

                mockTracker.WaitForRelatedEvent();
            }
        }
Пример #3
0
        public void OnGetFileStreamHandlesCancellationDuringWriteAction()
        {
            using (MockVirtualizationInstance mockGvFlt = new MockVirtualizationInstance())
                using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { "test.txt" }))
                {
                    GVFltCallbacks callbacks = new GVFltCallbacks(
                        this.Repo.Context,
                        this.Repo.GitObjects,
                        RepoMetadata.Instance,
                        new MockBlobSizes(),
                        gvflt: mockGvFlt,
                        gitIndexProjection: gitIndexProjection,
                        reliableBackgroundOperations: new MockReliableBackgroundOperations());

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

                    Guid enumerationGuid = Guid.NewGuid();

                    byte[] contentId          = GVFltCallbacks.ConvertShaToContentId("0123456789012345678901234567890123456789");
                    byte[] placeholderVersion = GVFltCallbacks.GetPlaceholderVersionId();

                    uint fileLength = 100;
                    MockGVFSGitObjects mockGVFSGitObjects = this.Repo.GitObjects as MockGVFSGitObjects;
                    mockGVFSGitObjects.FileLength = fileLength;

                    MockTracer mockTracker = this.Repo.Context.Tracer as MockTracer;
                    mockTracker.WaitRelatedEventName = "GVFltGetFileStreamHandlerAsyncHandler_OperationCancelled";

                    mockGvFlt.BlockCreateWriteBuffer(willWaitForRequest: true);
                    mockGvFlt.OnGetFileStream(
                        commandId: 1,
                        relativePath: "test.txt",
                        byteOffset: 0,
                        length: fileLength,
                        streamGuid: Guid.NewGuid(),
                        contentId: contentId,
                        providerId: placeholderVersion,
                        triggeringProcessId: 2,
                        triggeringProcessImageFileName: "UnitTest").ShouldEqual(HResult.Pending);

                    mockGvFlt.WaitForCreateWriteBuffer();
                    mockGvFlt.OnCancelCommand(1);
                    mockGvFlt.UnblockCreateWriteBuffer();
                    mockTracker.WaitForRelatedEvent();

                    callbacks.Stop();
                }
        }
        public void OnGetFileStreamHandlesGvWriteFailure()
        {
            using (MockVirtualizationInstance mockGvFlt = new MockVirtualizationInstance())
                using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { "test.txt" }))
                {
                    GVFltCallbacks callbacks = new GVFltCallbacks(
                        this.Repo.Context,
                        this.Repo.GitObjects,
                        RepoMetadata.Instance,
                        blobSizes: null,
                        gvflt: mockGvFlt,
                        gitIndexProjection: gitIndexProjection,
                        reliableBackgroundOperations: new MockReliableBackgroundOperations());

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

                    Guid enumerationGuid = Guid.NewGuid();

                    byte[] contentId = GVFltCallbacks.ConvertShaToContentId("0123456789012345678901234567890123456789");
                    byte[] epochId   = GVFltCallbacks.GetEpochId();

                    uint fileLength = 100;
                    MockGVFSGitObjects mockGVFSGitObjects = this.Repo.GitObjects as MockGVFSGitObjects;
                    mockGVFSGitObjects.FileLength = fileLength;

                    MockTracer mockTracker = this.Repo.Context.Tracer as MockTracer;
                    mockTracker.WaitRelatedEventName = "GVFltGetFileStreamHandlerAsyncHandler_OperationCancelled";

                    mockGvFlt.WriteFileReturnStatus = NtStatus.InternalError;
                    mockGvFlt.OnGetFileStream(
                        commandId: 1,
                        relativePath: "test.txt",
                        byteOffset: 0,
                        length: fileLength,
                        streamGuid: Guid.NewGuid(),
                        contentId: contentId,
                        epochId: epochId,
                        triggeringProcessId: 2,
                        triggeringProcessImageFileName: "UnitTest").ShouldEqual(NtStatus.Pending);

                    mockGvFlt.WaitForCompletionStatus().ShouldEqual(mockGvFlt.WriteFileReturnStatus);

                    callbacks.Stop();
                }
        }
Пример #5
0
        public void OnGetFileStreamReturnsPendingAndCompletesWithSuccessWhenNoFailures()
        {
            using (MockVirtualizationInstance mockGvFlt = new MockVirtualizationInstance())
                using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { "test.txt" }))
                {
                    GVFltCallbacks callbacks = new GVFltCallbacks(
                        this.Repo.Context,
                        this.Repo.GitObjects,
                        RepoMetadata.Instance,
                        new MockBlobSizes(),
                        gvflt: mockGvFlt,
                        gitIndexProjection: gitIndexProjection,
                        reliableBackgroundOperations: new MockReliableBackgroundOperations());

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

                    Guid enumerationGuid = Guid.NewGuid();

                    byte[] contentId          = GVFltCallbacks.ConvertShaToContentId("0123456789012345678901234567890123456789");
                    byte[] placeholderVersion = GVFltCallbacks.GetPlaceholderVersionId();

                    uint fileLength = 100;
                    MockGVFSGitObjects mockGVFSGitObjects = this.Repo.GitObjects as MockGVFSGitObjects;
                    mockGVFSGitObjects.FileLength   = fileLength;
                    mockGvFlt.WriteFileReturnResult = HResult.Ok;

                    mockGvFlt.OnGetFileStream(
                        commandId: 1,
                        relativePath: "test.txt",
                        byteOffset: 0,
                        length: fileLength,
                        streamGuid: Guid.NewGuid(),
                        contentId: contentId,
                        providerId: placeholderVersion,
                        triggeringProcessId: 2,
                        triggeringProcessImageFileName: "UnitTest").ShouldEqual(HResult.Pending);

                    mockGvFlt.WaitForCompletionStatus().ShouldEqual(HResult.Ok);

                    callbacks.Stop();
                }
        }
Пример #6
0
        public void OnGetFileStreamReturnsErrorWhenWriteFileContentsFails()
        {
            const string TestFileName = "test.txt";

            using (MockBackgroundFileSystemTaskRunner backgroundTaskRunner = new MockBackgroundFileSystemTaskRunner())
                using (MockVirtualizationInstance mockVirtualization = new MockVirtualizationInstance())
                    using (MockGitIndexProjection gitIndexProjection = new MockGitIndexProjection(new[] { TestFileName }))
                        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,
                                       backgroundFileSystemTaskRunner: backgroundTaskRunner,
                                       fileSystemVirtualizer: virtualizer))
                            {
                                string error;
                                fileSystemCallbacks.TryStart(out error).ShouldEqual(true);

                                byte[] contentId          = FileSystemVirtualizer.ConvertShaToContentId("0123456789012345678901234567890123456789");
                                byte[] placeholderVersion = MacFileSystemVirtualizer.PlaceholderVersionId;

                                uint fileLength = 100;
                                MockGVFSGitObjects mockGVFSGitObjects = this.Repo.GitObjects as MockGVFSGitObjects;
                                mockGVFSGitObjects.FileLength            = fileLength;
                                mockVirtualization.WriteFileReturnResult = Result.EIOError;

                                mockVirtualization.OnGetFileStream(
                                    commandId: 1,
                                    relativePath: TestFileName,
                                    providerId: placeholderVersion,
                                    contentId: contentId,
                                    triggeringProcessId: 2,
                                    triggeringProcessName: "UnitTest",
                                    fileHandle: IntPtr.Zero).ShouldEqual(Result.EIOError);

                                fileSystemCallbacks.Stop();
                            }
        }