Added support in MockFileInfo for both get and set of properties including:

CreationTime, CreationTimeUtc,
LastAccessTime, LastAccessTimeUtc,
LastWriteTime, LastWriteTimeUtc,
IsReadOnly.

Encrypt and Decrypt will now respond by internally performing a XOR across the byte array.

OpenWrite and AppendText now work.

NOTE: No attempt is currently made to insure a file marked read only file is not written to.

Tests added to cover these new features.
MockFileStream supports append (defaults to no append)

Author: willrawls

TestHelpers.Tests/MockFileInfoTests.cs

@@ -101,6 +101,198 @@ public void MockFileInfo_CreationTimeUtc_ShouldReturnCreationTimeUtcOfFileInMemo
             Assert.AreEqual(creationTime.ToUniversalTime(), result);
         }
 
+        [Test]
+        public void MockFileInfo_CreationTimeUtc_ShouldSetCreationTimeUtcOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var creationTime = DateTime.Now.AddHours(-4);
+            var fileData = new MockFileData("Demo text content") { CreationTime = creationTime };
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            var newUtcTime = DateTime.UtcNow;
+            fileInfo.CreationTimeUtc = newUtcTime;
+
+            // Assert
+            Assert.AreEqual(newUtcTime, fileInfo.CreationTimeUtc);
+        }
+
+
+        [Test]
+        public void MockFileInfo_CreationTime_ShouldReturnCreationTimeOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var creationTime = DateTime.Now.AddHours(-4);
+            var fileData = new MockFileData("Demo text content") { CreationTime = creationTime };
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            var result = fileInfo.CreationTime;
+
+            // Assert
+            Assert.AreEqual(creationTime, result);
+        }
+
+        [Test]
+        public void MockFileInfo_CreationTime_ShouldSetCreationTimeOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var creationTime = DateTime.Now.AddHours(-4);
+            var fileData = new MockFileData("Demo text content") { CreationTime = creationTime };
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            var newTime = DateTime.Now;
+            fileInfo.CreationTime = newTime;
+
+            // Assert
+            Assert.AreEqual(newTime, fileInfo.CreationTime);
+        }
+
+        [Test]
+        public void MockFileInfo_IsReadOnly_ShouldSetReadOnlyAttributeOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var fileData = new MockFileData("Demo text content");
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            fileInfo.IsReadOnly = true;
+
+            // Assert
+            Assert.AreEqual(FileAttributes.ReadOnly, fileData.Attributes & FileAttributes.ReadOnly);
+        }
+
+        [Test]
+        public void MockFileInfo_IsReadOnly_ShouldSetNotReadOnlyAttributeOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var fileData = new MockFileData("Demo text content") {Attributes = FileAttributes.ReadOnly};
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            fileInfo.IsReadOnly = false;
+
+            // Assert
+            Assert.AreNotEqual(FileAttributes.ReadOnly, fileData.Attributes & FileAttributes.ReadOnly);
+        }
+
+        [Test]
+        public void MockFileInfo_AppendText_ShouldAddTextToFileInMemoryFileSystem()
+        {
+            // Arrange
+            var fileData = new MockFileData("Demo text content");
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            using (var file = fileInfo.AppendText())
+                file.WriteLine("This should be at the end");
+
+            string newcontents;
+            using (var newfile = fileInfo.OpenText())
+                newcontents = newfile.ReadToEnd();
+
+            // Assert
+            Assert.AreEqual("Demo text contentThis should be at the end\r\n", newcontents);
+        }
+
+        [Test]
+        public void MockFileInfo_OpenWrite_ShouldAddDataToFileInMemoryFileSystem()
+        {
+            // Arrange
+            var fileData = new MockFileData("Demo text content");
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+            var bytesToAdd = new byte[] {65, 66, 67, 68, 69};
+
+            // Act
+            using (var file = fileInfo.OpenWrite())
+                file.Write(bytesToAdd, 0, bytesToAdd.Length);
+
+            string newcontents;
+            using (var newfile = fileInfo.OpenText())
+                newcontents = newfile.ReadToEnd();
+
+            // Assert
+            Assert.AreEqual("ABCDEtext content", newcontents);
+        }
+
+        [Test]
+        public void MockFileInfo_Encrypt_ShouldReturnXorOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var fileData = new MockFileData("Demo text content");
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            fileInfo.Encrypt();
+
+            string newcontents;
+            using (var newfile = fileInfo.OpenText())
+            {
+                newcontents = newfile.ReadToEnd();
+            }
+
+            // Assert
+            Assert.AreNotEqual("Demo text content", newcontents);
+        }
+
+        [Test]
+        public void MockFileInfo_Decrypt_ShouldReturnCorrectContentsFileInMemoryFileSystem()
+        {
+            // Arrange
+            var fileData = new MockFileData("Demo text content");
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+            fileInfo.Encrypt();
+
+            // Act
+            fileInfo.Decrypt();
+
+            string newcontents;
+            using (var newfile = fileInfo.OpenText())
+            {
+                newcontents = newfile.ReadToEnd();
+            }
+
+            // Assert
+            Assert.AreEqual("Demo text content", newcontents);
+        }
+
         [Test]
         public void MockFileInfo_LastAccessTimeUtc_ShouldReturnLastAccessTimeUtcOfFileInMemoryFileSystem()
         {
@@ -120,6 +312,26 @@ public void MockFileInfo_LastAccessTimeUtc_ShouldReturnLastAccessTimeUtcOfFileIn
             Assert.AreEqual(lastAccessTime.ToUniversalTime(), result);
         }
 
+        [Test]
+        public void MockFileInfo_LastAccessTimeUtc_ShouldSetCreationTimeUtcOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var lastAccessTime = DateTime.Now.AddHours(-4);
+            var fileData = new MockFileData("Demo text content") { LastAccessTime = lastAccessTime };
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            var newUtcTime = DateTime.UtcNow;
+            fileInfo.LastAccessTimeUtc = newUtcTime;
+
+            // Assert
+            Assert.AreEqual(newUtcTime, fileInfo.LastAccessTimeUtc);
+        }
+
         [Test]
         public void MockFileInfo_LastWriteTimeUtc_ShouldReturnLastWriteTimeUtcOfFileInMemoryFileSystem()
         {
@@ -138,7 +350,27 @@ public void MockFileInfo_LastWriteTimeUtc_ShouldReturnLastWriteTimeUtcOfFileInMe
             // Assert
             Assert.AreEqual(lastWriteTime.ToUniversalTime(), result);
         }
- 
+
+        [Test]
+        public void MockFileInfo_LastWriteTimeUtc_ShouldSetLastWriteTimeUtcOfFileInMemoryFileSystem()
+        {
+            // Arrange
+            var lastWriteTime = DateTime.Now.AddHours(-4);
+            var fileData = new MockFileData("Demo text content") { LastWriteTime = lastWriteTime };
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"c:\a.txt", fileData }
+            });
+            var fileInfo = new MockFileInfo(fileSystem, @"c:\a.txt");
+
+            // Act
+            var newUtcTime = DateTime.UtcNow;
+            fileInfo.LastWriteTime = newUtcTime;
+
+            // Assert
+            Assert.AreEqual(newUtcTime, fileInfo.LastWriteTime);
+        }
+
         [Test]
         public void MockFileInfo_GetExtension_ShouldReturnExtension()
         {