centralized path verification

adapted tests for correctness
added tests

TestHelpers.Tests/MockFileAppendAllLinesTests.cs

@@ -46,5 +46,90 @@ public void MockFile_AppendAllLines_ShouldPersistNewLinesToNewFile()
                 "line 1" + Environment.NewLine + "line 2" + Environment.NewLine + "line 3" + Environment.NewLine,
                 file.ReadAllText(path));
         }
+
+        [Test]
+        public void MockFile_AppendAllLines_ShouldThrowArgumentExceptionIfPathIsZeroLength()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.AppendAllLines(string.Empty, new[] { "does not matter" });
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
+
+        [TestCase(" ")]
+        [TestCase("   ")]
+        public void MockFile_AppendAllLines_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.AppendAllLines(path, new[] { "does not matter" });
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
+
+        [TestCase("\"")]
+        [TestCase("<")]
+        [TestCase(">")]
+        [TestCase("|")]
+        public void MockFile_AppendAllLines_ShouldThrowArgumentExceptionIfPathContainsInvalidChar(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.AppendAllLines(path, new[] { "does not matter" });
+
+            // Assert
+            Assert.Throws<NotSupportedException>(action);
+        }
+
+        [Test]
+        public void MockFile_AppendAllLines_ShouldThrowArgumentNullExceptionIfPathIsNull()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.AppendAllLines(null, new[] { "does not matter" });
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("path"));
+        }
+
+        [Test]
+        public void MockFile_AppendAllLines_ShouldThrowArgumentNullExceptionIfContentIsNull()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.AppendAllLines("foo", null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("contents"));
+        }
+
+        [Test]
+        public void MockFile_AppendAllLines_ShouldThrowArgumentNullExceptionIfEncodingIsNull()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.AppendAllLines("foo.txt", new [] { "bar" }, null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("encoding"));
+        }
     }
 }

TestHelpers.Tests/MockFileCopyTests.cs

@@ -224,7 +224,7 @@ public void MockFile_Copy_ShouldThrowArgumentExceptionWhenSourceIsStringOfBlanks
 
             var exception = Assert.Throws<ArgumentException>(() => fileSystem.File.Copy(sourceFilePath, destFilePath));
 
-            Assert.That(exception.Message, Is.EqualTo("The path is not of a legal form."));
+            Assert.That(exception.Message, Is.StringStarting("The path is not of a legal form."));
         }
 
         [Test]
@@ -258,7 +258,7 @@ public void MockFile_Copy_ShouldThrowArgumentExceptionWhenTargetIsStringOfBlanks
 
             var exception = Assert.Throws<ArgumentException>(() => fileSystem.File.Copy(sourceFilePath, destFilePath));
 
-            Assert.That(exception.Message, Is.EqualTo("The path is not of a legal form."));
+            Assert.That(exception.Message, Is.StringStarting("The path is not of a legal form."));
         }
 
         [Test]

TestHelpers.Tests/MockFileCreateTests.cs

@@ -10,7 +10,8 @@ namespace System.IO.Abstractions.TestingHelpers.Tests
 
     using XFS = MockUnixSupport;
 
-    public class MockFileCreateTests {
+    public class MockFileCreateTests
+    {
         [Test]
         public void Mockfile_Create_ShouldCreateNewStream()
         {
@@ -73,16 +74,75 @@ public void Mockfile_Create_OverwritesExistingFile()
         }
 
         [Test]
-        public void Mockfile_Create_ThrowsWhenPathIsReadOnly()
+        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).Close());
             Assert.That(exception.Message, Is.EqualTo(string.Format(CultureInfo.InvariantCulture, "Access to the path '{0}' is denied.", path)));
         }
+
+        [Test]
+        public void Mockfile_Create_ShouldThrowArgumentExceptionIfPathIsZeroLength()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.Create("");
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
+
+        [Test]
+        public void Mockfile_Create_ShouldThrowArgumentNullExceptionIfPathIsNull()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.Create(null);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [TestCase("\"")]
+        [TestCase("<")]
+        [TestCase(">")]
+        [TestCase("|")]
+        public void MockFile_Create_ShouldThrowArgumentNullExceptionIfPathIsNull(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.Create(path);
+
+            // Assert
+            Assert.Throws<NotSupportedException>(action);
+        }
+
+        [TestCase(" ")]
+        [TestCase("   ")]
+        public void MockFile_Create_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.Create(path);
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
     }
 }

TestHelpers.Tests/MockFileDeleteTests.cs

@@ -21,5 +21,19 @@ public void MockFile_Delete_ShouldDeleteFile()
             Assert.AreEqual(1, fileCount1, "File should have existed");
             Assert.AreEqual(0, fileCount2, "File should have been deleted");
         }
+
+        [TestCase(" ")]
+        [TestCase("   ")]
+        public void MockFile_Delete_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.Delete(path);
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
     }
 }

TestHelpers.Tests/MockFileGetCreationTimeTests.cs

@@ -0,0 +1,50 @@
+using NUnit.Framework;
+
+namespace System.IO.Abstractions.TestingHelpers.Tests
+{
+    [TestFixture]
+    public class MockFileGetCreationTimeTests
+    {
+        [Test]
+        public void MockFile_GetCreationTime_ShouldThrowArgumentNullExceptionIfPathIsNull()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.GetCreationTime(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("path"));
+        }
+
+        [TestCase(" ")]
+        [TestCase("   ")]
+        public void MockFile_GetCreationTime_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.GetCreationTime(path);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("path"));
+        }
+
+        [Test]
+        public void MockFile_GetCreationTime_ShouldReturnDefaultTimeIfFileDoesNotExist()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            var actualCreationTime = fileSystem.File.GetCreationTime(@"c:\does\not\exist.txt");
+
+            // Assert
+            Assert.AreEqual(new DateTime(1601, 01, 01, 01, 00, 00, DateTimeKind.Utc), actualCreationTime);
+        }
+    }
+}

TestHelpers.Tests/MockFileGetCreationTimeUtcTests.cs

@@ -0,0 +1,50 @@
+using NUnit.Framework;
+
+namespace System.IO.Abstractions.TestingHelpers.Tests
+{
+    [TestFixture]
+    public class MockFileGetCreationTimeUtcTests
+    {
+        [Test]
+        public void MockFile_GetCreationTimeUtc_ShouldThrowArgumentNullExceptionIfPathIsNull()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.GetCreationTimeUtc(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("path"));
+        }
+
+        [TestCase(" ")]
+        [TestCase("   ")]
+        public void MockFile_GetCreationTimeUtc_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.GetCreationTimeUtc(path);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("path"));
+        }
+
+        [Test]
+        public void MockFile_GetCreationTimeUtc_ShouldReturnDefaultTimeIfFileDoesNotExist()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            var actualCreationTime = fileSystem.File.GetCreationTimeUtc(@"c:\does\not\exist.txt");
+
+            // Assert
+            Assert.AreEqual(new DateTime(1601, 01, 01, 00, 00, 00, DateTimeKind.Utc), actualCreationTime);
+        }
+    }
+}

TestHelpers.Tests/MockFileGetLastAccessTimeTests.cs

@@ -0,0 +1,50 @@
+using NUnit.Framework;
+
+namespace System.IO.Abstractions.TestingHelpers.Tests
+{
+    [TestFixture]
+    public class MockFileGetLastAccessTimeTests
+    {
+        [Test]
+        public void MockFile_GetLastAccessTime_ShouldThrowArgumentNullExceptionIfPathIsNull()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.GetLastAccessTime(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("path"));
+        }
+
+        [TestCase(" ")]
+        [TestCase("   ")]
+        public void MockFile_GetLastAccessTime_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            TestDelegate action = () => fileSystem.File.GetLastAccessTime(path);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentException>(action);
+            Assert.That(exception.ParamName, Is.EqualTo("path"));
+        }
+
+        [Test]
+        public void MockFile_GetLastAccessTime_ShouldReturnDefaultTimeIfFileDoesNotExist()
+        {
+            // Arrange
+            var fileSystem = new MockFileSystem();
+
+            // Act
+            var actualLastAccessTime = fileSystem.File.GetLastAccessTime(@"c:\does\not\exist.txt");
+
+            // Assert
+            Assert.AreEqual(new DateTime(1601, 01, 01, 01, 00, 00, DateTimeKind.Utc), actualLastAccessTime);
+        }
+    }
+}