Skip to content

feat(migration): add Assert.Warn support and Is.Positive/Negative tests #4363

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
thomhurst merged 2 commits into from
Jan 13, 2026
Merged

feat(migration): add Assert.Warn support and Is.Positive/Negative tests #4363

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
e866522
feat(migration): add Assert.Warn support for NUnit migration
thomhurst Jan 13, 2026
e225507
test(migration): add tests for Is.Positive, Is.Negative, and negations
thomhurst Jan 13, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
41 changes: 41 additions & 0 deletions TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1151,6 +1151,7 @@ waitInvocation.Expression is MemberAccessExpressionSyntax waitAccess &&
"Fail" => CreateFailAssertion(arguments),
"Inconclusive" => CreateSkipAssertion(arguments),
"Ignore" => CreateSkipAssertion(arguments),
"Warn" => CreateWarnAssertion(arguments),

// 2-arg assertions (expected, actual) with optional message at index 2
"AreEqual" when arguments.Count >= 2 => ConvertAreEqualWithComparer(arguments),
Expand Down Expand Up @@ -1472,6 +1473,46 @@ private ExpressionSyntax CreateSkipAssertion(SeparatedSyntaxList<ArgumentSyntax>
return skipInvocation;
}

private ExpressionSyntax CreateWarnAssertion(SeparatedSyntaxList<ArgumentSyntax> arguments)
{
// NUnit's Assert.Warn outputs a warning but allows the test to continue
// TUnit doesn't have a direct equivalent, so we convert to Skip.Test with a prefix
// Users may want to handle warnings differently (e.g., console output)
var messageArg = arguments.Count > 0
? arguments[0]
: SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal("Warning")));

// Wrap the message in "Warning: " prefix
var prefixedMessage = SyntaxFactory.Argument(
SyntaxFactory.InterpolatedStringExpression(
SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken),
SyntaxFactory.List<InterpolatedStringContentSyntax>(
[
SyntaxFactory.InterpolatedStringText()
.WithTextToken(SyntaxFactory.Token(
SyntaxFactory.TriviaList(),
SyntaxKind.InterpolatedStringTextToken,
"Warning: ",
"Warning: ",
SyntaxFactory.TriviaList())),
SyntaxFactory.Interpolation(messageArg.Expression)
])));

var skipInvocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Skip"),
SyntaxFactory.IdentifierName("Test")
),
SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(prefixedMessage))
);

return skipInvocation;
}

private ExpressionSyntax? ConvertFileAssertion(InvocationExpressionSyntax invocation, string methodName)
{
var arguments = invocation.ArgumentList.Arguments;
Expand Down
192 changes: 192 additions & 0 deletions TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2268,6 +2268,42 @@ public void TestMethod()
);
}

[Test]
public async Task NUnit_Warn_Converted()
{
await CodeFixer.VerifyCodeFixAsync(
"""
using NUnit.Framework;

{|#0:public class MyClass|}
{
[Test]
public void TestMethod()
{
Assert.Warn("This is a warning");
}
}
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using TUnit.Core;
using TUnit.Assertions;
using static TUnit.Assertions.Assert;
using TUnit.Assertions.Extensions;

public class MyClass
{
[Test]
public void TestMethod()
{
Skip.Test($"Warning: {"This is a warning"}");
}
}
""",
ConfigureNUnitTest
);
}

[Test]
public async Task NUnit_Fail_Converted()
{
Expand Down Expand Up @@ -2552,6 +2588,162 @@ public async Task TestMethod()
);
}

[Test]
public async Task NUnit_Is_Positive_Converted()
{
await CodeFixer.VerifyCodeFixAsync(
"""
using NUnit.Framework;

{|#0:public class MyClass|}
{
[Test]
public void TestMethod()
{
int value = 5;
Assert.That(value, Is.Positive);
}
}
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
using TUnit.Core;
using TUnit.Assertions;
using static TUnit.Assertions.Assert;
using TUnit.Assertions.Extensions;

public class MyClass
{
[Test]
public async Task TestMethod()
{
int value = 5;
await Assert.That(value).IsPositive();
}
}
""",
ConfigureNUnitTest
);
}

[Test]
public async Task NUnit_Is_Negative_Converted()
{
await CodeFixer.VerifyCodeFixAsync(
"""
using NUnit.Framework;

{|#0:public class MyClass|}
{
[Test]
public void TestMethod()
{
int value = -5;
Assert.That(value, Is.Negative);
}
}
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
using TUnit.Core;
using TUnit.Assertions;
using static TUnit.Assertions.Assert;
using TUnit.Assertions.Extensions;

public class MyClass
{
[Test]
public async Task TestMethod()
{
int value = -5;
await Assert.That(value).IsNegative();
}
}
""",
ConfigureNUnitTest
);
}

[Test]
public async Task NUnit_Is_Not_Positive_Converted()
{
await CodeFixer.VerifyCodeFixAsync(
"""
using NUnit.Framework;

{|#0:public class MyClass|}
{
[Test]
public void TestMethod()
{
int value = -5;
Assert.That(value, Is.Not.Positive);
}
}
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
using TUnit.Core;
using TUnit.Assertions;
using static TUnit.Assertions.Assert;
using TUnit.Assertions.Extensions;

public class MyClass
{
[Test]
public async Task TestMethod()
{
int value = -5;
await Assert.That(value).IsLessThanOrEqualTo(0);
}
}
""",
ConfigureNUnitTest
);
}

[Test]
public async Task NUnit_Is_Not_Negative_Converted()
{
await CodeFixer.VerifyCodeFixAsync(
"""
using NUnit.Framework;

{|#0:public class MyClass|}
{
[Test]
public void TestMethod()
{
int value = 5;
Assert.That(value, Is.Not.Negative);
}
}
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
using TUnit.Core;
using TUnit.Assertions;
using static TUnit.Assertions.Assert;
using TUnit.Assertions.Extensions;

public class MyClass
{
[Test]
public async Task TestMethod()
{
int value = 5;
await Assert.That(value).IsGreaterThanOrEqualTo(0);
}
}
""",
ConfigureNUnitTest
);
}

[Test]
public async Task NUnit_Platform_Attribute_Removed()
{
Expand Down
Loading