Skip to content

Ak1008 take2 #111

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

Draft
wants to merge 12 commits into
base: dev
Choose a base branch
from
Draft

Ak1008 take2 #111

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
6760a69
Add AK1008 - Check for multiple Stash.Stash() invocation
Arkatufus Nov 13, 2024
a8edf1b
Merge branch 'dev' into Add-AK1008-multiple-stash-invocation
Aaronontheweb Dec 19, 2024
892dce4
Try fixing `AK1008` using simpler constructs
Aaronontheweb Dec 23, 2024
b88f35c
have some tests passing
Aaronontheweb Dec 23, 2024
0e272a2
added check to skip comparisons on non-actor classes
Aaronontheweb Dec 23, 2024
dd6c43e
fixed `UntypedActor` failure cases
Aaronontheweb Dec 23, 2024
fd8351f
have `ReceiveActor` cases working
Aaronontheweb Dec 23, 2024
d9ef886
short-circuit calls
Aaronontheweb Dec 23, 2024
e0354ec
fix
Aaronontheweb Dec 23, 2024
b331e28
fixed specs
Aaronontheweb Dec 23, 2024
182f7aa
added a positive failure case for `switch` statements
Aaronontheweb Dec 23, 2024
5f17a36
some fixes
Aaronontheweb Dec 23, 2024
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
304 changes: 304 additions & 0 deletions src/Akka.Analyzers.Tests/Analyzers/AK1000/MustNotInvokeStashMoreThanOnceInsideABlockSpecs.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,304 @@
// -----------------------------------------------------------------------
// <copyright file="MustNotInvokeStashMoreThanOnceInsideABlockSpecs.cs" company="Akka.NET Project">
// Copyright (C) 2013-2024 .NET Foundation <https://github.com/akkadotnet/akka.net>
// </copyright>
// -----------------------------------------------------------------------

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Testing;
using Xunit.Abstractions;
using Verify = Akka.Analyzers.Tests.Utility.AkkaVerifier<Akka.Analyzers.MustNotInvokeStashMoreThanOnceAnalyzer>;

namespace Akka.Analyzers.Tests.Analyzers.AK1000;

public class MustNotInvokeStashMoreThanOnceInsideABlockSpecs
{
public static readonly TheoryData<string> SuccessCases = new()
{
// ReceiveActor with single Stash() invocation
"""
// 01
using Akka.Actor;
using System.Threading.Tasks;

public sealed class MyActor : ReceiveActor, IWithStash
{
public MyActor()
{
Receive<string>(str => {
Sender.Tell(str);
Stash.Stash(); // should not flag this
});
}

public void Handler()
{
Stash.Stash();
}

public IStash Stash { get; set; }
}
""",

// Non-Actor class that has Stash() methods, we're not responsible for this.
"""
// 02
public interface INonAkkaStash
{
public void Stash();
}

public class NonAkkaStash : INonAkkaStash
{
public void Stash() { }
}

public sealed class MyActor
{
public MyActor()
{
Stash = new NonAkkaStash();
}

public void Test()
{
Stash.Stash();
Stash.Stash(); // should not flag this
}

public INonAkkaStash Stash { get; }
}
""",

// Non-Actor class that uses Stash(),
// we're only responsible for checking usage inside ActorBase class and its descendants.
"""
// 03
using System;
using Akka.Actor;

public class MyActor
{
public MyActor(IStash stash)
{
Stash = stash;
}

public void Test()
{
Stash.Stash();
Stash.Stash(); // should not flag this
}

public IStash Stash { get; set; }
}
""",
// Stash calls inside 2 different code branch
"""
// 04
using Akka.Actor;

public sealed class MyActor : ReceiveActor, IWithStash
{
public MyActor(int n)
{
Receive<string>(str =>
{
if(n < 0)
{
Stash!.Stash();
}
else
{
Stash!.Stash(); // should not flag this
}
});
}

public IStash Stash { get; set; } = null!;
}
""",

// Stash calls inside 2 different code branch (switch statements)
"""
// 05
using Akka.Actor;

public sealed class MyActor : ReceiveActor, IWithStash
{
public MyActor(int n)
{
Receive<string>(str =>
{
switch(str){
case null:
Stash!.Stash();
break;
default:
Stash!.Stash(); // should not flag this
break;
}
});
}

public IStash Stash { get; set; } = null!;
}
""",
};

public static readonly
TheoryData<(string testData, (int startLine, int startColumn, int endLine, int endColumn)[] spanData)>
FailureCases = new()
{
// Receive actor invoking Stash()
(
"""
// 01
using System;
using Akka.Actor;
using System.Threading.Tasks;

public sealed class MyActor : ReceiveActor, IWithStash
{
public MyActor()
{
Receive<string>(str =>
{
Stash.Stash();
Stash.Stash(); // Error
});
}

public IStash Stash { get; set; } = null!;
}
""", [
(12, 13, 12, 26),
(13, 13, 13, 26)
]),

// Receive actor invoking Stash() inside and outside of a code branch
(
"""
// 02
using System;
using Akka.Actor;
using System.Threading.Tasks;

public sealed class MyActor : ReceiveActor, IWithStash
{
public MyActor(int n)
{
Receive<string>(str =>
{
if(n < 0)
{
Stash!.Stash();
}

Stash.Stash(); // Error
});
}

public IStash Stash { get; set; } = null!;
}
""", [(12, 13, 12, 105),
(14, 13, 14, 26)]),

// UntypedActor invoking Stash() twice without branching
(
"""
// 03
using Akka.Actor;

public class MyUntypedActor : UntypedActor, IWithStash
{
protected override void OnReceive(object message)
{
Stash.Stash();
Stash.Stash(); // Error
}

public IStash Stash { get; set; } = null!;
}
""", [(8, 9, 8, 22),
(9, 9, 9, 22)]),
// UntypedActor invoking Stash() twice with a switch, but one is outside
(
"""
// 04
using Akka.Actor;

public class MyUntypedActor : UntypedActor, IWithStash
{
protected override void OnReceive(object message)
{
Stash.Stash();

switch(message)
{
case string s:
Stash.Stash(); // Error
break;
}
}

public IStash Stash { get; set; } = null!;
}
""", [(8, 9, 8, 22),
(13, 17, 13, 30)]),

// UntypedActor invoking Stash() twice with a switch, but one is outside
(
"""
// 05
using Akka.Actor;

public class MyUntypedActor : UntypedActor, IWithStash
{
protected override void OnReceive(object message)
{
Stash.Stash();

if(message is string s)
{
Stash.Stash(); // Error
}
}

public IStash Stash { get; set; } = null!;
}
""", [(8, 9, 8, 22),
(12, 17, 12, 30)]),
};

private readonly ITestOutputHelper _output;

public MustNotInvokeStashMoreThanOnceInsideABlockSpecs(ITestOutputHelper output)
{
_output = output;
}

[Theory]
[MemberData(nameof(SuccessCases))]
public Task SuccessCase(string testCode)
{
return Verify.VerifyAnalyzer(testCode);
}

[Theory]
[MemberData(nameof(FailureCases))]
public Task FailureCase(
(string testCode, (int startLine, int startColumn, int endLine, int endColumn)[] spanData) d)
{
List<DiagnosticResult> expectedResults = new();

foreach(var (startLine, startColumn, endLine, endColumn) in d.spanData)
{
var expected = Verify.Diagnostic().WithSpan(startLine, startColumn, endLine, endColumn).WithSeverity(DiagnosticSeverity.Error);
expectedResults.Add(expected);
}

return Verify.VerifyAnalyzer(d.testCode, expectedResults.ToArray());
}
}
Loading
Loading