Create integration test project with TUnit framework and basic end-to-end tests

Co-authored-by: samtrion <[email protected]>

Author: Copilot

CodeBuilder.slnx

@@ -20,5 +20,6 @@
   </Folder>
   <Folder Name="/tests/">
     <Project Path="tests/NetEvolve.CodeBuilder.Tests.Unit/NetEvolve.CodeBuilder.Tests.Unit.csproj" />
+    <Project Path="tests/NetEvolve.CodeBuilder.Tests.Integration/NetEvolve.CodeBuilder.Tests.Integration.csproj" />
   </Folder>
 </Solution>

Directory.Packages.props

@@ -18,5 +18,6 @@
     <PackageVersion Include="NetEvolve.Extensions.TUnit" Version="2.7.0" />
     <PackageVersion Include="System.Memory" Version="4.6.3" />
     <PackageVersion Include="TUnit" Version="0.57.1" />
+    <PackageVersion Include="Verify.TUnit" Version="30.7.3" />
   </ItemGroup>
 </Project>

GitVersion.yml.backup

@@ -0,0 +1,6 @@
+{
+  "major-version-bump-message": "breaking:",
+  "minor-version-bump-message": "feat:",
+  "patch-version-bump-message": "fix:",
+  "no-bump-message": ".*"
+}

src/NetEvolve.CodeBuilder/NetEvolve.CodeBuilder.csproj.backup

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>$(_ProjectTargetFrameworks)</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$([MSBuild]::GetTargetFrameworkIdentifier($(TargetFramework)))' == '.NETStandard' ">
+    <PackageReference Include="System.Memory" />
+  </ItemGroup>
+</Project>

tests/NetEvolve.CodeBuilder.Tests.Integration/CSharpCodeBuilderIntegrationTests.ComplexGeneration.cs

@@ -0,0 +1,122 @@
+namespace NetEvolve.CodeBuilder.Tests.Integration;
+
+using System;
+using System.Globalization;
+
+public partial class CSharpCodeBuilderIntegrationTests
+{
+    [Test]
+    public async Task GenerateCompleteClass_Should_ProduceCorrectOutput()
+    {
+        var builder = new CSharpCodeBuilder();
+
+        // Build a complete class with using statements, namespace, and methods
+        builder
+            .AppendLine("using System;")
+            .AppendLine("using System.Collections.Generic;")
+            .AppendLine()
+            .AppendLine("namespace MyApplication.Models")
+            .Append("{")
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Represents a customer entity.")
+            .AppendLine("/// </summary>")
+            .AppendLine("public class Customer")
+            .Append("{")
+            .AppendLine("private readonly string _id;")
+            .AppendLine()
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Initializes a new instance of the Customer class.")
+            .AppendLine("/// </summary>")
+            .AppendLine("/// <param name=\"id\">The customer identifier.</param>")
+            .AppendLine("public Customer(string id)")
+            .Append("{")
+            .AppendLine("_id = id ?? throw new ArgumentNullException(nameof(id));")
+            .Append("}")
+            .AppendLine()
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Gets the customer identifier.")
+            .AppendLine("/// </summary>")
+            .AppendLine("public string Id => _id;")
+            .AppendLine()
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Gets or sets the customer name.")
+            .AppendLine("/// </summary>")
+            .AppendLine("public string? Name { get; set; }")
+            .AppendLine()
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Gets or sets the customer email address.")
+            .AppendLine("/// </summary>")
+            .AppendLine("public string? Email { get; set; }")
+            .Append("}")
+            .Append("}");
+
+        var result = builder.ToString();
+
+        // Basic verification - check that the output contains expected elements
+        _ = await Assert.That(result).Contains("using System;");
+        _ = await Assert.That(result).Contains("namespace MyApplication.Models");
+        _ = await Assert.That(result).Contains("public class Customer");
+        _ = await Assert.That(result).Contains("public Customer(string id)");
+        _ = await Assert.That(result).Contains("public string Id => _id;");
+        _ = await Assert.That(result).Contains("public string? Name { get; set; }");
+        _ = await Assert.That(result).Contains("public string? Email { get; set; }");
+
+        // Ensure proper indentation is applied
+        _ = await Assert.That(result).Contains("    public class Customer");
+        _ = await Assert.That(result).Contains("        private readonly string _id;");
+    }
+
+    [Test]
+    public async Task GenerateInterface_WithMultipleMethods_Should_ProduceCorrectOutput()
+    {
+        var builder = new CSharpCodeBuilder();
+
+        builder
+            .AppendLine("using System;")
+            .AppendLine("using System.Threading.Tasks;")
+            .AppendLine()
+            .AppendLine("namespace MyApplication.Services")
+            .Append("{")
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Defines the contract for customer service operations.")
+            .AppendLine("/// </summary>")
+            .AppendLine("public interface ICustomerService")
+            .Append("{")
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Gets a customer by their identifier.")
+            .AppendLine("/// </summary>")
+            .AppendLine("/// <param name=\"id\">The customer identifier.</param>")
+            .AppendLine("/// <returns>The customer if found; otherwise, null.</returns>")
+            .AppendLine("Task<Customer?> GetCustomerAsync(string id);")
+            .AppendLine()
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Creates a new customer.")
+            .AppendLine("/// </summary>")
+            .AppendLine("/// <param name=\"customer\">The customer to create.</param>")
+            .AppendLine("/// <returns>A task representing the asynchronous operation.</returns>")
+            .AppendLine("Task CreateCustomerAsync(Customer customer);")
+            .AppendLine()
+            .AppendLine("/// <summary>")
+            .AppendLine("/// Updates an existing customer.")
+            .AppendLine("/// </summary>")
+            .AppendLine("/// <param name=\"customer\">The customer to update.</param>")
+            .AppendLine("/// <returns>A task representing the asynchronous operation.</returns>")
+            .AppendLine("Task UpdateCustomerAsync(Customer customer);")
+            .Append("}")
+            .Append("}");
+
+        var result = builder.ToString();
+
+        // Basic verification - check that the output contains expected elements
+        _ = await Assert.That(result).Contains("using System.Threading.Tasks;");
+        _ = await Assert.That(result).Contains("namespace MyApplication.Services");
+        _ = await Assert.That(result).Contains("public interface ICustomerService");
+        _ = await Assert.That(result).Contains("Task<Customer?> GetCustomerAsync(string id);");
+        _ = await Assert.That(result).Contains("Task CreateCustomerAsync(Customer customer);");
+        _ = await Assert.That(result).Contains("Task UpdateCustomerAsync(Customer customer);");
+
+        // Ensure proper indentation is applied
+        _ = await Assert.That(result).Contains("    public interface ICustomerService");
+        _ = await Assert.That(result).Contains("        Task<Customer?> GetCustomerAsync(string id);");
+    }
+}

tests/NetEvolve.CodeBuilder.Tests.Integration/CSharpCodeBuilderIntegrationTests.ConditionalGeneration.cs

@@ -0,0 +1,181 @@
+namespace NetEvolve.CodeBuilder.Tests.Integration;
+
+using System;
+using System.Globalization;
+using System.Linq;
+
+public partial class CSharpCodeBuilderIntegrationTests
+{
+    [Test]
+    public async Task GenerateMethodWithConditionalContent_Should_ProduceCorrectOutput()
+    {
+        var builder = new CSharpCodeBuilder();
+
+        var includeLogging = true;
+        var includeValidation = false;
+        var isAsync = true;
+
+        builder.AppendLine("public class ServiceClass").Append("{");
+
+        if (isAsync)
+        {
+            builder.Append("public async Task");
+        }
+        else
+        {
+            builder.Append("public void");
+        }
+
+        builder
+            .Append(" ProcessDataAsync(string input)")
+            .Append("{")
+            .AppendLineIf(includeValidation, "if (string.IsNullOrEmpty(input))")
+            .AppendLineIf(includeValidation, "{")
+            .AppendLineIf(
+                includeValidation,
+                "    throw new ArgumentException(\"Input cannot be null or empty\", nameof(input));"
+            )
+            .AppendLineIf(includeValidation, "}")
+            .AppendLineIf(includeValidation, "")
+            .AppendLineIf(includeLogging, "Console.WriteLine($\"Processing input: {input}\");")
+            .AppendLine("var result = input.ToUpperInvariant();")
+            .AppendLineIf(includeLogging, "Console.WriteLine($\"Processing complete: {result}\");")
+            .AppendLineIf(isAsync, "await Task.CompletedTask;")
+            .AppendLine("return result;")
+            .Append("}")
+            .Append("}");
+
+        var result = builder.ToString();
+
+        // Verify conditional content was applied correctly
+        _ = await Assert.That(result).Contains("public async Task ProcessDataAsync(string input)"); // async version
+        _ = await Assert.That(result).Contains("Console.WriteLine($\"Processing input: {input}\");"); // logging included
+        _ = await Assert.That(result).Contains("await Task.CompletedTask;"); // async included
+        _ = await Assert.That(result).DoesNotContain("if (string.IsNullOrEmpty(input))"); // validation excluded
+        _ = await Assert.That(result).Contains("input.ToUpperInvariant()"); // proper string case conversion
+    }
+
+    [Test]
+    public async Task GenerateReflectionBasedCode_Should_ProduceCorrectOutput()
+    {
+        var builder = new CSharpCodeBuilder();
+
+        var properties = new[]
+        {
+            new
+            {
+                Name = "Id",
+                Type = "int",
+                HasGetter = true,
+                HasSetter = false,
+            },
+            new
+            {
+                Name = "Name",
+                Type = "string?",
+                HasGetter = true,
+                HasSetter = true,
+            },
+            new
+            {
+                Name = "Email",
+                Type = "string?",
+                HasGetter = true,
+                HasSetter = true,
+            },
+            new
+            {
+                Name = "CreatedAt",
+                Type = "DateTime",
+                HasGetter = true,
+                HasSetter = false,
+            },
+        };
+
+        builder.AppendLine("using System;").AppendLine().AppendLine("public class GeneratedEntity").Append("{");
+
+        // Generate backing fields for properties without setters
+        foreach (var prop in properties.Where(p => !p.HasSetter))
+        {
+            builder
+                .AppendFormat(
+                    CultureInfo.InvariantCulture,
+                    "private readonly {0} _{1};",
+                    prop.Type,
+                    prop.Name.ToUpperInvariant()
+                )
+                .AppendLine();
+        }
+
+        if (properties.Any(p => !p.HasSetter))
+        {
+            builder.AppendLine();
+        }
+
+        // Generate constructor
+        var readOnlyProps = properties.Where(p => !p.HasSetter).ToArray();
+        if (readOnlyProps.Length > 0)
+        {
+            builder.Append("public GeneratedEntity(");
+            for (int i = 0; i < readOnlyProps.Length; i++)
+            {
+                if (i > 0)
+                    builder.Append(", ");
+                builder.AppendFormat(
+                    CultureInfo.InvariantCulture,
+                    "{0} {1}",
+                    readOnlyProps[i].Type,
+                    readOnlyProps[i].Name.ToUpperInvariant()
+                );
+            }
+            builder.AppendLine(")").Append("{");
+
+            foreach (var prop in readOnlyProps)
+            {
+                builder
+                    .AppendFormat(
+                        CultureInfo.InvariantCulture,
+                        "_{0} = {1};",
+                        prop.Name.ToUpperInvariant(),
+                        prop.Name.ToUpperInvariant()
+                    )
+                    .AppendLine();
+            }
+
+            builder.Append("}").AppendLine();
+        }
+
+        // Generate properties
+        foreach (var prop in properties)
+        {
+            builder.AppendFormat(CultureInfo.InvariantCulture, "public {0} {1}", prop.Type, prop.Name);
+
+            if (prop.HasGetter && prop.HasSetter)
+            {
+                builder.AppendLine(" { get; set; }");
+            }
+            else if (prop.HasGetter && !prop.HasSetter)
+            {
+                builder
+                    .AppendFormat(CultureInfo.InvariantCulture, " => _{0};", prop.Name.ToUpperInvariant())
+                    .AppendLine();
+            }
+
+            builder.AppendLine();
+        }
+
+        builder.Append("}");
+
+        var result = builder.ToString();
+
+        // Basic verification for reflection-based code generation
+        _ = await Assert.That(result).Contains("public class GeneratedEntity");
+        _ = await Assert.That(result).Contains("private readonly int _ID;");
+        _ = await Assert.That(result).Contains("private readonly DateTime _CREATEDAT;");
+        _ = await Assert.That(result).Contains("public GeneratedEntity(int ID, DateTime CREATEDAT)");
+        _ = await Assert.That(result).Contains("public int Id => _ID;");
+        _ = await Assert.That(result).Contains("public string? Name { get; set; }");
+        _ = await Assert.That(result).Contains("public string? Email { get; set; }");
+        _ = await Assert.That(result).Contains("public DateTime CreatedAt => _CREATEDAT;");
+    }
+}