Merge branch 'feature/break_up_parse_unit_tests' into develop

Resolves #69

Author: Jericho

Source/HttpMultipartParser.UnitTests/HttpMultipartFormParserUnitTests.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace HttpMultipartParser.UnitTests.ParserScenarios
+{
+    /// <summary>
+    ///     Tests that the final '--' ending up in a seperate chunk doesn't break everything.
+    /// </summary>
+    public class ExactBufferTruncate
+    {
+        private static readonly string _testData = TestUtil.TrimAllLines(@"--boundry
+            Content-Disposition: form-data; name=""text""
+
+            textdata
+            --boundry
+            Content-Disposition: form-data; name=""file""; filename=""data.txt""
+            Content-Type: text/plain
+
+            1234567890123456789012
+            --boundry--");
+
+        /// <summary>
+        ///     This test has the buffer split such that the final '--' of the end boundary
+        ///     falls into the next buffer.
+        /// </summary>
+        private static readonly TestData _testCase = new TestData(
+            _testData,
+            new List<ParameterPart> {
+                new ParameterPart("text", "textdata")
+            },
+            new List<FilePart> {
+                new FilePart( "file", "data.txt", TestUtil.StringToStreamNoBom("1234567890123456789012"))
+            }
+        );
+
+        public ExactBufferTruncate()
+        {
+            foreach (var filePart in _testCase.ExpectedFileData)
+            {
+                filePart.Data.Position = 0;
+            }
+        }
+
+
+        /// <summary>
+        ///     Tests that the final '--' ending up in a seperate chunk doesn't break everything.
+        /// </summary>
+        [Fact]
+        public void CanHandleFinalDashesInSeperateBufferFromEndBinary()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8, 16);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
+
+        /// <summary>
+        ///     Tests that the final '--' ending up in a seperate chunk doesn't break everything.
+        /// </summary>
+        [Fact]
+        public async Task CanHandleFinalDashesInSeperateBufferFromEndBinaryAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8, 16).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+    }
+}

Source/HttpMultipartParser.UnitTests/ParserScenarios/ExactBufferTruncate.cs

@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace HttpMultipartParser.UnitTests.ParserScenarios
+{
+    /// <summary>
+    ///     Test for cases where the file is last with expected outcomes.
+    /// </summary>
+    public class FileIsLast
+    {
+        private static readonly string _testData = TestUtil.TrimAllLines(
+            @"-----------------------------41952539122868
+            Content-Disposition: form-data; name=""adID""
+
+            1425
+            -----------------------------41952539122868
+            Content-Disposition: form-data; name=""files[]""; filename=""Capture.JPG""
+            Content-Type: image/jpeg
+
+             BinaryData
+             -----------------------------41952539122868--");
+
+        private static readonly TestData _testCase = new TestData(
+            _testData,
+            new List<ParameterPart> {
+                new ParameterPart("adID", "1425")
+            },
+            new List<FilePart> {
+                new FilePart("files[]", "Capture.JPG", TestUtil.StringToStreamNoBom("BinaryData"), "image/jpeg", "form-data")
+            }
+        );
+
+        public FileIsLast()
+        {
+            foreach (var filePart in _testCase.ExpectedFileData)
+            {
+                filePart.Data.Position = 0;
+            }
+        }
+
+        [Fact]
+        public void CanHandleFileAsLastSection()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
+        [Fact]
+        public async Task CanHandleFileAsLastSectionAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+    }
+}

Source/HttpMultipartParser.UnitTests/ParserScenarios/FileIsLast.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace HttpMultipartParser.UnitTests.ParserScenarios
+{
+    public class FullPathAsFileName
+    {
+        private static readonly string _testData = TestUtil.TrimAllLines(
+            @"-----------------------------7de6cc440a46
+            Content-Disposition: form-data; name=""file""; filename=""C:\test\test;abc.txt""
+            Content-Type: text/plain
+
+            test
+            -----------------------------7de6cc440a46--"
+            );
+
+        private static readonly TestData _testCase = new TestData(
+            _testData,
+            new List<ParameterPart>(),
+            new List<FilePart> {
+                    new FilePart("file", "test;abc.txt", TestUtil.StringToStream("test"), "text/plain", "form-data")
+            }
+        );
+
+        public FullPathAsFileName()
+        {
+            foreach (var filePart in _testCase.ExpectedFileData)
+            {
+                filePart.Data.Position = 0;
+            }
+        }
+
+        [Fact]
+        public void HandlesFullPathAsFileNameWithSemicolonCorrectly()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
+        [Fact]
+        public async Task HandlesFullPathAsFileNameWithSemicolonCorrectlyAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+    }
+}

Source/HttpMultipartParser.UnitTests/ParserScenarios/FullPathAsFileName.cs

@@ -0,0 +1,66 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace HttpMultipartParser.UnitTests.ParserScenarios
+{
+    public class MixedSingleByteAndMultiByteWidth
+    {
+        private static readonly string _testData = TestUtil.TrimAllLines(
+            @"-----------------------------41952539122868
+            Content-Disposition: form-data; name=""تت""
+
+            1425
+            -----------------------------41952539122868
+            Content-Disposition: form-data; name=""files[]""; filename=""تست.jpg""
+            Content-Type: image/jpeg
+
+             BinaryData
+             -----------------------------41952539122868--"
+            );
+
+        private static readonly TestData _testCase = new TestData(
+            _testData,
+            new List<ParameterPart> {
+                new ParameterPart("تت", "1425")
+            },
+            new List<FilePart> {
+                new FilePart("files[]", "تست.jpg", TestUtil.StringToStreamNoBom("BinaryData"), "image/jpeg", "form-data")
+            }
+        );
+
+        public MixedSingleByteAndMultiByteWidth()
+        {
+            foreach (var filePart in _testCase.ExpectedFileData)
+            {
+                filePart.Data.Position = 0;
+            }
+        }
+
+        [Fact]
+        public void CanHandleMixedSingleByteAndMultiByteWidthCharacters()
+        {
+            using (
+                Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8)
+                )
+            {
+                var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
+        [Fact]
+        public async Task CanHandleMixedSingleByteAndMultiByteWidthCharactersAsync()
+        {
+            using (
+                Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8)
+                )
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+    }
+}

Source/HttpMultipartParser.UnitTests/ParserScenarios/MixedSingleByteAndMultiByteWidth.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace HttpMultipartParser.UnitTests.ParserScenarios
+{
+    public class MixedUnicodeWidthAndAsciiWidthCharacters
+    {
+        private static readonly string _testData = TestUtil.TrimAllLines(
+            @"--boundary_.oOo._MjQ1NTU=OTk3Ng==MjcxODE=
+              Content-Disposition: form-data; name=""psAdTitle""
+
+              Bonjour poignée 
+              --boundary_.oOo._MjQ1NTU=OTk3Ng==MjcxODE=--"
+            );
+
+        private static readonly TestData _testCase = new TestData(
+            _testData,
+            new List<ParameterPart> {
+                new ParameterPart("psAdTitle", "Bonjour poignée")
+            },
+            new List<FilePart>()
+        );
+
+        public MixedUnicodeWidthAndAsciiWidthCharacters()
+        {
+            foreach (var filePart in _testCase.ExpectedFileData)
+            {
+                filePart.Data.Position = 0;
+            }
+        }
+
+        [Fact]
+        public void CanHandleUnicodeWidthAndAsciiWidthCharacters()
+        {
+            using (
+                Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
+        [Fact]
+        public async Task CanHandleUnicodeWidthAndAsciiWidthCharactersAsync()
+        {
+            using (
+                Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+    }
+}