Initial Commit

.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: "nuget"
+    directory: "/"
+    open-pull-requests-limit: 20
+    schedule:
+      interval: "daily"
+    groups:
+      test-dependencies:
+        patterns:
+          - NUnit*
+          - "*Test*"
+      modularpipelines-dependencies:
+        patterns:
+          - "*ModularPipeline*"
+    ignore:
+      - dependency-name: "Microsoft.Extensions.*"
+        update-types: ["version-update:semver-major"]

.github/workflows/dotnet.yml

@@ -0,0 +1,39 @@
+# This workflow will build a .NET project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
+
+name: .NET
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  workflow_dispatch:
+    inputs:
+      publish-packages:
+        description: Publish packages?    
+        type: boolean
+        required: true
+
+jobs:
+  modularpipeline:
+    environment: ${{ github.ref == 'refs/heads/main' && 'Production' || 'Pull Requests' }}
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 8.0.x
+      - name: Run Pipeline
+        run: dotnet run -c Release
+        working-directory: "TUnit.Pipeline"
+        env:
+          DOTNET_ENVIRONMENT: ${{ github.ref == 'refs/heads/main' && 'Production' || 'Development' }}
+          NuGet__ApiKey: ${{ secrets.NUGET__APIKEY }}
+          PULL_REQUEST_BRANCH: ${{ github.event.pull_request.head.ref }}
+          PUBLISH_PACKAGES: ${{ github.event.inputs.publish-packages }}

Directory.Build.props

@@ -0,0 +1,16 @@
+<Project>
+    <ItemGroup>
+        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+            <_Parameter1>TUnit.Core</_Parameter1>
+        </AssemblyAttribute>
+        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+            <_Parameter1>TUnit.Engine</_Parameter1>
+        </AssemblyAttribute>
+        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+            <_Parameter1>TUnit</_Parameter1>
+        </AssemblyAttribute>
+        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+            <_Parameter1>TUnit.TestAdapter</_Parameter1>
+        </AssemblyAttribute>
+    </ItemGroup>
+</Project>

README.md

@@ -1 +1,62 @@
-# TUnit
+# TUnit
+T(est)Unit!
+
+```csharp
+    [Test]
+    public async Task Test1()
+    {
+        var value = "Hello world!";
+
+        await Assert.That(value)
+            .Is.Not.Null
+            .And.Is.EqualTo("hello world!", StringComparison.InvariantCultureIgnoreCase)
+            .And.Has.Count().EqualTo(12)
+            .And.Does.StartWith("H");
+    }
+```
+
+## Motivations
+There are only three main testing frameworks in the .NET world - xUnit, NUnit and MSTest.
+More frameworks means more options, and more options motivates more features or improvements.
+
+These testing frameworks are amazing, but I've had some issues with them. You might not have had any of these, but these are my experiences:
+
+### xUnit
+There is no way to tap into information about a test in a generic way. 
+For example, I've had some Playwright tests run before, and I want them to save a screenshot or video ONLY when the test fails.
+If the test passes, I don't have anything to investigate, and it'll use up unnecessary storage, and it'll probably slow my test suite down if I had hundreds or thousands of tests all trying to save screenshots.
+
+However, if I'm in a Dispose method which is called when the test ends, then there's no way for me to know if my test succeeded or failed. I'd have to do some really clunky workaround involving try catch and setting a boolean or exception to a class field and checking that. And to do that for every test was just not ideal.
+
+#### Assertions
+I have stumbled across assertions so many times where the arguments are the wrong way round.
+This can result in really confusing error messages.
+```csharp
+var one = 2;
+Assert.Equal(1, one)
+Assert.Equal(one, 1)
+```
+
+### NUnit
+
+#### Assertions
+I absolutely love the newer assertion syntax in NUnit. The `Assert.That(something, Is.Something)`. I think it's really clear to read, it's clear what is being asserted, and it's clear what you're trying to achieve.
+
+However, there is a lack of type checking on assertions. (Yes, there are analyzer packages to help with this, but this still isn't strict type checking.)
+
+`Assert.That("1", Throws.Exception);`
+
+This assertion makes no sense, because we're passing in a string. This can never throw an exception because it isn't a delegate that can be executed. But it's still perfectly valid code that will compile.
+
+As does this:
+`Assert.That(1, Does.Contain("Foo!"));`
+
+With TUnit assertions, I wanted to make these impossible to compile. So type constraints are built into the assertions themselves. There should be no way for a non-delegate to be able to do a `Throws` assertion, or for an `int` assertion to check for `string` conditions.
+
+So in TUnit, this will compile:
+
+`await Assert.That(() => 1).Throws.Nothing;`
+
+This won't:
+
+`await Assert.That(1).Throws.Nothing;`

TUnit.Analyzers/TUnit.Analyzers.Sample/Examples.cs

@@ -0,0 +1,24 @@
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+
+using System.Threading.Tasks;
+using TUnit.Assertions;
+
+namespace TUnit.Analyzers.Sample;
+
+// If you don't see warnings, build the Analyzers Project.
+
+public class Examples
+{
+    public class CommonClass // Try to apply quick fix using the IDE.
+    {
+    }
+
+    public async Task ToStars()
+    {
+        await Assert.That("1").Is.EqualTo("2");
+        var spaceship = new Spaceship();
+        spaceship.SetSpeed(300000000); // Invalid value, it should be highlighted.
+        spaceship.SetSpeed(42);
+    }
+}

TUnit.Analyzers/TUnit.Analyzers.Sample/Spaceship.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace TUnit.Analyzers.Sample;
+
+public class Spaceship
+{
+    public void SetSpeed(long speed)
+    {
+        if (speed > 299_792_458)
+            throw new ArgumentOutOfRangeException(nameof(speed));
+    }
+}

TUnit.Analyzers/TUnit.Analyzers.Sample/TUnit.Analyzers.Sample.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\TUnit\TUnit.csproj" />
+        <ProjectReference Include="..\TUnit.Analyzers\TUnit.Analyzers.csproj"
+                          OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="NUnit" Version="4.0.1" />
+    </ItemGroup>
+
+</Project>

TUnit.Analyzers/TUnit.Analyzers.Tests/AwaitAssertionAnalyzerTests.cs

@@ -0,0 +1,33 @@
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Verifier = TUnit.Analyzers.Tests.Verifiers.CSharpAnalyzerVerifier<TUnit.Analyzers.AwaitAssertionAnalyzer>;
+
+namespace TUnit.Analyzers.Tests;
+
+public class AwaitAssertionAnalyzerTests
+{
+    [Test]
+    public async Task ClassWithMyCompanyTitle_AlertDiagnostic()
+    {
+        const string text = """
+                            using System.Threading.Tasks;
+                            using TUnit.Assertions;
+                            using TUnit.Core;
+
+                            public class MyClass
+                            {
+
+                                public async Task MyTest()
+                                {
+                                    var one = 1;
+                                    {|#0:Assert.That(one).Is.EqualTo(1);|}
+                                }
+
+                            }
+                            """;
+
+        var expected = Verifier.Diagnostic().WithLocation(0);
+
+        await Verifier.VerifyAnalyzerAsync(text, expected).ConfigureAwait(false);
+    }
+}

TUnit.Analyzers/TUnit.Analyzers.Tests/Net.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Immutable;
+using System.IO;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace TUnit.Analyzers.Tests;
+
+internal static class Net
+{
+    private static readonly Lazy<ReferenceAssemblies> LazyNet60 = new(() =>
+        new ReferenceAssemblies(
+                "net6.0",
+                new PackageIdentity(
+                    "Microsoft.NETCore.App.Ref",
+                    "6.0.21"),
+                Path.Combine("ref", "net6.0"))
+            .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.Extensions.Logging", "6.0.0")))
+        );
+
+    public static ReferenceAssemblies Net60 => LazyNet60.Value;
+
+    private static readonly Lazy<ReferenceAssemblies> LazyNet70 = new(() =>
+        new ReferenceAssemblies(
+                "net7.0",
+                new PackageIdentity(
+                    "Microsoft.NETCore.App.Ref",
+                    "7.0.15"),
+                Path.Combine("ref", "net7.0"))
+            .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.Extensions.Logging", "7.0.0")))
+    );
+
+    private static readonly Lazy<ReferenceAssemblies> LazyNet80 = new(() =>
+        new ReferenceAssemblies(
+                "net8.0",
+                new PackageIdentity(
+                    "Microsoft.NETCore.App.Ref",
+                    "8.0.1"),
+                Path.Combine("ref", "net8.0"))
+            .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.Extensions.Logging", "8.0.0")))
+    );
+
+    public static ReferenceAssemblies Net70 => LazyNet70.Value;
+    public static ReferenceAssemblies Net80 => LazyNet80.Value;
+}

TUnit.Analyzers/TUnit.Analyzers.Tests/SampleCodeFixProviderTests.cs

@@ -0,0 +1,31 @@
+// using System.Threading.Tasks;
+// using Xunit;
+// using Verifier =
+//     Microsoft.CodeAnalysis.CSharp.Testing.XUnit.CodeFixVerifier<TUnit.Analyzers.MixAndOrOperatorsAnalyzer,
+//         TUnit.Analyzers.SampleCodeFixProvider>;
+//
+// namespace TUnit.Analyzers.Tests;
+//
+// public class SampleCodeFixProviderTests
+// {
+//     [Fact]
+//     public async Task ClassWithMyCompanyTitle_ReplaceWithCommonKeyword()
+//     {
+//         const string text = @"
+// public class MyCompanyClass
+// {
+// }
+// ";
+//
+//         const string newText = @"
+// public class CommonClass
+// {
+// }
+// ";
+//
+//         var expected = Verifier.Diagnostic()
+//             .WithLocation(2, 14)
+//             .WithArguments("MyCompanyClass");
+//         await Verifier.VerifyCodeFixAsync(text, expected, newText).ConfigureAwait(false);
+//     }
+// }

TUnit.Analyzers/TUnit.Analyzers.Tests/TUnit.Analyzers.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.NUnit" Version="1.1.1" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.NUnit" Version="1.1.1" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeRefactoring.Testing.NUnit" Version="1.1.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.2"/>
+        <PackageReference Include="NUnit" Version="3.14.0" />
+        <PackageReference Include="NUnit.Analyzers" Version="4.0.1">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\TUnit.Assertions\TUnit.Assertions.csproj" />
+        <ProjectReference Include="..\..\TUnit\TUnit.csproj" />
+        <ProjectReference Include="..\TUnit.Analyzers\TUnit.Analyzers.csproj"/>
+    </ItemGroup>
+
+</Project>