DSharpPlus · akiraveliara · May 18, 2025 · Feb 27, 2024 · Feb 27, 2024 · Feb 28, 2024
diff --git a/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/DSharpPlus.Analyzers.Test.csproj b/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/DSharpPlus.Analyzers.Test.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <TargetFramework>net9.0</TargetFramework>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
+    <GenerateDocumentationFile>false</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\DSharpPlus.Commands\DSharpPlus.Commands.csproj" />
+    <ProjectReference Include="..\DSharpPlus.Analyzers\DSharpPlus.Analyzers.csproj" />
+    <ProjectReference Include="..\..\DSharpPlus\DSharpPlus.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Basic.Reference.Assemblies.Net80" />
+    <PackageReference Include="Microsoft.CodeAnalysis" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing" />
+    <PackageReference Include="NUnit" />
+    <PackageReference Include="NUnit.Analyzers" />
+    <PackageReference Include="NUnit3TestAdapter" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+  </ItemGroup>
+</Project>
diff --git a/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/HasPermissionTest.cs b/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/HasPermissionTest.cs
@@ -0,0 +1,85 @@
+using System.Threading.Tasks;
+using DSharpPlus.Analyzers.Core;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using Verifier = Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<
+    DSharpPlus.Analyzers.Core.HasPermissionAnalyzer,
+    Microsoft.CodeAnalysis.Testing.DefaultVerifier
+>;
+
+namespace DSharpPlus.Analyzers.Test;
+
+public class HasPermissionTest
+{
+    /// <summary>
+    /// Unit test to see if HasPermissionAnalyzer reports
+    /// </summary>
+    [Test]
+    public static async Task HasPermissionNotEquals_DiagnosticAsync()
+    {
+        CSharpAnalyzerTest<HasPermissionAnalyzer, DefaultVerifier> test =
+            Utility.CreateAnalyzerTest<HasPermissionAnalyzer>();
+
+        test.TestCode = """
+                        using DSharpPlus.Entities;
+
+                        public class DoesIt
+                        {
+                            public static bool HaveAdmin(DiscordPermission perm) 
+                            {
+                                if ((perm & DiscordPermission.Administrator) != 0) 
+                                {
+                                    return true;
+                                }
+                                return false;
+                            }
+                        }
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(7, 13)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use 'perm.HasPermission(DiscordPermission.Administrator)' instead")
+        );
+
+        await test.RunAsync();
+    }
+
+    [Test]
+    public async Task HasPermissionEquals_DiagnosticAsync()
+    {
+        CSharpAnalyzerTest<HasPermissionAnalyzer, DefaultVerifier> test =
+            Utility.CreateAnalyzerTest<HasPermissionAnalyzer>();
+
+        test.TestCode = """
+                        using DSharpPlus.Entities;
+
+                        public class DoesIt
+                        {
+                            public static bool HaveNoAdmin(DiscordPermission perm) 
+                            {
+                                if ((perm & DiscordPermission.Administrator) == 0) 
+                                {
+                                    return true;
+                                }
+                                return false;
+                            }
+                        }
+
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(7, 13)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use 'perm.HasPermission(DiscordPermission.Administrator)' instead")
+        );
+
+        await test.RunAsync();
+    }
+}
diff --git a/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/MultipleOverwriteTest.cs b/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/MultipleOverwriteTest.cs
@@ -0,0 +1,195 @@
+using System.Threading.Tasks;
+using DSharpPlus.Analyzers.Core;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using Verifier = Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<
+    DSharpPlus.Analyzers.Core.MultipleOverwriteAnalyzer,
+    Microsoft.CodeAnalysis.Testing.DefaultVerifier
+>;
+
+namespace DSharpPlus.Analyzers.Test;
+
+/// <summary>
+/// 
+/// </summary>
+public static class MultipleOverwriteTest
+{
+    /// <summary>
+    /// Single diagnostic report for multiple overwrite analyzer
+    /// </summary>
+    [Test]
+    public static async Task DiagnosticAsync()
+    {
+        CSharpAnalyzerTest<MultipleOverwriteAnalyzer, DefaultVerifier> test =
+            Utility.CreateAnalyzerTest<MultipleOverwriteAnalyzer>();
+
+        test.TestCode = """
+                        using DSharpPlus.Entities;
+                        using System.Threading.Tasks;
+
+                        public class OverwriteTest
+                        {
+                            public async Task AddOverwritesAsync(DiscordChannel channel, DiscordMember member, DiscordMember member2)
+                            {
+                                await channel.AddOverwriteAsync(member, DiscordPermission.BanMembers);
+                                await channel.AddOverwriteAsync(member2, DiscordPermission.KickMembers);
+                            }
+                        }
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(9, 15)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use one 'channel.ModifyAsync(..)' instead of multiple 'channel.AddOverwriteAsync(..)'")
+        );
+        await test.RunAsync();
+    }
+
+    [Test]
+    public static async Task MultipleErrorsScenarioTestAsync()
+    {
+        CSharpAnalyzerTest<MultipleOverwriteAnalyzer, DefaultVerifier> test =
+            Utility.CreateAnalyzerTest<MultipleOverwriteAnalyzer>();
+
+        test.TestCode = """
+                        using DSharpPlus.Entities;
+                        using System.Threading.Tasks;
+
+                        public class OverwriteTest
+                        {
+                            public async Task AddOverwritesAsync(DiscordChannel channel, DiscordMember member, DiscordMember member2)
+                            {
+                                await channel.AddOverwriteAsync(member, DiscordPermission.BanMembers);
+                                await channel.AddOverwriteAsync(member2, DiscordPermission.KickMembers);
+                                await channel.AddOverwriteAsync(member2, DiscordPermission.Administrator);
+                            }
+                        }
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(9, 15)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use one 'channel.ModifyAsync(..)' instead of multiple 'channel.AddOverwriteAsync(..)'")
+        );
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(10, 15)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use one 'channel.ModifyAsync(..)' instead of multiple 'channel.AddOverwriteAsync(..)'")
+        );
+
+        await test.RunAsync();
+    }
+
+    [Test]
+    public static async Task ForEachLoopDiagnosticAsync()
+    {
+        CSharpAnalyzerTest<MultipleOverwriteAnalyzer, DefaultVerifier> test
+            = Utility.CreateAnalyzerTest<MultipleOverwriteAnalyzer>();
+
+        test.TestCode = """
+                        using DSharpPlus.Entities;
+                        using System.Threading.Tasks;
+                        using System.Collections.Generic;
+
+                        public class OverwriteTest
+                        {
+                            public async Task AddOverwritesAsync(DiscordChannel channel, List<DiscordMember> members)
+                            {
+                                foreach (DiscordMember member in members) 
+                                {
+                                    await channel.AddOverwriteAsync(member, DiscordPermission.BanMembers);
+                                }
+                            }
+                        }
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(11, 19)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use one 'channel.ModifyAsync(..)' instead of multiple 'channel.AddOverwriteAsync(..)'")
+        );
+
+        await test.RunAsync();
+    }
+
+    [Test]
+    public static async Task ForLoopDiagnosticAsync()
+    {
+        CSharpAnalyzerTest<MultipleOverwriteAnalyzer, DefaultVerifier> test
+            = Utility.CreateAnalyzerTest<MultipleOverwriteAnalyzer>();
+
+        test.TestCode = """
+                        using DSharpPlus.Entities;
+                        using System.Threading.Tasks;
+                        using System.Collections.Generic;
+
+                        public class OverwriteTest
+                        {
+                            public async Task AddOverwritesAsync(DiscordChannel channel, List<DiscordMember> members)
+                            {
+                                for (int i = 0; i < members.Count; i++)
+                                {
+                                    await channel.AddOverwriteAsync(members[i], DiscordPermission.BanMembers);
+                                }
+                            }
+                        }
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(11, 19)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use one 'channel.ModifyAsync(..)' instead of multiple 'channel.AddOverwriteAsync(..)'")
+        );
+
+        await test.RunAsync();
+    }
+
+    [Test]
+    public static async Task WhileLoopDiagnosticAsync()
+    {
+        CSharpAnalyzerTest<MultipleOverwriteAnalyzer, DefaultVerifier> test
+            = Utility.CreateAnalyzerTest<MultipleOverwriteAnalyzer>();
+
+        test.TestCode = """
+                        using DSharpPlus.Entities;
+                        using System.Threading.Tasks;
+                        using System.Collections.Generic;
+
+                        public class OverwriteTest
+                        {
+                            public async Task AddOverwritesAsync(DiscordChannel channel, List<DiscordMember> members)
+                            {
+                                int i = 0;
+                                while (i < members.Count)
+                                {
+                                    await channel.AddOverwriteAsync(members[i], DiscordPermission.BanMembers);
+                                    i++;
+                                }
+                            }
+                        }
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(12, 19)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessage("Use one 'channel.ModifyAsync(..)' instead of multiple 'channel.AddOverwriteAsync(..)'")
+        );
+
+        await test.RunAsync();
+    }
+}
diff --git a/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/ProcessorCheckTest.cs b/DSharpPlus.Analyzers/DSharpPlus.Analyzers.Test/ProcessorCheckTest.cs
@@ -0,0 +1,50 @@
+using System.Threading.Tasks;
+using DSharpPlus.Analyzers.Commands;
+using DSharpPlus.Commands;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using Verifier = Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<
+    DSharpPlus.Analyzers.Commands.ProcessorCheckAnalyzer,
+    Microsoft.CodeAnalysis.Testing.DefaultVerifier
+>;
+
+namespace DSharpPlus.Analyzers.Test;
+
+public static class ProcessorCheckTest
+{
+    [Test]
+    public static async Task DiagnosticTestAsync()
+    {
+        CSharpAnalyzerTest<ProcessorCheckAnalyzer, DefaultVerifier> test
+            = Utility.CreateAnalyzerTest<ProcessorCheckAnalyzer>();
+        test.TestState.AdditionalReferences.Add(typeof(CommandContext).Assembly);
+
+        test.TestCode = """
+                        using System.Threading.Tasks;
+                        using DSharpPlus.Commands.Trees.Metadata;
+                        using DSharpPlus.Commands.Processors.TextCommands;
+                        using DSharpPlus.Commands.Processors.SlashCommands;
+
+                        public class Test 
+                        {
+                            [AllowedProcessors<SlashCommandProcessor>()]
+                            public async Task Tester(TextCommandContext context)
+                            {
+                                await context.RespondAsync("Tester!");
+                            }
+                        }
+                        """;
+
+        test.ExpectedDiagnostics.Add
+        (
+            Verifier.Diagnostic()
+                .WithLocation(9, 30)
+                .WithSeverity(DiagnosticSeverity.Error)
+                .WithMessage("All provided processors does not support context 'TextCommandContext'")
+        );
+
+        await test.RunAsync();
+    }
+}