Initial skeleton for unit testing

#39

Author: ProgrammingByPermutation

src/Nullinside.Api.TwitchBot.Tests/ChatRules/AChatRuleUnitTestBase.cs

@@ -0,0 +1,56 @@
+using Moq;
+using Nullinside.Api.Common.Twitch;
+using Nullinside.Api.Model.Ddl;
+using Nullinside.Api.TwitchBot.ChatRules;
+
+namespace Nullinside.Api.TwitchBot.Tests.ChatRules;
+
+public abstract class AChatRuleUnitTestBase<T> : UnitTestBase where T : AChatRule, new()
+{
+    /// <summary>
+    /// Tests that the message filter is capable of passing at all.
+    /// </summary>
+    /// <param name="goodString">A friendly string with no issues.</param>
+    [Test]
+    [TestCase("Hello I love candy and sprinkles")]
+    public async Task TestItDoesntAlwaysFail(string goodString)
+    {
+        var rule = new T();
+        var botProxy = new Mock<ITwitchApiProxy>();
+        
+        // Process the message and assert that we pass the message.
+        var chat = new TwitchChatMessage(true, goodString, "123", "456");
+        var result = await rule.Handle("123", botProxy.Object, chat, this._db);
+        Assert.That(result, Is.True);
+        
+        // Process the message and assert that we pass the message.
+        chat = new TwitchChatMessage(false, goodString, "123", "456");
+        result = await rule.Handle("123", botProxy.Object, chat, this._db);
+        Assert.That(result, Is.True);
+    }
+    
+    /// <summary>
+    /// Tests that the rules are only running when they should be.
+    /// </summary>
+    [Test]
+    public void TestShouldRun()
+    {
+        var rule = new T();
+        
+        // Rule is turned on and so is scanning.
+        var shouldRun = rule.ShouldRun(new TwitchUserConfig { Enabled = true, BanKnownBots = true });
+        Assert.That(shouldRun, Is.True);
+        
+        // Scanning is turned off
+        shouldRun = rule.ShouldRun(new TwitchUserConfig { Enabled = false, BanKnownBots = true });
+        Assert.That(shouldRun, Is.False);
+        
+        // Rule is turned off.
+        shouldRun = rule.ShouldRun(new TwitchUserConfig { Enabled = true, BanKnownBots = false });
+        Assert.That(shouldRun, Is.False);
+        
+        // Everything is off.
+        shouldRun = rule.ShouldRun(new TwitchUserConfig { Enabled = false, BanKnownBots = false });
+        Assert.That(shouldRun, Is.False);
+    }
+}

src/Nullinside.Api.TwitchBot.Tests/ChatRules/BestCheapViewersTests.cs

@@ -1,7 +1,12 @@
+using Moq;
+using Nullinside.Api.Common.Twitch;
+using Nullinside.Api.Model;
+using Nullinside.Api.TwitchBot.ChatRules;
+using TwitchLib.Client.Models;
+
 namespace Nullinside.Api.TwitchBot.Tests.ChatRules;
 
-public class BestCheapViewersTests
-{
+public class BestCheapViewersTests : AChatRuleUnitTestBase<BestCheapViewers> {
     [Test]
     [TestCase("Best viewers on ***")]
     [TestCase("Best  viewers on ***")]
@@ -18,9 +23,14 @@ public class BestCheapViewersTests
     [TestCase("C̀heap Viewers on ***")]
     [TestCase("Cheaͧp v̫iewers on ***")]
     [TestCase("Cheaͧp v̫iewers on *** ")]
-    public void TestKnownStrings(string badString)
+    public async Task TestKnownStrings(string badString)
     {
-        // Need to put interfaces in front of the classes before we can do this.
-        Assert.Pass();
+        var rule = new BestCheapViewers();
+        var botProxy = new Mock<ITwitchApiProxy>();
+        var chat = new TwitchChatMessage(true, badString, "123", "456");
+        
+        // Process the message and assert that we fail the message.
+        var result = await rule.Handle("123", botProxy.Object, chat, this._db);
+        Assert.That(result, Is.False);
     }
 }

src/Nullinside.Api.TwitchBot.Tests/ChatRules/DiscordTests.cs

@@ -1,16 +1,39 @@
-namespace Nullinside.Api.TwitchBot.Tests.ChatRules;
+using Moq;
+using Nullinside.Api.Common.Twitch;
+using Nullinside.Api.TwitchBot.ChatRules;
 
-public class DiscordTests
+namespace Nullinside.Api.TwitchBot.Tests.ChatRules;
+
+public class DiscordTests : AChatRuleUnitTestBase<Discord>
 {
     [Test]
     [TestCase("Hello mate you stream pretty cool that's why I follow I would love to be a fan of yours if you don't mind kindly add me on Discord: 👉👉lacaster5")]
     [TestCase("Hello, I just recently found your channel and can already tell that your content is great, and I would love to stick with you long term. If you're open to it, I'd be willing to connect with you on Discord. My username is teecash1000")]
     [TestCase("Hey there 👋 You stream pretty cool that’s why I followed you. I will like to make you a friend and be a fan, if you don’t mind Kindly chat me on Discord, my Discord username is tuckzay")]
     [TestCase("Hi! Just wanted to say that I absolutely love your gameplay and content.l'd love to connect better with you on Discord if that's possible. Looking forward to more awesome streams from you! My username is 👉👉👉 edisonpires")]
     [TestCase("What's up Friend, great stream! I'm having a blast watching you stream. Let's move the conversation to Discord, where we can discuss more about streaming in more detail and get to know each other better. See you there! My discord username is 👉john_6029")]
-    public void TestKnownStrings(string badString)
+    public async Task TestKnownStrings(string badString)
+    {
+        var rule = new Discord();
+        var botProxy = new Mock<ITwitchApiProxy>();
+        var chat = new TwitchChatMessage(true, badString, "123", "456");
+        
+        // Process the message and assert that we fail the message.
+        var result = await rule.Handle("123", botProxy.Object, chat, this._db);
+        Assert.That(result, Is.False);
+    }
+    
+    [Test]
+    [TestCase("I've heard of the application discord before and it sounds great")]
+    [TestCase("I was talking on my discord the other day")]
+    public async Task EnsureNoFalsePositives(string badString)
     {
-        // Need to put interfaces in front of the classes before we can do this.
-        Assert.Pass();
+        var rule = new Discord();
+        var botProxy = new Mock<ITwitchApiProxy>();
+        var chat = new TwitchChatMessage(true, badString, "123", "456");
+        
+        // Process the message and assert that we do not fail the message.
+        var result = await rule.Handle("123", botProxy.Object, chat, this._db);
+        Assert.That(result, Is.True);
     }
 }

src/Nullinside.Api.TwitchBot.Tests/ChatRules/StreamViewersTests.cs

@@ -1,15 +1,22 @@
+using Moq;
+using Nullinside.Api.Common.Twitch;
 using Nullinside.Api.TwitchBot.ChatRules;
 
 namespace Nullinside.Api.TwitchBot.Tests.ChatRules;
 
-public class StreamViewersTests
+public class StreamViewersTests : AChatRuleUnitTestBase<StreamViewers>
 {
     [Test]
     [TestCase("@jellynyeko dо уоu alrеady triеd strеamviewers  оrg? Real viewеrs, fire works! Тhеy arе now giving оut а frее рackagе for streamers оО")]
     [TestCase("@kygaming98 dо уоu аlready tried streаmviewers  оrg? Real viewers, firе works! Thеy arе now giving оut а freе package fоr streamers oО")]
-    public void TestKnownStrings(string badString)
+    public async Task TestKnownStrings(string badString)
     {
-        // Need to put interfaces in front of the classes before we can do this.
-        Assert.Pass();
+        var rule = new StreamViewers();
+        var botProxy = new Mock<ITwitchApiProxy>();
+        var chat = new TwitchChatMessage(true, badString, "123", "456");
+        
+        // Process the message and assert that we fail the message.
+        var result = await rule.Handle("123", botProxy.Object, chat, this._db);
+        Assert.That(result, Is.False);
     }
 }

src/Nullinside.Api.TwitchBot.Tests/Nullinside.Api.TwitchBot.Tests.csproj

@@ -14,7 +14,9 @@
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.8" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+        <PackageReference Include="Moq" Version="4.20.72" />
         <PackageReference Include="NUnit" Version="4.2.2" />
         <PackageReference Include="NUnit.Analyzers" Version="4.3.0">
           <PrivateAssets>all</PrivateAssets>

src/Nullinside.Api.TwitchBot.Tests/UnitTestBase.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Nullinside.Api.Model;
+
+namespace Nullinside.Api.TwitchBot.Tests;
+
+/// <summary>
+///   A base class for all unit tests.
+/// </summary>
+public abstract class UnitTestBase {
+  /// <summary>
+  ///   A fake database.
+  /// </summary>
+  protected INullinsideContext _db;
+
+  [SetUp]
+  public virtual void Setup() {
+    // Create an in-memory database to fake the SQL queries. Note that we generate a random GUID for the name
+    // here. If you use the same name more than once you'll get collisions between tests.
+    DbContextOptions<NullinsideContext> contextOptions = new DbContextOptionsBuilder<NullinsideContext>()
+      .UseInMemoryDatabase(Guid.NewGuid().ToString())
+      .ConfigureWarnings(b => b.Ignore(InMemoryEventId.TransactionIgnoredWarning))
+      .Options;
+    _db = new NullinsideContext(contextOptions);
+  }
+
+  [TearDown]
+  public virtual async Task TearDown() {
+    // Dispose since it has one.
+    await _db.DisposeAsync();
+  }
+}

src/Nullinside.Api.TwitchBot/ChatRules/AChatRule.cs

@@ -16,7 +16,7 @@ public abstract class AChatRule : IChatRule {
   public abstract bool ShouldRun(TwitchUserConfig config);
 
   /// <inheritdoc />
-  public abstract Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, ChatMessage message,
+  public abstract Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, TwitchChatMessage message,
     INullinsideContext db, CancellationToken stoppingToken = new());
 
   /// <summary>

src/Nullinside.Api.TwitchBot/ChatRules/BestCheapViewers.cs

@@ -26,7 +26,7 @@ public override bool ShouldRun(TwitchUserConfig config) {
   }
 
   /// <inheritdoc />
-  public override async Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, ChatMessage message,
+  public override async Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, TwitchChatMessage message,
     INullinsideContext db, CancellationToken stoppingToken = new()) {
     if (!message.IsFirstMessage) {
       return true;

src/Nullinside.Api.TwitchBot/ChatRules/Discord.cs

@@ -22,7 +22,7 @@ public override bool ShouldRun(TwitchUserConfig config) {
   }
 
   /// <inheritdoc />
-  public override async Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, ChatMessage message,
+  public override async Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, TwitchChatMessage message,
     INullinsideContext db, CancellationToken stoppingToken = new()) {
     if (!message.IsFirstMessage) {
       return true;

src/Nullinside.Api.TwitchBot/ChatRules/Dogehype.cs

@@ -16,7 +16,7 @@ public override bool ShouldRun(TwitchUserConfig config) {
   }
 
   /// <inheritdoc />
-  public override async Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, ChatMessage message,
+  public override async Task<bool> Handle(string channelId, ITwitchApiProxy botProxy, TwitchChatMessage message,
     INullinsideContext db, CancellationToken stoppingToken = new()) {
     // The number of spaces per message may chance, so normalize that and lowercase it for comparison.
     string normalized = string.Concat(message.Message.Split(" ").Where(s => !string.IsNullOrWhiteSpace(s)))