From 30bb35853b02c75a9ae549f69b05bada30d091fc Mon Sep 17 00:00:00 2001 From: Alexandru Macocian Date: Tue, 22 Mar 2022 12:46:52 +0100 Subject: [PATCH] Cover classes with unit tests --- Sybil.UnitTests/AccessorBuilderTests.cs | 176 +++++++++++ .../BaseConstructorBuilderTests.cs | 67 +++++ Sybil.UnitTests/ClassBuilderTests.cs | 145 +++++++++ Sybil.UnitTests/ConstructorBuilderTests.cs | 223 ++++++++++++++ Sybil.UnitTests/FieldBuilderTests.cs | 109 +++++++ Sybil.UnitTests/MethodBuilderTests.cs | 278 ++++++++++++++++++ Sybil.UnitTests/NamespaceBuilderTests.cs | 86 ++++++ Sybil.UnitTests/PropertyBuilderTests.cs | 120 ++++++++ Sybil/AssemblyInfo.cs | 3 + Sybil/BaseConstructorBuilder.cs | 2 +- Sybil/ClassBuilder.cs | 2 - Sybil/ConstructorBuilder.cs | 2 + Sybil/NamespaceBuilder.cs | 7 +- Sybil/PropertyBuilder.cs | 2 + 14 files changed, 1214 insertions(+), 8 deletions(-) create mode 100644 Sybil.UnitTests/AccessorBuilderTests.cs create mode 100644 Sybil.UnitTests/BaseConstructorBuilderTests.cs create mode 100644 Sybil.UnitTests/ClassBuilderTests.cs create mode 100644 Sybil.UnitTests/ConstructorBuilderTests.cs create mode 100644 Sybil.UnitTests/FieldBuilderTests.cs create mode 100644 Sybil.UnitTests/MethodBuilderTests.cs create mode 100644 Sybil.UnitTests/NamespaceBuilderTests.cs create mode 100644 Sybil.UnitTests/PropertyBuilderTests.cs create mode 100644 Sybil/AssemblyInfo.cs diff --git a/Sybil.UnitTests/AccessorBuilderTests.cs b/Sybil.UnitTests/AccessorBuilderTests.cs new file mode 100644 index 0000000..fdee58e --- /dev/null +++ b/Sybil.UnitTests/AccessorBuilderTests.cs @@ -0,0 +1,176 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class AccessorBuilderTests + { + private const string PublicGet = "public get;"; + private const string PublicStaticGet = "public static get;"; + private const string Set = "set;"; + private const string GetExpressionField = "get => this.field ;"; + private const string GetBodyField = +@"get +{ + return this.field; +}"; + + private readonly AccessorBuilder builder; + + public AccessorBuilderTests() + { + this.builder = new AccessorBuilder(Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetAccessorDeclaration); + } + + [TestMethod] + public void WithModifier_ModifierNull_ThrowsNullArgumentException() + { + var action = () => + { + this.builder.WithModifier(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifier("public"); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithModifiers_ModifiersNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifiers(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifiers_ModifiersValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifiers("public static"); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithBody_BodyNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithBody(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithBody_BodyValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithBody("return this.field;"); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithArrowExpression_ExpressionNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithArrowExpression(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithArrowExpression_ExpressionValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithArrowExpression("this.field;"); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void Build_ReturnsAccessorDeclarationSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void WithModifier_ReturnsExpectedString() + { + var result = this.builder.WithModifier("public").Build().ToFullString(); + + result.Should().Be(PublicGet); + } + + [TestMethod] + public void WithModifiers_ReturnsExpectedString() + { + var result = this.builder.WithModifiers("public static").Build().ToFullString(); + + result.Should().Be(PublicStaticGet); + } + + [TestMethod] + public void SetAccessor_ReturnsExpectedString() + { + var result = new AccessorBuilder(Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetAccessorDeclaration).Build().ToFullString(); + + result.Should().Be(Set); + } + + [TestMethod] + public void WithBody_ReturnsExpectedString() + { + var result = this.builder.WithBody("return this.field;").Build().ToFullString(); + + result.Should().Be(GetBodyField); + } + + [TestMethod] + public void WithArrowExpression_ReturnsExpectedString() + { + var result = this.builder.WithArrowExpression("this.field;").Build().ToFullString(); + + result.Should().Be(GetExpressionField); + } + + [TestMethod] + public void WithBody_OverridesWithArrowExpression_ReturnsExpectedString() + { + var result = this.builder + .WithArrowExpression("this field;") + .WithBody("return this.field;") + .Build() + .ToFullString(); + + result.Should().Be(GetBodyField); + } + + [TestMethod] + public void WithArrowExpression_OverridesWithBody_ReturnsExpectedString() + { + var result = this.builder + .WithBody("return this.field;") + .WithArrowExpression("this.field;") + .Build() + .ToFullString(); + + result.Should().Be(GetExpressionField); + } + } +} \ No newline at end of file diff --git a/Sybil.UnitTests/BaseConstructorBuilderTests.cs b/Sybil.UnitTests/BaseConstructorBuilderTests.cs new file mode 100644 index 0000000..243a0a6 --- /dev/null +++ b/Sybil.UnitTests/BaseConstructorBuilderTests.cs @@ -0,0 +1,67 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class BaseConstructorBuilderTests + { + private const string EmptyBase = ": base()"; + private const string TestBase = ": base(test)"; + + private readonly BaseConstructorBuilder builder; + + public BaseConstructorBuilderTests() + { + this.builder = new BaseConstructorBuilder(); + } + + [TestMethod] + public void WithArgument_NullArgument_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithArgument(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithArgument_ValidArgument_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithArgument("test"); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void Build_ReturnsConstructorInitializerSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void EmptyBaseConstructor_ReturnsExpectedString() + { + var result = this.builder.Build().ToFullString(); + + result.Should().Be(EmptyBase); + } + + [TestMethod] + public void WithArgument_ShouldReturnExpectedString() + { + var result = this.builder + .WithArgument("test") + .Build() + .ToFullString(); + + result.Should().Be(TestBase); + } + } +} \ No newline at end of file diff --git a/Sybil.UnitTests/ClassBuilderTests.cs b/Sybil.UnitTests/ClassBuilderTests.cs new file mode 100644 index 0000000..347de2e --- /dev/null +++ b/Sybil.UnitTests/ClassBuilderTests.cs @@ -0,0 +1,145 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class ClassBuilderTests + { + private const string Name = "Test"; + private const string PublicClass = +@"public class Test +{ +}"; + private const string PublicStaticClass = +@"public static class Test +{ +}"; + + private readonly ClassBuilder builder; + + public ClassBuilderTests() + { + this.builder = new ClassBuilder(Name); + } + + [TestMethod] + public void Constructor_NullName_ThrowArgumentNullException() + { + var action = () => + { + _ = new ClassBuilder(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifier(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifier("public"); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithModifiers_ModifiersNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifiers(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifiers_ModifiersValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifiers("public static"); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithField_NullFieldBuilder_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithField(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithProperty_NullPropertyBuilder_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithProperty(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithMethod_NullMethodBuilder_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithMethod(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithConstructor_NullConstructorBuilder_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithConstructor(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void Build_ReturnsClassDeclarationSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void WithModifier_ReturnsExpectedString() + { + var result = this.builder.WithModifier("public").Build().ToFullString(); + + result.Should().Be(PublicClass); + } + + [TestMethod] + public void WithModifiers_ReturnsExpectedString() + { + var result = this.builder.WithModifiers("public static").Build().ToFullString(); + + result.Should().Be(PublicStaticClass); + } + } +} \ No newline at end of file diff --git a/Sybil.UnitTests/ConstructorBuilderTests.cs b/Sybil.UnitTests/ConstructorBuilderTests.cs new file mode 100644 index 0000000..a3229b5 --- /dev/null +++ b/Sybil.UnitTests/ConstructorBuilderTests.cs @@ -0,0 +1,223 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class ConstructorBuilderTests + { + private const string Public = "public"; + private const string PublicSealed = "public sealed"; + private const string Null = "null"; + private const string ParameterType = "string"; + private const string ParameterName = "someString"; + private const string Name = "Test"; + private const string Body = "this.someString = someString;"; + private const string PublicEmptyConstructor = +@"public Test() +{ +}"; + private const string PublicSealedEmptyConstructor = +@"public sealed Test() +{ +}"; + private const string ConstructorWithParameter = +@"Test(string someString) +{ +}"; + private const string ConstructorWithParameterWithDefault = +@"Test(string someString = null) +{ +}"; + private const string ConstructorWithBody = +@"Test() +{ + this.someString = someString; +}"; + private const string ConstructorWithModifiersBodyAndParameter = +@"public public sealed Test(string someString = null) +{ + this.someString = someString; +}"; + + private readonly ConstructorBuilder builder; + + public ConstructorBuilderTests() + { + this.builder = new ConstructorBuilder(Name); + } + + [TestMethod] + public void Constructor_NullName_ThrowArgumentNullException() + { + var action = () => + { + _ = new ConstructorBuilder(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifier(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifier(Public); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithModifiers_ModifiersNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifiers(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifiers_ModifiersValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifiers(PublicSealed); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithBase_NullBase_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithBase(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithParameter_ParameterNameNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithParameter(ParameterType, null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithParameter_ParameterTypeNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithParameter(null, ParameterName); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithParameter_ParameterValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithParameter(ParameterType, ParameterName); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithBody_BodyNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithBody(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithBody_BodyValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithBody(Body); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void Build_ReturnsConstructorDeclarationSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void WithModifier_ReturnsExpectedString() + { + var result = this.builder.WithModifier(Public).Build().ToFullString(); + + result.Should().Be(PublicEmptyConstructor); + } + + [TestMethod] + public void WithModifiers_ReturnsExpectedString() + { + var result = this.builder.WithModifiers(PublicSealed).Build().ToFullString(); + + result.Should().Be(PublicSealedEmptyConstructor); + } + + [TestMethod] + public void WithParameter_ReturnsExpectedString() + { + var result = this.builder.WithParameter(ParameterType, ParameterName).Build().ToFullString(); + + result.Should().Be(ConstructorWithParameter); + } + + [TestMethod] + public void WithParameter_WithDefault_ReturnsExpectedString() + { + var result = this.builder.WithParameter(ParameterType, ParameterName, Null).Build().ToFullString(); + + result.Should().Be(ConstructorWithParameterWithDefault); + } + + [TestMethod] + public void WithBody_ReturnsExpectedString() + { + var result = this.builder.WithBody(Body).Build().ToFullString(); + + result.Should().Be(ConstructorWithBody); + } + + [TestMethod] + public void WithBody_WithParameter_WithModifier_WithModifiers_ReturnsExpectedString() + { + var result = this.builder + .WithBody(Body) + .WithParameter(ParameterType, ParameterName, Null) + .WithModifier(Public) + .WithModifiers(PublicSealed) + .Build() + .ToFullString(); + + result.Should().Be(ConstructorWithModifiersBodyAndParameter); + } + } +} \ No newline at end of file diff --git a/Sybil.UnitTests/FieldBuilderTests.cs b/Sybil.UnitTests/FieldBuilderTests.cs new file mode 100644 index 0000000..478e938 --- /dev/null +++ b/Sybil.UnitTests/FieldBuilderTests.cs @@ -0,0 +1,109 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class FieldBuilderTests + { + private const string Public = "public"; + private const string PublicSealed = "public sealed"; + private const string FieldName = "someString"; + private const string FieldType = "string"; + private const string PublicField = "public string someString;"; + private const string PublicSealedField = "public sealed string someString;"; + + private readonly FieldBuilder builder; + + public FieldBuilderTests() + { + this.builder = new FieldBuilder(FieldType, FieldName); + } + + [TestMethod] + public void Constructor_NullFieldType_ThrowsArgumentNullException() + { + var action = () => + { + _ = new FieldBuilder(null, FieldName); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void Constructor_NullFieldName_ThrowsArgumentNullException() + { + var action = () => + { + _ = new FieldBuilder(FieldType, null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifier(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifier(Public); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithModifiers_ModifiersNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifiers(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifiers_ModifiersValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifiers(PublicSealed); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void Build_ReturnsFieldDeclarationSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void WithModifier_ReturnsExpectedString() + { + var result = this.builder.WithModifier(Public).Build().ToFullString(); + + result.Should().Be(PublicField); + } + + [TestMethod] + public void WithModifiers_ReturnsExpectedString() + { + var result = this.builder.WithModifiers(PublicSealed).Build().ToFullString(); + + result.Should().Be(PublicSealedField); + } + } +} \ No newline at end of file diff --git a/Sybil.UnitTests/MethodBuilderTests.cs b/Sybil.UnitTests/MethodBuilderTests.cs new file mode 100644 index 0000000..9f766fb --- /dev/null +++ b/Sybil.UnitTests/MethodBuilderTests.cs @@ -0,0 +1,278 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class MethodBuilderTests + { + private const string Public = "public"; + private const string PublicSealed = "public sealed"; + private const string Null = "null"; + private const string ParameterType = "string"; + private const string ParameterName = "someString"; + private const string Name = "Test"; + private const string ReturnType = "string"; + private const string Expression = "this.someString;"; + private const string Body = "this.someString = someString;"; + private const string PublicEmptyMethod = "public string Test() => throw new NotImplementedException() ;"; + private const string PublicSealedEmptyMethod = "public sealed string Test() => throw new NotImplementedException() ;"; + private const string EmptyMethodWithParameter = "string Test(string someString) => throw new NotImplementedException() ;"; + private const string EmptyMethodWithParameterWithDefault = "string Test(string someString = null) => throw new NotImplementedException() ;"; + private const string MethodWithArrowExpression = "string Test() => this.someString ;"; + private const string PublicSealedMethodWithParameterAndExpression = "public sealed string Test(string someString = null) => this.someString ;"; + private const string MethodWithBody = +@"string Test() +{ + this.someString = someString; +}"; + private const string PublicSealedMethodWithBodyAndParameter = +@"public sealed string Test(string someString = null) +{ + this.someString = someString; +}"; + + private readonly MethodBuilder builder; + + public MethodBuilderTests() + { + this.builder = new MethodBuilder(ReturnType, Name); + } + + [TestMethod] + public void Constructor_NullName_ThrowArgumentNullException() + { + var action = () => + { + _ = new MethodBuilder(ReturnType, null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void Constructor_NullReturnType_ThrowArgumentNullException() + { + var action = () => + { + _ = new MethodBuilder(null, Name); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifier(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifier(Public); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithModifiers_ModifiersNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifiers(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifiers_ModifiersValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifiers(PublicSealed); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithParameter_ParameterNameNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithParameter(ParameterType, null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithParameter_ParameterTypeNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithParameter(null, ParameterName); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithParameter_ParameterValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithParameter(ParameterType, ParameterName); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithBody_BodyNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithBody(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithBody_BodyValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithBody(Body); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithExpression_ExpressionNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithExpression(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithExpression_ExpressionValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithExpression(Expression); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void Build_ReturnsMethodDeclarationSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void WithModifier_ReturnsExpectedString() + { + var result = this.builder.WithModifier(Public).Build().ToFullString(); + + result.Should().Be(PublicEmptyMethod); + } + + [TestMethod] + public void WithModifiers_ReturnsExpectedString() + { + var result = this.builder.WithModifiers(PublicSealed).Build().ToFullString(); + + result.Should().Be(PublicSealedEmptyMethod); + } + + [TestMethod] + public void WithParameter_ReturnsExpectedString() + { + var result = this.builder.WithParameter(ParameterType, ParameterName).Build().ToFullString(); + + result.Should().Be(EmptyMethodWithParameter); + } + + [TestMethod] + public void WithParameter_WithDefault_ReturnsExpectedString() + { + var result = this.builder.WithParameter(ParameterType, ParameterName, Null).Build().ToFullString(); + + result.Should().Be(EmptyMethodWithParameterWithDefault); + } + + [TestMethod] + public void WithBody_ReturnsExpectedString() + { + var result = this.builder.WithBody(Body).Build().ToFullString(); + + result.Should().Be(MethodWithBody); + } + + [TestMethod] + public void WithArrowExpression_ReturnsExpectedString() + { + var result = this.builder.WithExpression(Expression).Build().ToFullString(); + + result.Should().Be(MethodWithArrowExpression); + } + + [TestMethod] + public void WithBody_OverwritesWithExpression_ReturnsExpectedString() + { + var result = this.builder + .WithExpression(Expression) + .WithBody(Body) + .Build() + .ToFullString(); + + result.Should().Be(MethodWithBody); + } + + [TestMethod] + public void WithExpression_OverwritesWithBody_ReturnsExpectedString() + { + var result = this.builder + .WithBody(Body) + .WithExpression(Expression) + .Build() + .ToFullString(); + + result.Should().Be(MethodWithArrowExpression); + } + + [TestMethod] + public void WithBody_WithModifiers_WithParameter_ReturnsExpectedString() + { + var result = this.builder + .WithBody(Body) + .WithModifiers(PublicSealed) + .WithParameter(ParameterType, ParameterName, Null) + .Build() + .ToFullString(); + + result.Should().Be(PublicSealedMethodWithBodyAndParameter); + } + + [TestMethod] + public void WithExpression_WithModifiers_WithParameter_ReturnsExpectedString() + { + var result = this.builder + .WithExpression(Expression) + .WithModifiers(PublicSealed) + .WithParameter(ParameterType, ParameterName, Null) + .Build() + .ToFullString(); + + result.Should().Be(PublicSealedMethodWithParameterAndExpression); + } + } +} \ No newline at end of file diff --git a/Sybil.UnitTests/NamespaceBuilderTests.cs b/Sybil.UnitTests/NamespaceBuilderTests.cs new file mode 100644 index 0000000..ae532d9 --- /dev/null +++ b/Sybil.UnitTests/NamespaceBuilderTests.cs @@ -0,0 +1,86 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class NamespaceBuilderTests + { + private const string Using = "System"; + private const string Namespace = "Test"; + private const string NamespaceWithUsing = +@"namespace Test +{ + using System; +}"; + + private readonly NamespaceBuilder builder; + + public NamespaceBuilderTests() + { + this.builder = new NamespaceBuilder(Namespace); + } + + [TestMethod] + public void Constructor_NullNamespace_ThrowsArgumentNullException() + { + var action = () => + { + _ = new NamespaceBuilder(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithUsing_NullUsing_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithUsing(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithUsing_ValidUsing_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithUsing(Using); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithClass_NullClassBuilder_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithClass(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void Build_ReturnsNamespaceDeclarationSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void WithUsing_ReturnsExpectedString() + { + var result = this.builder + .WithUsing(Using) + .Build() + .ToFullString(); + + result.Should().Be(NamespaceWithUsing); + } + } +} \ No newline at end of file diff --git a/Sybil.UnitTests/PropertyBuilderTests.cs b/Sybil.UnitTests/PropertyBuilderTests.cs new file mode 100644 index 0000000..8609a9b --- /dev/null +++ b/Sybil.UnitTests/PropertyBuilderTests.cs @@ -0,0 +1,120 @@ +using FluentAssertions; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace Sybil.Tests +{ + [TestClass] + public class PropertyBuilderTests + { + private const string Public = "public"; + private const string PublicStatic = "public static"; + private const string TypeName = "string"; + private const string PropertyName = "SomeString"; + private const string PublicProperty = "public string SomeString { }"; + private const string PublicStaticProperty = "public static string SomeString { }"; + + private readonly PropertyBuilder builder; + + public PropertyBuilderTests() + { + this.builder = new PropertyBuilder(TypeName, PropertyName); + } + + [TestMethod] + public void Constructor_NullPropertyType_ThrowsArgumentNullException() + { + var action = () => + { + _ = new PropertyBuilder(null, PropertyName); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void Constructor_NullPropertyName_ThrowsArgumentNullException() + { + var action = () => + { + _ = new PropertyBuilder(TypeName, null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifier(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifier_ModifierValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifier(Public); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithModifiers_ModifiersNull_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithModifiers(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void WithModifiers_ModifiersValid_ReturnsBuilder() + { + var returnedBuilder = this.builder.WithModifiers(PublicStatic); + + returnedBuilder.Should().NotBeNull().And.Subject.Should().Be(this.builder); + } + + [TestMethod] + public void WithAccessor_NullAccessor_ThrowsArgumentNullException() + { + var action = () => + { + this.builder.WithAccessor(null); + }; + + action.Should().Throw(); + } + + [TestMethod] + public void Build_ReturnsPropertyDeclarationSyntax() + { + var syntax = this.builder.Build(); + + syntax.Should().NotBeNull().And.Subject.Should().BeOfType(); + } + + [TestMethod] + public void WithModifier_ReturnsExpectedString() + { + var result = this.builder.WithModifier(Public).Build().ToFullString(); + + result.Should().Be(PublicProperty); + } + + [TestMethod] + public void WithModifiers_ReturnsExpectedString() + { + var result = this.builder.WithModifiers(PublicStatic).Build().ToFullString(); + + result.Should().Be(PublicStaticProperty); + } + } +} \ No newline at end of file diff --git a/Sybil/AssemblyInfo.cs b/Sybil/AssemblyInfo.cs new file mode 100644 index 0000000..243472d --- /dev/null +++ b/Sybil/AssemblyInfo.cs @@ -0,0 +1,3 @@ +using System.Runtime.CompilerServices; + +[assembly:InternalsVisibleTo("Sybil.UnitTests")] diff --git a/Sybil/BaseConstructorBuilder.cs b/Sybil/BaseConstructorBuilder.cs index 5841d11..84b884d 100644 --- a/Sybil/BaseConstructorBuilder.cs +++ b/Sybil/BaseConstructorBuilder.cs @@ -25,7 +25,7 @@ namespace Sybil public ConstructorInitializerSyntax Build() { - return ConstructorInitializerSyntax.NormalizeWhitespace(); + return this.ConstructorInitializerSyntax.NormalizeWhitespace(); } } } diff --git a/Sybil/ClassBuilder.cs b/Sybil/ClassBuilder.cs index 0a64114..76ea2c0 100644 --- a/Sybil/ClassBuilder.cs +++ b/Sybil/ClassBuilder.cs @@ -9,7 +9,6 @@ namespace Sybil { public sealed class ClassBuilder : IBuilder { - private readonly string className; private ClassDeclarationSyntax ClassDeclaration { get; set; } private readonly List Constructors = new List(); @@ -22,7 +21,6 @@ namespace Sybil { _ = string.IsNullOrWhiteSpace(className) ? throw new ArgumentNullException(nameof(className)) : className; - this.className = className; this.ClassDeclaration = SyntaxFactory.ClassDeclaration(className); } diff --git a/Sybil/ConstructorBuilder.cs b/Sybil/ConstructorBuilder.cs index 8e7ce09..a2e988c 100644 --- a/Sybil/ConstructorBuilder.cs +++ b/Sybil/ConstructorBuilder.cs @@ -23,6 +23,8 @@ namespace Sybil public ConstructorBuilder WithBase(BaseConstructorBuilder baseConstructorBuilder) { + _ = baseConstructorBuilder ?? throw new ArgumentNullException(nameof(baseConstructorBuilder)); + this.baseConstructorBuilder = baseConstructorBuilder; return this; } diff --git a/Sybil/NamespaceBuilder.cs b/Sybil/NamespaceBuilder.cs index 13c4a31..422d0f3 100644 --- a/Sybil/NamespaceBuilder.cs +++ b/Sybil/NamespaceBuilder.cs @@ -31,6 +31,8 @@ namespace Sybil public NamespaceBuilder WithClass(ClassBuilder classBuilder) { + _ = classBuilder ?? throw new ArgumentNullException(nameof(classBuilder)); + this.classBuilders.Add(classBuilder); return this; @@ -42,10 +44,5 @@ namespace Sybil .AddMembers(this.classBuilders.Select(c => c.Build()).ToArray()) .NormalizeWhitespace(); } - - public static NamespaceBuilder Create(string @namespace) - { - return new NamespaceBuilder(@namespace); - } } } diff --git a/Sybil/PropertyBuilder.cs b/Sybil/PropertyBuilder.cs index 29e4f1d..95a17bd 100644 --- a/Sybil/PropertyBuilder.cs +++ b/Sybil/PropertyBuilder.cs @@ -41,6 +41,8 @@ namespace Sybil } public PropertyBuilder WithAccessor(AccessorBuilder accessorBuilder) { + _ = accessorBuilder ?? throw new ArgumentNullException(nameof(accessorBuilder)); + this.accessors.Add(accessorBuilder); return this;