public void Mockfile_Create_OverwritesExistingFile()
        {
            string path = XFS.Path(@"c:\some\file.txt");
            var fileSystem = new MockFileSystem();

            var mockFile = new MockFile(fileSystem);

            fileSystem.Directory.CreateDirectory(Path.GetDirectoryName(path));

            // Create a file
            using (var stream = mockFile.Create(path))
            {
                var contents = new UTF8Encoding(false).GetBytes("Test 1");
                stream.Write(contents, 0, contents.Length);
            }

            // Create new file that should overwrite existing file
            var expectedContents = new UTF8Encoding(false).GetBytes("Test 2");
            using (var stream = mockFile.Create(path))
            {
                stream.Write(expectedContents, 0, expectedContents.Length);
            }

            var actualContents = fileSystem.GetFile(path).Contents;

            Assert.That(actualContents, Is.EqualTo(expectedContents));
        }
        public void Mockfile_Create_OverwritesExistingFile()
        {
            string         path       = XFS.Path(@"c:\some\file.txt");
            MockFileSystem fileSystem = new MockFileSystem();

            MockFile mockFile = new MockFile(fileSystem);

            // Create a file
            using (Stream stream = mockFile.Create(path))
            {
                byte[] contents = new UTF8Encoding(false).GetBytes("Test 1");
                stream.Write(contents, 0, contents.Length);
            }

            // Create new file that should overwrite existing file
            byte[] expectedContents = new UTF8Encoding(false).GetBytes("Test 2");
            using (Stream stream = mockFile.Create(path))
            {
                stream.Write(expectedContents, 0, expectedContents.Length);
            }

            byte[] actualContents = fileSystem.GetFile(path).Contents;

            Assert.Equal(actualContents, expectedContents);
        }
        public void Mockfile_Create_OverwritesExistingFile()
        {
            string path       = XFS.Path(@"c:\some\file.txt");
            var    fileSystem = new MockFileSystem();

            fileSystem.AddDirectory(XFS.Path(@"c:\some"));

            var mockFile = new MockFile(fileSystem);

            // Create a file
            using (var stream = mockFile.Create(path))
            {
                var contents = new UTF8Encoding(false).GetBytes("Test 1");
                stream.Write(contents, 0, contents.Length);
            }

            // Create new file that should overwrite existing file
            var expectedContents = new UTF8Encoding(false).GetBytes("Test 2");

            using (var stream = mockFile.Create(path))
            {
                stream.Write(expectedContents, 0, expectedContents.Length);
            }

            var actualContents = fileSystem.GetFile(path).Contents;

            Assert.That(actualContents, Is.EqualTo(expectedContents));
        }
        private IFile MockSecretFile(string secretKey, string text)
        {
            var file = new MockFile("c:\\sss\\secret.txt", null);

            file.Create(text);
            ((MockDirectory)pubProfiles).AddRawFile(
                $@"C:\Profile\Microsoft\UserSecrets\{secretKey}\secrets.json",
                file);
            return(file);
        }
 public void Mockfile_Create_ThrowsWhenPathIsReadOnly()
 {
     string path = XFS.Path(@"c:\something\read-only.txt");
     var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData> { { path, new MockFileData("Content") } });
     var mockFile = new MockFile(fileSystem);
     
     mockFile.SetAttributes(path, FileAttributes.ReadOnly);
  
     var exception =  Assert.Throws<UnauthorizedAccessException>(() => mockFile.Create(path).Close());
     Assert.That(exception.Message, Is.EqualTo(string.Format(CultureInfo.InvariantCulture, "Access to the path '{0}' is denied.", path)));
 }
        public void Mockfile_CreateOverload_ShouldCreateNewStream()
        {
            string fullPath   = XFS.Path(@"c:\something\demo.txt");
            var    fileSystem = new MockFileSystem();

            fileSystem.AddDirectory(XFS.Path(@"c:\something"));
            FileOptions fileOption = FileOptions.WriteThrough;
            var         mockFile   = new MockFile(fileSystem);

            Assert.That(fileSystem.FileExists(fullPath), Is.False);
            mockFile.Create(fullPath, 20, fileOption).Dispose();
            Assert.That(fileSystem.FileExists(fullPath), Is.True);
        }
        public void Mockfile_Create_ShouldCreateNewStream()
        {
            string fullPath   = XFS.Path(@"c:\something\demo.txt");
            var    fileSystem = new MockFileSystem();

            var sut = new MockFile(fileSystem);

            Assert.False(fileSystem.FileExists(fullPath));

            sut.Create(fullPath).Dispose();

            Assert.True(fileSystem.FileExists(fullPath));
        }
        public void Mockfile_Create_ShouldCreateNewStream()
        {
            string fullPath = XFS.Path(@"c:\something\demo.txt");
            var fileSystem = new MockFileSystem();

            var sut = new MockFile(fileSystem);

            Assert.That(fileSystem.FileExists(fullPath), Is.False);

            sut.Create(fullPath).Close();

            Assert.That(fileSystem.FileExists(fullPath), Is.True);
        }
예제 #9
0
        public void Mockfile_Create_ShouldCreateNewStream()
        {
            const string fullPath   = @"c:\something\demo.txt";
            var          fileSystem = new MockFileSystem();

            var sut = new MockFile(fileSystem);

            Assert.That(fileSystem.FileExists(fullPath), Is.False);

            sut.Create(fullPath).Close();

            Assert.That(fileSystem.FileExists(fullPath), Is.True);
        }
예제 #10
0
        public void Mockfile_Create_ThrowsWhenPathIsReadOnly()
        {
            const string path       = @"c:\something\read-only.txt";
            var          fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> {
                { path, new MockFileData("Content") }
            });
            var mockFile = new MockFile(fileSystem);

            mockFile.SetAttributes(path, FileAttributes.ReadOnly);

            var exception = Assert.Throws <UnauthorizedAccessException>(() => mockFile.Create(path).Close());

            Assert.That(exception.Message, Is.EqualTo(string.Format("Access to the path '{0}' is denied.", path)));
        }
        public void Mockfile_Create_ShouldThrowUnauthorizedAccessExceptionIfPathIsReadOnly()
        {
            // Arrange
            string path       = XFS.Path(@"c:\something\read-only.txt");
            var    fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> {
                { path, new MockFileData("Content") }
            });
            var mockFile = new MockFile(fileSystem);

            // Act
            mockFile.SetAttributes(path, FileAttributes.ReadOnly);

            // Assert
            var exception = Assert.Throws <UnauthorizedAccessException>(() => mockFile.Create(path).Dispose());

            Assert.That(exception.Message, Is.EqualTo(string.Format(CultureInfo.InvariantCulture, "Access to the path '{0}' is denied.", path)));
        }
        public void Mockfile_Create_CanWriteToNewStream()
        {
            string fullPath = XFS.Path(@"c:\something\demo.txt");
            var fileSystem = new MockFileSystem();
            var data = new UTF8Encoding(false).GetBytes("Test string");

            var sut = new MockFile(fileSystem);
            using (var stream = sut.Create(fullPath))
            {
                stream.Write(data, 0, data.Length);
            }

            var mockFileData = fileSystem.GetFile(fullPath);
            var fileData = mockFileData.Contents;

            Assert.That(fileData, Is.EqualTo(data));
        }
예제 #13
0
        public void Mockfile_Create_CanWriteToNewStream()
        {
            const string fullPath   = @"c:\something\demo.txt";
            var          fileSystem = new MockFileSystem();
            var          data       = new UTF8Encoding(false).GetBytes("Test string");

            var sut = new MockFile(fileSystem);

            using (var stream = sut.Create(fullPath))
            {
                stream.Write(data, 0, data.Length);
            }

            var mockFileData = fileSystem.GetFile(fullPath);
            var fileData     = mockFileData.Contents;

            Assert.That(fileData, Is.EqualTo(data));
        }
        public void Mockfile_Create_CanWriteToNewStream()
        {
            string         fullPath   = XFS.Path(@"c:\something\demo.txt");
            MockFileSystem fileSystem = new MockFileSystem();

            byte[] data = new UTF8Encoding(false).GetBytes("Test string");

            MockFile sut = new MockFile(fileSystem);

            using (Stream stream = sut.Create(fullPath))
            {
                stream.Write(data, 0, data.Length);
            }

            MockFileData mockFileData = fileSystem.GetFile(fullPath);

            byte[] fileData = mockFileData.Contents;

            Assert.Equal(fileData, data);
        }
        public void Mockfile_CreateOverload_CanWriteToNewStream()
        {
            string fullPath   = XFS.Path(@"c:\something\demo.txt");
            var    fileSystem = new MockFileSystem();

            fileSystem.AddDirectory(XFS.Path(@"c:\something"));
            var data = new UTF8Encoding(false).GetBytes("Test string");

            var         sut        = new MockFile(fileSystem);
            FileOptions fileOption = FileOptions.WriteThrough;

            using (var stream = sut.Create(fullPath, data.Length, fileOption))
            {
                stream.Write(data, 0, data.Length);
            }

            var mockFileData = fileSystem.GetFile(fullPath);
            var fileData     = mockFileData.Contents;

            Assert.That(fileData, Is.EqualTo(data));
        }
        public void Mockfile_Create_ShouldCreateNewStream()
        {
            const string fullPath = @"c:\something\demo.txt";
            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());

            var sut = new MockFile(fileSystem);

            Assert.That(fileSystem.FileExists(fullPath), Is.False);

            sut.Create(fullPath).Close();

            Assert.That(fileSystem.FileExists(fullPath), Is.True);
        }
        public void Mockfile_Create_ShouldThrowUnauthorizedAccessExceptionIfPathIsReadOnly()
        {
            // Arrange
            string         path       = XFS.Path(@"c:\something\read-only.txt");
            MockFileSystem fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> {
                { path, new MockFileData("Content") }
            });
            MockFile mockFile = new MockFile(fileSystem);

            // Act
            mockFile.SetAttributes(path, FileAttributes.ReadOnly);

            // Assert
            UnauthorizedAccessException exception = Assert.Throws <UnauthorizedAccessException>(() => mockFile.Create(path).Dispose());

            Assert.Equal(exception.Message, $"Access to the path '{path}' is denied.");
        }