public void VaultSetsProperty()
        {
            var vault  = Moq.Mock.Of <Vault>();
            var stream = new Extensions.FileDownloadStream(Moq.Mock.Of <ObjectFile>(), vault);

            Assert.AreEqual(vault, stream.Vault);
        }
        public void ReadThrowsWithCountLargerThanByteArray2()
        {
            var data   = new byte[1];
            var stream = new Extensions.FileDownloadStream(Mock.Of <ObjectFile>(), Moq.Mock.Of <Vault>());

            stream.Read(data, 1, 1);
        }
        public void FileToDownloadSetsProperty()
        {
            var objectFile = Moq.Mock.Of <ObjectFile>();
            var stream     = new Extensions.FileDownloadStream(objectFile, Moq.Mock.Of <Vault>());

            Assert.AreEqual(objectFile, stream.FileToDownload);
        }
        public void ReadThrowsWithNegativeCount()
        {
            var data   = new byte[1];
            var stream = new Extensions.FileDownloadStream(Mock.Of <ObjectFile>(), Moq.Mock.Of <Vault>());

            stream.Read(data, 0, -1);
        }
        public void OpenDownloadSessionPopulatesDownloadSession
        (
            int fileId,
            int fileVersion,
            MFFileFormat fileFormat
        )
        {
            // Set up a file to download.
            var objectFileMock = new Mock <ObjectFile>();

            objectFileMock.SetupGet(m => m.ID).Returns(fileId);
            objectFileMock.SetupGet(m => m.Version).Returns(fileVersion);

            // Set up the vault object file operations mock.
            var vaultObjectFileOperationsMock = new Mock <VaultObjectFileOperations>();

            // When DownloadFileInBlocks_BeginEx is called, return a dummy session.
            vaultObjectFileOperationsMock
            .Setup(m => m.DownloadFileInBlocks_BeginEx
                   (
                       Moq.It.IsAny <int>(),
                       Moq.It.IsAny <int>(),
                       Moq.It.IsAny <MFFileFormat>()
                   ))
            .Returns((int receivedFileId, int receivedFileVersion, MFFileFormat receivedFileFormat) =>
            {
                // Ensure we got the right data.
                Assert.AreEqual(fileId, receivedFileId);
                Assert.AreEqual(fileVersion, receivedFileVersion);
                Assert.AreEqual(fileFormat, receivedFileFormat);

                // Mock a download session to return.
                var downloadSessionMock = new Mock <FileDownloadSession>();
                downloadSessionMock.SetupGet(m => m.DownloadID).Returns(1);
                downloadSessionMock.SetupGet(m => m.FileSize).Returns(1000);
                downloadSessionMock.SetupGet(m => m.FileSize32).Returns(1000);
                return(downloadSessionMock.Object);
            })
            .Verifiable();

            // Set up the mock vault.
            var vaultMock = new Mock <Vault>();

            vaultMock
            .SetupGet(m => m.ObjectFileOperations)
            .Returns(vaultObjectFileOperationsMock.Object);

            // Act.
            var stream = new Extensions.FileDownloadStream(objectFileMock.Object, vaultMock.Object, fileFormat);

            stream.OpenDownloadSession();

            // Ensure object is populated.
            Assert.IsNotNull(stream.DownloadSession);

            // Ensure we got hit as expected.
            vaultMock.Verify();
            vaultObjectFileOperationsMock.Verify();
        }
        public void CloseDownloadSessionDoesNotThrowWithEmptyDownloadSession()
        {
            // Create the stream.
            var stream = new Extensions.FileDownloadStream(Moq.Mock.Of <ObjectFile>(), Moq.Mock.Of <Vault>());

            // Ensure the session is null.
            Assert.IsNull(stream.DownloadSession);

            // Close.
            stream.Close();
        }
        public void ReadCountZeroDoesNotThrow()
        {
            // Set up the vault object file operations mock.
            var vaultObjectFileOperationsMock = new Mock <VaultObjectFileOperations>();

            // When DownloadFileInBlocks_BeginEx is called (starting a download session), return a dummy session.
            vaultObjectFileOperationsMock
            .Setup(m => m.DownloadFileInBlocks_BeginEx
                   (
                       Moq.It.IsAny <int>(),
                       Moq.It.IsAny <int>(),
                       Moq.It.IsAny <MFFileFormat>()
                   ))
            .Returns((int receivedFileId, int receivedFileVersion, MFFileFormat receivedFileFormat) =>
            {
                // Mock a download session to return.
                var downloadSessionMock = new Mock <FileDownloadSession>();
                downloadSessionMock.SetupGet(m => m.DownloadID).Returns(1);
                downloadSessionMock.SetupGet(m => m.FileSize).Returns(1000);
                downloadSessionMock.SetupGet(m => m.FileSize32).Returns(1000);
                return(downloadSessionMock.Object);
            })
            .Verifiable();

            // Set up the mock vault.
            var vaultMock = new Mock <Vault>();

            vaultMock
            .SetupGet(m => m.ObjectFileOperations)
            .Returns(vaultObjectFileOperationsMock.Object);

            // Set up the data to read.
            var data = new byte[1];

            // Read some data.
            var stream = new Extensions.FileDownloadStream(Mock.Of <ObjectFile>(), vaultMock.Object);

            stream.Read(data, 0, 0);
        }
        public void DownloadSessionDefaultsToNull()
        {
            var stream = new Extensions.FileDownloadStream(Moq.Mock.Of <ObjectFile>(), Moq.Mock.Of <Vault>());

            Assert.IsNull(stream.DownloadSession);
        }
        public void FileFormatDefaultsToNative()
        {
            var stream = new Extensions.FileDownloadStream(Moq.Mock.Of <ObjectFile>(), Moq.Mock.Of <Vault>());

            Assert.AreEqual(MFFileFormat.MFFileFormatNative, stream.FileFormat);
        }
        public void ReadThrowsWithNullBuffer()
        {
            var stream = new Extensions.FileDownloadStream(Mock.Of <ObjectFile>(), Moq.Mock.Of <Vault>());

            stream.Read(null, 0, 1);
        }