test: Added XUnit integration tests

src/NetEvolve.ProjectBuilders/ProjectFactory.cs

@@ -120,8 +120,8 @@
     /// <inheritdoc cref="IProjectFactory.AddEnvironmentVariable"/>
     public IProjectFactory AddEnvironmentVariable(string name, string? value)
     {
         Argument.ThrowIfNullOrWhiteSpace(name);
         Argument.ThrowIfNullOrWhiteSpace(value);
 
         if (!EnvironmentVariables.TryAdd(name, value))
         {
@@ -134,7 +134,7 @@
     /// <inheritdoc cref="IProjectFactory.AddEnvironmentVariables"/>
     public IProjectFactory AddEnvironmentVariables(params KeyValuePair<string, string?>[] variables)
     {
         Argument.ThrowIfNull(variables);
 
         foreach (var variable in variables)
         {
@@ -175,24 +175,7 @@
         // Create temporary directory for testing
         await _tempDirectory.CreateAsync(cancellationToken).ConfigureAwait(false);
 
-        if (_testPackageBuilder is not null)
-        {
-            var lookupPaths = ObjectBuilders
-                .OfType<ProjectBuilder>()
-                .Select(x => x.ItemGroup.Items)
-                .OfType<IReference>()
-                .SelectMany(x => x.LookUpPaths)
-                .Distinct()
-                .ToArray();
-
-            if (lookupPaths.Length > 0)
-            {
-                _testPackageBuilder.SetPackagePaths(lookupPaths);
-
-                // Prepare nuget packages for testings
-                await _testPackageBuilder.CreateAsync(cancellationToken).ConfigureAwait(false);
-            }
-        }
+        await PrepareNuGetPackagesAsync(cancellationToken).ConfigureAwait(false);
 
         await Parallel
             .ForEachAsync(
@@ -230,6 +213,30 @@
         return sarif;
     }
 
+    private async Task PrepareNuGetPackagesAsync(CancellationToken cancellationToken)
+    {
+        if (_testPackageBuilder is null)
+        {
+            return;
+        }
+
+        var lookupPaths = ObjectBuilders
+            .OfType<ProjectBuilder>()
+            .Select(x => x.ItemGroup.Items)
+            .OfType<IReference>()
+            .SelectMany(x => x.LookUpPaths)
+            .Distinct()
+            .ToArray();
+
+        if (lookupPaths.Length > 0)
+        {
+            _testPackageBuilder.SetPackagePaths(lookupPaths);
+
+            // Prepare nuget packages for testings
+            await _testPackageBuilder.CreateAsync(cancellationToken).ConfigureAwait(false);
+        }
+    }
+
     private async Task<CommandResult> ExecuteDotNetCommandAsync(
         IEnumerable<string> args,
         CancellationToken cancellationToken

tests/NetEvolve.ProjectBuilders.XUnit.Tests.Integration/Builders/GlobalJsonBuilderTests.cs

@@ -0,0 +1,44 @@
+namespace NetEvolve.ProjectBuilders.XUnit.Tests.Integration.Builders;
+
+using System.Threading.Tasks;
+using NetEvolve.ProjectBuilders;
+using NetEvolve.ProjectBuilders.Builders;
+using NetEvolve.ProjectBuilders.Models;
+
+public class GlobalJsonBuilderTests(TemporaryDirectoryFixture directory) : IClassFixture<TemporaryDirectoryFixture>
+{
+    [Theory]
+    [MemberData(nameof(GetTheoryData))]
+    public async Task CreateAsync_Theory_Expected(string runtimeVersion, bool allowPrerelease, RollForward rollForward)
+    {
+        var subdirectory = directory.CreateDirectory(
+            $"{nameof(CreateAsync_Theory_Expected)}{runtimeVersion}{allowPrerelease}{rollForward}"
+        );
+        await using var builder = new GlobalJsonBuilder(subdirectory, runtimeVersion);
+        await builder
+            .SetAllowPrerelease(allowPrerelease)
+            .SetRollForward(rollForward)
+            .CreateAsync(cancellationToken: TestContext.Current.CancellationToken);
+        _ = await VerifyFile(builder.FullPath)
+            .UseParameters(allowPrerelease, rollForward, runtimeVersion)
+            .HashParameters();
+    }
+
+    public static TheoryData<string, bool, RollForward> GetTheoryData()
+    {
+        var data = new TheoryData<string, bool, RollForward>();
+        var runtimeVersions = new[] { Constants.RuntimeSdkDefault, "10.0.100" };
+        var rollForwardOptions = Enum.GetValues<RollForward>();
+
+        foreach (var runtimeVersion in runtimeVersions)
+        {
+            foreach (var rollForward in rollForwardOptions)
+            {
+                data.Add(runtimeVersion, true, rollForward);
+                data.Add(runtimeVersion, false, rollForward);
+            }
+        }
+
+        return data;
+    }
+}

tests/NetEvolve.ProjectBuilders.XUnit.Tests.Integration/Builders/ProjectBuilderTests.cs

@@ -0,0 +1,160 @@
+namespace NetEvolve.ProjectBuilders.XUnit.Tests.Integration.Builders;
+
+using System.Linq;
+using System.Threading.Tasks;
+using NetEvolve.ProjectBuilders;
+using NetEvolve.ProjectBuilders.Builders;
+using NetEvolve.ProjectBuilders.Models;
+
+public class ProjectBuilderTests(TemporaryDirectoryFixture directory) : IClassFixture<TemporaryDirectoryFixture>
+{
+    [Theory]
+    [MemberData(nameof(GetTargetFrameworkValues))]
+    public async ValueTask CreateAsync_TargetFrameworkTheory_Expected(
+        string? sdk,
+        NullableOptions nullable,
+        TargetFramework targetFramework
+    )
+    {
+        var subdirectory = directory.CreateDirectory(
+            $"{nameof(CreateAsync_TargetFrameworkTheory_Expected)}{Guid.NewGuid()}"
+        );
+        await using var builder = new ProjectBuilder(subdirectory, Constants.CSharpProjectFileName);
+
+        await builder
+            .WithNullable(nullable)
+            .WithTargetFramework(targetFramework)
+            .SetProjectSdk(sdk)
+            .CreateAsync(TestContext.Current.CancellationToken);
+
+        _ = await VerifyFile(builder.FullPath, extension: "xml")
+            .UseParameters(nullable, targetFramework, sdk)
+            .HashParameters();
+    }
+
+    [Theory]
+    [MemberData(nameof(GetTargetFrameworkValues))]
+    public async ValueTask CreateAsync_TargetFrameworksTheory_Expected(
+        string? sdk,
+        NullableOptions nullable,
+        TargetFramework targetFramework
+    )
+    {
+        var subdirectory = directory.CreateDirectory(
+            $"{nameof(CreateAsync_TargetFrameworksTheory_Expected)}{Guid.NewGuid()}"
+        );
+        await using var builder = new ProjectBuilder(subdirectory, Constants.CSharpProjectFileName);
+
+        await builder
+            .WithNullable(nullable)
+            .WithTargetFrameworks(TargetFramework.NetStandard2_0, targetFramework)
+            .SetProjectSdk(sdk)
+            .CreateAsync(TestContext.Current.CancellationToken);
+
+        _ = await VerifyFile(builder.FullPath, extension: "xml")
+            .UseParameters(nullable, targetFramework, sdk)
+            .HashParameters();
+    }
+
+    public static TheoryData<string?, NullableOptions, TargetFramework> GetTargetFrameworkValues()
+    {
+        var data = new TheoryData<string?, NullableOptions, TargetFramework>();
+        var sdks = new string?[] { null, "Microsoft.NET.Sdk", "Microsoft.NET.Sdk.Web" };
+        var nullableOptions = Enum.GetValues<NullableOptions>();
+        var targetFrameworks = new TargetFramework[]
+        {
+            TargetFramework.NetStandard2_0,
+            TargetFramework.Net10Windows,
+            TargetFramework.NetFramework4_8_1,
+        };
+        foreach (
+            var c in from sdk in sdks
+            from nullable in nullableOptions
+            from targetFramework in targetFrameworks
+            select (sdk, nullable, targetFramework)
+        )
+        {
+            data.Add(c.sdk, c.nullable, c.targetFramework);
+        }
+
+        return data;
+    }
+
+    [Theory]
+    [MemberData(nameof(AddPackageReference_Newtonsoft_Expected_Data))]
+    public async ValueTask AddPackageReference_Newtonsoft_Expected(
+        string? version,
+        string? versionOverride,
+        bool generatePathProperty,
+        string? aliases,
+        ReferenceAssets? includeAssets,
+        ReferenceAssets? excludeAssets,
+        ReferenceAssets? privateAssets
+    )
+    {
+        var subdirectory = directory.CreateDirectory(
+            $"{nameof(AddPackageReference_Newtonsoft_Expected)}{Guid.NewGuid()}"
+        );
+        await using var builder = new ProjectBuilder(subdirectory, Constants.CSharpProjectFileName);
+        await builder
+            .AddPackageReference(
+                "Newtonsoft.Json",
+                version,
+                versionOverride,
+                generatePathProperty,
+                aliases,
+                includeAssets,
+                excludeAssets,
+                privateAssets
+            )
+            .CreateAsync(TestContext.Current.CancellationToken);
+
+        _ = await VerifyFile(builder.FullPath, extension: "xml")
+            .UseParameters(
+                version,
+                versionOverride,
+                generatePathProperty,
+                aliases,
+                includeAssets,
+                excludeAssets,
+                privateAssets
+            )
+            .HashParameters();
+    }
+
+    public static TheoryData<
+        string?,
+        string?,
+        bool,
+        string?,
+        ReferenceAssets?,
+        ReferenceAssets?,
+        ReferenceAssets?
+    > AddPackageReference_Newtonsoft_Expected_Data()
+    {
+        var data =
+            new TheoryData<string?, string?, bool, string?, ReferenceAssets?, ReferenceAssets?, ReferenceAssets?>();
+        var versions = new string?[] { "13.0.1", null };
+        var versionOverrides = new string?[] { "13.0.1", null };
+        var aliasesOptions = new string?[] { "NJson", "" };
+        ReferenceAssets?[] includeAssetsOptions = [ReferenceAssets.All, null];
+        ReferenceAssets?[] exlcudeAssetsOptions = [ReferenceAssets.None, ReferenceAssets.Runtime];
+        ReferenceAssets?[] privateAssetsOptions = [ReferenceAssets.Build | ReferenceAssets.ContentFiles, null];
+
+        foreach (
+            var c in from version in versions
+            from versionOverride in versionOverrides
+            from aliases in aliasesOptions
+            from includeAssets in includeAssetsOptions
+            from excludeAssets in exlcudeAssetsOptions
+            from privateAssets in privateAssetsOptions
+            select (version, versionOverride, aliases, includeAssets, excludeAssets, privateAssets)
+        )
+        {
+            data.Add(c.version, c.versionOverride, true, c.aliases, c.includeAssets, c.excludeAssets, c.privateAssets);
+            data.Add(c.version, c.versionOverride, false, c.aliases, c.includeAssets, c.excludeAssets, c.privateAssets);
+        }
+
+        return data;
+    }
+}

tests/NetEvolve.ProjectBuilders.XUnit.Tests.Integration/CSharpProjectTests.cs

@@ -0,0 +1,62 @@
+namespace NetEvolve.ProjectBuilders.XUnit.Tests.Integration;
+
+using System;
+using System.Threading.Tasks;
+using NetEvolve.ProjectBuilders;
+using NetEvolve.ProjectBuilders.Builders;
+
+public class CSharpProjectTests(TemporaryDirectoryFixture directory) : IClassFixture<TemporaryDirectoryFixture>
+{
+    [Theory]
+    [MemberData(nameof(AddCSharpFileData))]
+    public async Task BuildAsync_CSharp_Theory(bool expectedErrors, bool expectedWarnings, string content)
+    {
+        var projectDirectory = directory.CreateDirectory($"{nameof(BuildAsync_CSharp_Theory)}{Guid.NewGuid()}");
+        var nugetDirectory = directory.CreateDirectory($"{nameof(BuildAsync_CSharp_Theory)}{Guid.NewGuid()}");
+
+        await using var nugetFactory = new TestPackageBuilder(nugetDirectory);
+        await using var factory = ProjectFactory.Create(nugetFactory, projectDirectory);
+
+        var result = await factory
+            .AddCSharpProject(builder => builder.WithDefaults().AddCSharpFile("main.cs", content))
+            .AddGlobalJson(configure: projectBuilder => projectBuilder.WithDefaults())
+            .BuildAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.Equal(result.HasErrors(), expectedErrors);
+        Assert.Equal(result.HasWarnings(), expectedWarnings);
+    }
+
+    [Theory]
+    [MemberData(nameof(AddCSharpFileData))]
+    public async Task BuildAsync_CSharp_VerifyDirectory(bool expectedErrors, bool expectedWarnings, string content)
+    {
+        var projectDirectory = directory.CreateDirectory(
+            $"{nameof(BuildAsync_CSharp_VerifyDirectory)}{Guid.NewGuid()}"
+        );
+        var nugetDirectory = directory.CreateDirectory($"{nameof(BuildAsync_CSharp_VerifyDirectory)}{Guid.NewGuid()}");
+
+        await using var nugetFactory = new TestPackageBuilder(nugetDirectory);
+        await using var factory = ProjectFactory.Create(nugetFactory, projectDirectory);
+
+        _ = await factory
+            .AddCSharpProject(builder => builder.WithDefaults().AddCSharpFile("main.cs", content))
+            .AddGlobalJson(configure: projectBuilder => projectBuilder.WithDefaults())
+            .BuildAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        _ = await VerifyDirectory(projectDirectory.FullPath, include: ProjectHelpers.DirectoryFilter)
+            .UseParameters(expectedErrors, expectedWarnings, content)
+            .HashParameters();
+    }
+
+    public static TheoryData<bool, bool, string> AddCSharpFileData =>
+        new TheoryData<bool, bool, string>
+        {
+            { false, false, "class Program { static void Main() { System.Console.WriteLine(\"Hello, World!\"); } }" },
+            { true, false, "class Program { static void Main() { WriteLine(\"Hello, World!\"); } }" },
+            {
+                false,
+                true,
+                "class Program { static async void Main() { System.Console.WriteLine(\"Hello, World!\"); } }"
+            },
+        };
+}

tests/NetEvolve.ProjectBuilders.XUnit.Tests.Integration/NetEvolve.ProjectBuilders.XUnit.Tests.Integration.csproj

@@ -10,7 +10,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" VersionOverride="18.1.0" />
+    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" VersionOverride="18.0.6" />
     <PackageReference Include="NetEvolve.Extensions.XUnit.V3" />
     <PackageReference Include="Verify.ParametersHashing" />
     <PackageReference Include="Verify.XunitV3" />

tests/NetEvolve.ProjectBuilders.XUnit.Tests.Integration/ProjectFactoryTests.cs

@@ -0,0 +1,43 @@
+namespace NetEvolve.ProjectBuilders.XUnit.Tests.Integration;
+
+using System.Threading.Tasks;
+using NetEvolve.ProjectBuilders;
+using NetEvolve.ProjectBuilders.Builders;
+using NetEvolve.ProjectBuilders.Models;
+
+public class ProjectFactoryTests(TemporaryDirectoryFixture directory) : IClassFixture<TemporaryDirectoryFixture>
+{
+    [Fact]
+    public async Task BuildAsync_CSharpProject_Expected()
+    {
+        var subdirectory = directory.CreateDirectory(nameof(BuildAsync_CSharpProject_Expected));
+        await using var factory = ProjectFactory.Create(directory: subdirectory);
+
+        var result = await factory
+            .AddCSharpProject(projectBuilder => projectBuilder.WithTargetFramework(TargetFramework.Net8))
+            .AddGlobalJson(
+                Constants.RuntimeSdkDefault,
+                jsonBuilder => jsonBuilder.SetRollForward(RollForward.LatestMinor)
+            )
+            .BuildAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.True(result.HasNoErrorsOrWarnings());
+    }
+
+    [Fact]
+    public async Task BuildAsync_VBProject_Expected()
+    {
+        var subdirectory = directory.CreateDirectory(nameof(BuildAsync_VBProject_Expected));
+        await using var factory = ProjectFactory.Create(directory: subdirectory);
+
+        var result = await factory
+            .AddVBProject(projectBuilder => projectBuilder.WithTargetFramework(TargetFramework.Net8))
+            .AddGlobalJson(
+                Constants.RuntimeSdkDefault,
+                jsonBuilder => jsonBuilder.SetRollForward(RollForward.LatestMinor)
+            )
+            .BuildAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.True(result.HasNoErrorsOrWarnings());
+    }
+}