Add some tests of Swagger.ObjectModel

src/Swagger.ObjectModel/Utilities.cs

@@ -5,9 +5,14 @@ namespace Swagger.ObjectModel
 {
     public static class Utilities
     {
+        /// <summary>
+        /// convert a string to camelcase with special rules.
+        /// </summary>
+        /// <param name="val">the string need to be convertd</param>
+        /// <returns></returns>
         public static string ToCamelCase(string val)
         {
-            if (String.IsNullOrEmpty(val))
+            if (String.IsNullOrWhiteSpace(val))
             {
                 return val;
             }

test/Swagger.ObjectModel.Tests/Builders/BodyParameterBuilderTest.cs

@@ -0,0 +1,63 @@
+using Swagger.ObjectModel.Builders;
+using Xunit;
+
+namespace Swagger.ObjectModel.Tests.Builders
+{
+    public class BodyParameterBuilderTest
+    {
+        private readonly BodyParameterBuilder builder;
+        private readonly string name;
+        private readonly Schema schema; 
+        public BodyParameterBuilderTest()
+        {            
+            this.builder = new BodyParameterBuilder();
+
+            this.name = "name";
+            this.schema = new Schema
+            {
+                Description = "some description"
+            };
+        }
+
+        [Fact]
+        public void Should_ThrowRequiredFieldException_WhenNameOrSchemaIsNull()
+        {
+            // Assert
+            Assert.Throws(typeof(RequiredFieldException), () => builder.Build());
+            Assert.Throws(typeof(RequiredFieldException), () => builder.Name(name).Build());
+            Assert.Throws(typeof(RequiredFieldException), () => builder.Name(string.Empty).Schema(schema).Build());
+        }
+
+        [Fact]
+        public void Should_AbleToSetNameAndSchema()
+        {
+            // Arrange           
+            // Act
+            var bodyParameter = builder.Name(name)
+                                       .Schema(schema)
+                                       .Build();
+
+            // Assert
+            Assert.NotNull(bodyParameter);
+            Assert.Equal(name, bodyParameter.Name);
+            Assert.Same(schema, bodyParameter.Schema);
+        }
+
+        [Fact]
+        public void Should_AbleToSetDescription()
+        {
+            // Arrange   
+            string description = "description";
+
+            // Act
+            var bodyParameter = builder.Name(name)
+                                       .Schema(schema)
+                                       .Description(description)
+                                       .Build();
+
+            // Assert
+            Assert.NotNull(bodyParameter);
+            Assert.Equal(description, bodyParameter.Description);
+        }
+    }
+}

test/Swagger.ObjectModel.Tests/Builders/ContactBuilderTest.cs

@@ -0,0 +1,78 @@
+using Swagger.ObjectModel.Builders;
+using Xunit;
+
+namespace Swagger.ObjectModel.Tests.Builders
+{
+    public class ContactBuilderTest
+    {
+        private readonly ContactBuilder builder;
+        public ContactBuilderTest()
+        {
+            this.builder = new ContactBuilder();
+        }
+
+        [Fact]
+        public void Should_AbleToSetName()
+        {
+            // Arrange   
+            string name = "name";
+
+            // Act
+            var contact = builder.Name(name).Build();
+
+            // Assert
+            Assert.NotNull(contact);
+            Assert.Equal(name, contact.Name);
+        }
+
+        [Fact]
+        public void Should_AbleToSetEmailAddress()
+        {
+            // Arrange   
+            string email = "[email protected]";
+
+            // Act
+            var contact = builder.EmailAddress(email).Build();
+
+            // Assert
+            Assert.NotNull(contact);
+            Assert.Equal(email, contact.EmailAddress);            
+        }
+
+        [Fact]
+        public void Should_AbleToSetUrl()
+        {
+            // Arrange   
+            string url = "https://github.com/yahehe/Nancy.Swagger";
+
+            // Act
+            var contact = builder.Url(url).Build();
+
+            // Assert
+            Assert.NotNull(contact);
+            Assert.Equal(url, contact.Url);
+        }
+
+        [Fact]
+        public void Should_AbleToSetAllProperties()
+        {
+            // Arrange   
+            string name = "name";
+            string email = "[email protected]";
+            string url = "https://github.com/yahehe/Nancy.Swagger";
+
+            // Act
+            var contact = builder.Name(name)
+                                 .EmailAddress(email)
+                                 .Url(url)
+                                 .Build();
+
+            // Assert
+            Assert.NotNull(contact);
+            Assert.Equal(name, contact.Name);
+            Assert.Equal(email, contact.EmailAddress);
+            Assert.Equal(url, contact.Url);
+        }
+
+    }
+}

test/Swagger.ObjectModel.Tests/Builders/ExternalDocumentationBuilderTest.cs

@@ -0,0 +1,61 @@
+using Swagger.ObjectModel.Builders;
+using Xunit;
+
+namespace Swagger.ObjectModel.Tests.Builders
+{
+    public class ExternalDocumentationBuilderTest
+    {
+        private readonly ExternalDocumentationBuilder builder;
+        private readonly string url = string.Empty;
+        public ExternalDocumentationBuilderTest()
+        {
+            this.builder = new ExternalDocumentationBuilder();
+            this.url = "https://github.com/yahehe/Nancy.Swagger";
+        }
+
+        [Fact]
+        public void Should_ThrowRequiredFieldException_WhenUrlIsNullOrEmpty()
+        {
+            // Assert                      
+            Assert.Throws(typeof(RequiredFieldException), () => builder.Url("").Build());
+            Assert.Throws(typeof(RequiredFieldException), () => builder.Url(null).Build());            
+        }
+
+        [Fact]
+        public void Should_ThrowRequiredFieldException_WhenUrlIsNotSet()
+        {
+            // Assert
+            Assert.Throws(typeof(RequiredFieldException), () => builder.Build());
+            Assert.Throws(typeof(RequiredFieldException), () => builder.Description("desc").Build());            
+        }
+
+        [Fact]
+        public void Should_AbleToSetUrl()
+        {
+            // Arrange              
+            // Act
+            var externalDocumentation = builder.Url(url).Build();
+
+            // Assert
+            Assert.NotNull(externalDocumentation);
+            Assert.Equal(url, externalDocumentation.Url);
+        }
+
+        [Fact]
+        public void Should_AbleToSetDescription()
+        {
+            // Arrange    
+            string description = "description";
+
+            // Act
+            var externalDocumentation = builder.Url(url)
+                                               .Description(description)
+                                               .Build();
+
+            // Assert
+            Assert.NotNull(externalDocumentation);
+            Assert.Equal(url, externalDocumentation.Url);
+            Assert.Equal(description, externalDocumentation.Description);
+        }
+    }
+}

test/Swagger.ObjectModel.Tests/Builders/HeaderBuilderTest.cs

@@ -0,0 +1,55 @@
+using Swagger.ObjectModel.Builders;
+using Xunit;
+
+namespace Swagger.ObjectModel.Tests.Builders
+{
+    public class HeaderBuilderTest
+    {
+        private readonly HeaderBuilder builder;
+        public HeaderBuilderTest()
+        {
+            this.builder = new HeaderBuilder();
+        }
+
+        [Fact]
+        public void Should_ReturnEmptyHeader_WhenSetNothing()
+        {
+            // Arrange              
+            // Act            
+            var header = builder.Build();
+
+            // Assert
+            Assert.NotNull(header);            
+            Assert.Null(header.Description);
+            Assert.Null(header.Default);
+        }
+
+        [Fact]
+        public void Should_AbleToSetDescription()
+        {
+            // Arrange       
+            string description = "description";
+
+            // Act
+            var header = builder.Description(description).Build();
+
+            // Assert
+            Assert.NotNull(header);
+            Assert.Equal(description,header.Description);
+        }
+
+        [Fact]
+        public void Should_AbleToSetDefaultOfDataType()
+        {
+            // Arrange       
+            object defaultValue = new object();
+
+            // Act
+            var header = builder.Default(defaultValue).Build();
+
+            // Assert
+            Assert.NotNull(header);
+            Assert.Equal(defaultValue, header.Default);
+        }
+    }
+}

test/Swagger.ObjectModel.Tests/UtilitiesTest.cs

@@ -0,0 +1,80 @@
+using Should;
+using Xunit;
+
+namespace Swagger.ObjectModel.Tests
+{
+    public class UtilitiesTest
+    {
+        [Fact]
+        public void ToCamelCase_EmptyOrNull_ShouldReturnItself()
+        {
+            // Arrange
+            string emptyString = string.Empty;
+            string nullString = null;
+            string whiteSpaceString = "";
+
+            // Act
+            var actual_empty = Utilities.ToCamelCase(emptyString);
+            var actual_null = Utilities.ToCamelCase(nullString);
+            var actual_whitespace = Utilities.ToCamelCase(whiteSpaceString);
+
+            // Assert
+            actual_empty.ShouldEqual(emptyString);
+            actual_null.ShouldEqual(actual_null);
+            actual_whitespace.ShouldEqual(whiteSpaceString);            
+        }
+
+        [Fact]
+        public void ToCamelCase_StartWithDigit_ShouldReturnStartWith_()
+        {
+            // Arrange
+            string val = "123";
+
+            // Act
+            var actual = Utilities.ToCamelCase(val);
+
+            // Assert
+            actual.ShouldEqual("_123");
+        }
+
+        [Fact]
+        public void ToCamelCase_StartWithUpperLetter_ShouldReturnStartWithLowerLetter()
+        {
+            // Arrange
+            string val = "Abc";
+
+            // Act
+            var actual = Utilities.ToCamelCase(val);
+
+            // Assert
+            actual.ShouldEqual("abc");
+        }
+
+        [Fact]
+        public void ToCamelCase__ShouldReturnCamelString()
+        {
+            // Arrange
+            string val = "AbC123dEf";
+
+            // Act
+            var actual = Utilities.ToCamelCase(val);
+
+            // Assert
+            actual.ShouldEqual("abC123DEf");
+        }
+
+
+        [Fact]
+        public void ToCamelCase_WithSpecialSymbol__ShouldReturnCamelString()
+        {
+            // Arrange
+            string val = string.Format("{0}/{1}","get", "values");
+
+            // Act
+            var actual = Utilities.ToCamelCase(val);
+
+            // Assert
+            actual.ShouldEqual("getValues");
+        }
+    }
+}