diff --git a/.markdownlintignore b/.markdownlintignore
new file mode 100644
index 000000000..1b763b1ba
--- /dev/null
+++ b/.markdownlintignore
@@ -0,0 +1 @@
+CHANGELOG.md
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 820f0a1a0..54f60b335 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ Please ADD ALL Changes to the UNRELEASED SECTION and not a specific release
 - BuildBot.Health.Tests: new test project covering BuildBot.Health at 100% line and branch coverage
 - BuildBot.Json.Tests: new test project covering BuildBot.Json at 100% line and branch coverage
 - BuildBot.ServiceModel.Tests: Added test coverage for all types in BuildBot.ServiceModel
+- BuildBot.Discord.Tests: Added unit tests to increase code coverage to 100%
 ### Fixed
 - Suppress known Scriban 6.2.0 vulnerabilities pending upgrade
 - SnsMessage: Token property was never populated from the constructor argument
@@ -57,6 +58,7 @@ Please ADD ALL Changes to the UNRELEASED SECTION and not a specific release
 - Dependencies - Updated Discord.Net to 3.19.1
 - Dependencies - Updated Microsoft.Extensions to 10.0.5
 - SDK - Updated DotNet SDK to 10.0.301
+- BuildBot.Discord.Tests: Added branch coverage tests for null-title paths in DiscordBot.PublishCommonAsync
 ### Removed
 ### Deployment Changes
 <!--
diff --git a/src/BuildBot.Discord.Tests/BuildBot.Discord.Tests.csproj b/src/BuildBot.Discord.Tests/BuildBot.Discord.Tests.csproj
new file mode 100644
index 000000000..621c3d741
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/BuildBot.Discord.Tests.csproj
@@ -0,0 +1,73 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AnalysisLevel>latest</AnalysisLevel>
+    <AnalysisMode>AllEnabledByDefault</AnalysisMode>
+    <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
+    <DebuggerSupport>true</DebuggerSupport>
+    <DisableImplicitNuGetFallbackFolder>true</DisableImplicitNuGetFallbackFolder>
+    <EnableMicrosoftExtensionsConfigurationBinderSourceGenerator>true</EnableMicrosoftExtensionsConfigurationBinderSourceGenerator>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <EnforceExtendedAnalyzerRules>false</EnforceExtendedAnalyzerRules>
+    <Features>strict;flow-analysis</Features>
+    <GenerateNeutralResourcesLanguageAttribute>true</GenerateNeutralResourcesLanguageAttribute>
+    <IlcGenerateStackTraceData>false</IlcGenerateStackTraceData>
+    <IlcOptimizationPreference>Size</IlcOptimizationPreference>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+    <IsPublishable>false</IsPublishable>
+    <IsTrimmable>false</IsTrimmable>
+    <JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>
+    <LangVersion>latest</LangVersion>
+    <NoWarn />
+    <NuGetAudit>true</NuGetAudit>
+    <NuGetAuditLevel>high</NuGetAuditLevel>
+    <NuGetAuditMode>all</NuGetAuditMode>
+    <Nullable>enable</Nullable>
+    <OptimizationPreference>speed</OptimizationPreference>
+    <OutputType>Exe</OutputType>
+    <RunAOTCompilation>false</RunAOTCompilation>
+    <TargetFramework>net10.0</TargetFramework>
+    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
+    <TieredCompilation>true</TieredCompilation>
+    <TieredPGO>true</TieredPGO>
+    <TreatSpecificWarningsAsErrors />
+    <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+    <UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>
+    <UseSystemResourceKeys>true</UseSystemResourceKeys>
+    <WarnOnPackingNonPackableProject>false</WarnOnPackingNonPackableProject>
+    <WarningsAsErrors />
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)UnitTests.props" Condition="Exists('$(SolutionDir)UnitTests.props')" />
+  <ItemGroup>
+    <ProjectReference Include="..\BuildBot.Discord\BuildBot.Discord.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="FunFair.Test.Common" Version="6.2.25.2243" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="NSubstitute" Version="5.3.0" />
+    <PackageReference Include="xunit.v3.mtp-v2" Version="3.2.2" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="AsyncFixer" Version="2.1.0" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="codecracker.CSharp" Version="1.1.0" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="Credfeto.Enumeration.Source.Generation" Version="1.2.139.1741" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="CSharpIsNullAnalyzer" Version="0.1.593" PrivateAssets="all" ExcludeAssets="runtime" />
+    <PackageReference Include="FunFair.CodeAnalysis" Version="7.1.35.1745" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="FunFair.Test.Source.Generator" Version="6.2.25.2243" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="Meziantou.Analyzer" Version="3.0.22" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="NSubstitute.Analyzers.CSharp" Version="1.0.17" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="Nullable.Extended.Analyzer" Version="1.15.6581" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="Philips.CodeAnalysis.DuplicateCodeAnalyzer" Version="1.6.4" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="Philips.CodeAnalysis.MaintainabilityAnalyzers" Version="1.9.1" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="Roslynator.Analyzers" Version="4.15.0" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="SecurityCodeScan.VS2019" Version="5.6.7" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="SmartAnalyzers.CSharpExtensions.Annotations" Version="4.2.11" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="SonarAnalyzer.CSharp" Version="10.20.0.135146" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="SourceLink.Create.CommandLine" Version="2.8.3" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="ToStringWithoutOverrideAnalyzer" Version="0.6.0" PrivateAssets="All" ExcludeAssets="runtime" />
+    <PackageReference Include="xunit.analyzers" Version="1.27.0" PrivateAssets="All" ExcludeAssets="runtime" />
+  </ItemGroup>
+</Project>
diff --git a/src/BuildBot.Discord.Tests/DependencyInjectionTests.cs b/src/BuildBot.Discord.Tests/DependencyInjectionTests.cs
new file mode 100644
index 000000000..8997602d1
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/DependencyInjectionTests.cs
@@ -0,0 +1,83 @@
+using BuildBot.Discord;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Services;
+using BuildBot.ServiceModel.ComponentStatus;
+using Discord;
+using FunFair.Test.Common;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Xunit;
+
+namespace BuildBot.Discord.Tests;
+
+public sealed class DependencyInjectionTests : DependencyInjectionTestsBase
+{
+    private static readonly DiscordBotConfiguration TestConfig = new(
+        token: "test-token",
+        server: "test-server",
+        channel: "test-channel",
+        releaseChannel: "test-release-channel"
+    );
+
+    public DependencyInjectionTests(ITestOutputHelper output)
+        : base(output: output, dependencyInjectionRegistration: Configure) { }
+
+    private static IServiceCollection Configure(IServiceCollection services)
+    {
+        return services.AddDiscord(TestConfig);
+    }
+
+    [Fact]
+    public void DiscordBotMustBeRegisteredAsIDiscordBot()
+    {
+        this.RequireService<IDiscordBot>();
+    }
+
+    [Fact]
+    public void DiscordBotMustBeRegisteredAsIComponentStatus()
+    {
+        this.RequireService<IComponentStatus>();
+    }
+
+    [Fact]
+    public void BotMessageChannelMustBeRegistered()
+    {
+        this.RequireService<IMessageChannel<BotMessage>>();
+    }
+
+    [Fact]
+    public void BotReleaseMessageChannelMustBeRegistered()
+    {
+        this.RequireService<IMessageChannel<BotReleaseMessage>>();
+    }
+
+    [Fact]
+    public void BotServiceMustBeRegisteredAsIHostedService()
+    {
+        this.RequireService<IHostedService>();
+    }
+
+    [Fact]
+    public void DiscordRawClientMustBeRegistered()
+    {
+        this.RequireService<IDiscordRawClient>();
+    }
+
+    [Fact]
+    public void DiscordRawClient_WhenDisconnected_LoginStateIsLoggedOut()
+    {
+        IDiscordRawClient client = this.GetService<IDiscordRawClient>();
+        Assert.Equal(expected: LoginState.LoggedOut, actual: client.LoginState);
+    }
+
+    [Fact]
+    public void FindChannel_WhenClientIsDisconnected_ReturnsNull()
+    {
+        IDiscordRawClient client = this.GetService<IDiscordRawClient>();
+        IDiscordChannel? channel = client.FindChannel(
+            serverName: "nonexistent-server",
+            channelName: "nonexistent-channel"
+        );
+        Assert.Null(channel);
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Models/BotMessageTests.cs b/src/BuildBot.Discord.Tests/Models/BotMessageTests.cs
new file mode 100644
index 000000000..1288c2ced
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Models/BotMessageTests.cs
@@ -0,0 +1,37 @@
+using BuildBot.Discord.Models;
+using Discord;
+using FunFair.Test.Common;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Models;
+
+public sealed class BotMessageTests : TestBase
+{
+    [Fact]
+    public void MessageProperty_ReturnsSuppliedBuilder()
+    {
+        EmbedBuilder builder = new();
+        BotMessage msg = new(builder);
+
+        Assert.Same(expected: builder, actual: msg.Message);
+    }
+
+    [Fact]
+    public void TwoInstances_WithSameBuilder_AreEqual()
+    {
+        EmbedBuilder builder = new();
+        BotMessage msg1 = new(builder);
+        BotMessage msg2 = new(builder);
+
+        Assert.Equal(expected: msg1, actual: msg2);
+    }
+
+    [Fact]
+    public void TwoInstances_WithDifferentBuilders_AreNotEqual()
+    {
+        BotMessage msg1 = new(new EmbedBuilder().WithTitle("First Message"));
+        BotMessage msg2 = new(new EmbedBuilder().WithTitle("Second Message"));
+
+        Assert.NotEqual(expected: msg1, actual: msg2);
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Models/BotReleaseMessageTests.cs b/src/BuildBot.Discord.Tests/Models/BotReleaseMessageTests.cs
new file mode 100644
index 000000000..152d977e0
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Models/BotReleaseMessageTests.cs
@@ -0,0 +1,37 @@
+using BuildBot.Discord.Models;
+using Discord;
+using FunFair.Test.Common;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Models;
+
+public sealed class BotReleaseMessageTests : TestBase
+{
+    [Fact]
+    public void MessageProperty_ReturnsSuppliedBuilder()
+    {
+        EmbedBuilder builder = new();
+        BotReleaseMessage msg = new(builder);
+
+        Assert.Same(expected: builder, actual: msg.Message);
+    }
+
+    [Fact]
+    public void TwoInstances_WithSameBuilder_AreEqual()
+    {
+        EmbedBuilder builder = new();
+        BotReleaseMessage msg1 = new(builder);
+        BotReleaseMessage msg2 = new(builder);
+
+        Assert.Equal(expected: msg1, actual: msg2);
+    }
+
+    [Fact]
+    public void TwoInstances_WithDifferentBuilders_AreNotEqual()
+    {
+        BotReleaseMessage msg1 = new(new EmbedBuilder().WithTitle("First Release"));
+        BotReleaseMessage msg2 = new(new EmbedBuilder().WithTitle("Second Release"));
+
+        Assert.NotEqual(expected: msg1, actual: msg2);
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Publishers/DiscordBotMessageNotificationHandlerTests.cs b/src/BuildBot.Discord.Tests/Publishers/DiscordBotMessageNotificationHandlerTests.cs
new file mode 100644
index 000000000..f09458664
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Publishers/DiscordBotMessageNotificationHandlerTests.cs
@@ -0,0 +1,36 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Publishers;
+using Discord;
+using FunFair.Test.Common;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Publishers;
+
+public sealed class DiscordBotMessageNotificationHandlerTests : TestBase
+{
+    [Fact]
+    public async Task Handle_LogsAndPublishesToChannel()
+    {
+        ILogger<DiscordBotMessageNotificationHandler> logger =
+            this.GetTypedLogger<DiscordBotMessageNotificationHandler>();
+        logger.IsEnabled(Arg.Any<LogLevel>()).Returns(true);
+
+        IMessageChannel<BotMessage> channel = GetSubstitute<IMessageChannel<BotMessage>>();
+
+        DiscordBotMessageNotificationHandler handler = new(messageChannel: channel, logger: logger);
+
+        EmbedBuilder builder = new EmbedBuilder().WithTitle("Test Notification");
+        BotMessage notification = new(builder);
+
+        await handler.Handle(notification: notification, cancellationToken: this.CancellationToken());
+
+        logger.Received(1).IsEnabled(LogLevel.Information);
+        await channel
+            .Received(1)
+            .PublishAsync(message: Arg.Any<BotMessage>(), cancellationToken: Arg.Any<CancellationToken>());
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Publishers/DiscordBotReleaseMessageNotificationHandlerTests.cs b/src/BuildBot.Discord.Tests/Publishers/DiscordBotReleaseMessageNotificationHandlerTests.cs
new file mode 100644
index 000000000..c938fef64
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Publishers/DiscordBotReleaseMessageNotificationHandlerTests.cs
@@ -0,0 +1,30 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Publishers;
+using Discord;
+using FunFair.Test.Common;
+using NSubstitute;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Publishers;
+
+public sealed class DiscordBotReleaseMessageNotificationHandlerTests : TestBase
+{
+    [Fact]
+    public async Task Handle_PublishesToChannel()
+    {
+        IMessageChannel<BotReleaseMessage> channel = GetSubstitute<IMessageChannel<BotReleaseMessage>>();
+
+        DiscordBotReleaseMessageNotificationHandler handler = new(channel);
+
+        EmbedBuilder builder = new EmbedBuilder().WithTitle("Release Notification");
+        BotReleaseMessage notification = new(builder);
+
+        await handler.Handle(notification: notification, cancellationToken: this.CancellationToken());
+
+        await channel
+            .Received(1)
+            .PublishAsync(message: Arg.Any<BotReleaseMessage>(), cancellationToken: Arg.Any<CancellationToken>());
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/BotServiceTests.cs b/src/BuildBot.Discord.Tests/Services/BotServiceTests.cs
new file mode 100644
index 000000000..426952ccc
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/BotServiceTests.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord.Models;
+using BuildBot.Discord.Services;
+using Discord;
+using FunFair.Test.Common;
+using NSubstitute;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Services;
+
+public sealed class BotServiceTests : TestBase
+{
+    private static (
+        BotService Service,
+        IDiscordBot Bot,
+        MessageChannel<BotMessage> MessageChannel,
+        MessageChannel<BotReleaseMessage> ReleaseChannel
+    ) CreateService()
+    {
+        IDiscordBot bot = GetSubstitute<IDiscordBot>();
+        bot.StartAsync(Arg.Any<CancellationToken>()).Returns(Task.CompletedTask);
+        bot.StopAsync(Arg.Any<CancellationToken>()).Returns(Task.CompletedTask);
+
+        MessageChannel<BotMessage> messageChannel = new();
+        MessageChannel<BotReleaseMessage> releaseChannel = new();
+
+        BotService service = new(bot: bot, botMessageChannel: messageChannel, botReleaseMessageChannel: releaseChannel);
+
+        return (service, bot, messageChannel, releaseChannel);
+    }
+
+    [Fact]
+    public async Task StartAsync_DelegatesToBot()
+    {
+        (BotService service, IDiscordBot bot, _, _) = CreateService();
+
+        using (service)
+        {
+            await service.StartAsync(this.CancellationToken());
+
+            await bot.Received(1).StartAsync(Arg.Any<CancellationToken>());
+        }
+    }
+
+    [Fact]
+    public async Task StopAsync_DelegatesToBot()
+    {
+        (BotService service, IDiscordBot bot, _, _) = CreateService();
+
+        using (service)
+        {
+            await service.StopAsync(this.CancellationToken());
+
+            await bot.Received(1).StopAsync(Arg.Any<CancellationToken>());
+        }
+    }
+
+    [Fact]
+    public void Dispose_DisposesSubscriptions()
+    {
+        (BotService service, _, _, _) = CreateService();
+
+        service.Dispose();
+    }
+
+    [Fact]
+    public async Task BotMessage_IsForwardedToBot_AfterDelay()
+    {
+        (BotService service, IDiscordBot bot, MessageChannel<BotMessage> messageChannel, _) = CreateService();
+
+        using (service)
+        {
+            EmbedBuilder builder = new EmbedBuilder().WithTitle("Test");
+            BotMessage message = new(builder);
+
+            await messageChannel.PublishAsync(message: message, cancellationToken: this.CancellationToken());
+
+            await Task.Delay(TimeSpan.FromSeconds(2), this.CancellationToken());
+
+            await bot.Received(1)
+                .PublishAsync(builder: Arg.Any<EmbedBuilder>(), cancellationToken: Arg.Any<CancellationToken>());
+        }
+    }
+
+    [Fact]
+    public async Task BotReleaseMessage_IsForwardedToBot_AfterDelay()
+    {
+        (BotService service, IDiscordBot bot, _, MessageChannel<BotReleaseMessage> releaseChannel) = CreateService();
+
+        using (service)
+        {
+            EmbedBuilder builder = new EmbedBuilder().WithTitle("Release");
+            BotReleaseMessage message = new(builder);
+
+            await releaseChannel.PublishAsync(message: message, cancellationToken: this.CancellationToken());
+
+            await Task.Delay(TimeSpan.FromSeconds(2), this.CancellationToken());
+
+            await bot.Received(1)
+                .PublishToReleaseChannelAsync(
+                    builder: Arg.Any<EmbedBuilder>(),
+                    cancellationToken: Arg.Any<CancellationToken>()
+                );
+        }
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/DiscordBotConfigurationTests.cs b/src/BuildBot.Discord.Tests/Services/DiscordBotConfigurationTests.cs
new file mode 100644
index 000000000..cd7bfd17b
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/DiscordBotConfigurationTests.cs
@@ -0,0 +1,60 @@
+using BuildBot.Discord;
+using FunFair.Test.Common;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Services;
+
+public sealed class DiscordBotConfigurationTests : TestBase
+{
+    [Fact]
+    public void Token_ReturnsConstructorValue()
+    {
+        DiscordBotConfiguration config = new(
+            token: "my-token",
+            server: "server",
+            channel: "channel",
+            releaseChannel: "releases"
+        );
+
+        Assert.Equal(expected: "my-token", actual: config.Token);
+    }
+
+    [Fact]
+    public void Server_ReturnsConstructorValue()
+    {
+        DiscordBotConfiguration config = new(
+            token: "token",
+            server: "my-server",
+            channel: "channel",
+            releaseChannel: "releases"
+        );
+
+        Assert.Equal(expected: "my-server", actual: config.Server);
+    }
+
+    [Fact]
+    public void Channel_ReturnsConstructorValue()
+    {
+        DiscordBotConfiguration config = new(
+            token: "token",
+            server: "server",
+            channel: "my-channel",
+            releaseChannel: "releases"
+        );
+
+        Assert.Equal(expected: "my-channel", actual: config.Channel);
+    }
+
+    [Fact]
+    public void ReleaseChannel_ReturnsConstructorValue()
+    {
+        DiscordBotConfiguration config = new(
+            token: "token",
+            server: "server",
+            channel: "channel",
+            releaseChannel: "my-releases"
+        );
+
+        Assert.Equal(expected: "my-releases", actual: config.ReleaseChannel);
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/DiscordBotTests.cs b/src/BuildBot.Discord.Tests/Services/DiscordBotTests.cs
new file mode 100644
index 000000000..4a3b22b02
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/DiscordBotTests.cs
@@ -0,0 +1,429 @@
+using System;
+using System.Threading.Tasks;
+using BuildBot.Discord.Services;
+using BuildBot.ServiceModel.ComponentStatus;
+using Discord;
+using FunFair.Test.Common;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Services;
+
+public sealed class DiscordBotTests : TestBase
+{
+    private static readonly DiscordBotConfiguration Config = new(
+        token: "test-token",
+        server: "test-server",
+        channel: "test-channel",
+        releaseChannel: "test-release-channel"
+    );
+
+    private (IDiscordRawClient Client, ILogger<DiscordBot> Logger, DiscordBot Bot) CreateBot()
+    {
+        IDiscordRawClient client = GetSubstitute<IDiscordRawClient>();
+        ILogger<DiscordBot> logger = this.GetTypedLogger<DiscordBot>();
+        logger.IsEnabled(Arg.Any<LogLevel>()).Returns(true);
+
+        DiscordBot bot = new(client: client, botConfiguration: Config, logger: logger);
+
+        return (client, logger, bot);
+    }
+
+    private (ILogger<DiscordBot> Logger, Func<LogMessage, Task> Handler) CreateBotForLogTests()
+    {
+        IDiscordRawClient client = GetSubstitute<IDiscordRawClient>();
+        ILogger<DiscordBot> logger = this.GetTypedLogger<DiscordBot>();
+        logger.IsEnabled(Arg.Any<LogLevel>()).Returns(true);
+
+        Func<LogMessage, Task>? capturedHandler = null;
+        client
+            .When(x => x.RegisterLogHandler(Arg.Any<Func<LogMessage, Task>>()))
+            .Do(callInfo => capturedHandler = callInfo.Arg<Func<LogMessage, Task>>());
+
+        _ = new DiscordBot(client: client, botConfiguration: Config, logger: logger);
+
+        return (
+            logger,
+            capturedHandler
+                ?? throw new InvalidOperationException("DiscordBot constructor did not call RegisterLogHandler")
+        );
+    }
+
+    [Fact]
+    public void GetStatus_WhenLoggedOut_ReturnsDisconnectedStatus()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        client.LoginState.Returns(LoginState.LoggedOut);
+
+        ServiceStatus status = bot.GetStatus();
+
+        Assert.Equal(expected: "Discord", actual: status.Name);
+        Assert.False(condition: status.Ok, userMessage: "Discord should not be connected when logged out");
+    }
+
+    [Fact]
+    public void GetStatus_WhenLoggedIn_ReturnsConnectedStatus()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        client.LoginState.Returns(LoginState.LoggedIn);
+
+        ServiceStatus status = bot.GetStatus();
+
+        Assert.Equal(expected: "Discord", actual: status.Name);
+        Assert.True(condition: status.Ok, userMessage: "Discord should be connected when logged in");
+    }
+
+    [Fact]
+    public async Task PublishAsync_WhenChannelNotFound_LogsErrorAndReturns()
+    {
+        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
+
+        client
+            .FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>())
+            .Returns((IDiscordChannel?)null);
+
+        await bot.PublishAsync(
+            builder: new EmbedBuilder().WithTitle("Test"),
+            cancellationToken: this.CancellationToken()
+        );
+
+        client.Received(1).FindChannel(serverName: Config.Server, channelName: Config.Channel);
+        logger.Received(1).IsEnabled(LogLevel.Error);
+    }
+
+    [Fact]
+    public async Task PublishToReleaseChannelAsync_WhenChannelNotFound_LogsErrorAndReturns()
+    {
+        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
+
+        client
+            .FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>())
+            .Returns((IDiscordChannel?)null);
+
+        await bot.PublishToReleaseChannelAsync(
+            builder: new EmbedBuilder().WithTitle("Test"),
+            cancellationToken: this.CancellationToken()
+        );
+
+        client.Received(1).FindChannel(serverName: Config.Server, channelName: Config.ReleaseChannel);
+        logger.Received(1).IsEnabled(LogLevel.Error);
+    }
+
+    [Fact]
+    public async Task PublishAsync_WhenChannelFound_SendsMessageAndLogsSuccess()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
+        IDisposable mockTypingState = GetSubstitute<IDisposable>();
+
+        mockChannel.Name.Returns("test-channel");
+        mockChannel.EnterTypingState().Returns(mockTypingState);
+        mockChannel
+            .SendMessageAsync(Arg.Any<Embed>())
+            .Returns(Task.FromResult<(string SentToChannel, string MessageContent)>(("test-channel", string.Empty)));
+
+        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+
+        await bot.PublishAsync(
+            builder: new EmbedBuilder().WithTitle("Test Message"),
+            cancellationToken: this.CancellationToken()
+        );
+
+        await mockChannel.Received(1).SendMessageAsync(Arg.Any<Embed>());
+    }
+
+    [Fact]
+    public async Task PublishToReleaseChannelAsync_WhenChannelFound_SendsMessage()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
+        IDisposable mockTypingState = GetSubstitute<IDisposable>();
+
+        mockChannel.Name.Returns("test-release-channel");
+        mockChannel.EnterTypingState().Returns(mockTypingState);
+        mockChannel
+            .SendMessageAsync(Arg.Any<Embed>())
+            .Returns(
+                Task.FromResult<(string SentToChannel, string MessageContent)>(("test-release-channel", string.Empty))
+            );
+
+        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+
+        await bot.PublishToReleaseChannelAsync(
+            builder: new EmbedBuilder().WithTitle("Release Test"),
+            cancellationToken: this.CancellationToken()
+        );
+
+        await mockChannel.Received(1).SendMessageAsync(Arg.Any<Embed>());
+    }
+
+    [Fact]
+    public async Task PublishAsync_WhenSendFails_WhileLoggedIn_ReconnectsAfterLogout()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
+        IDisposable mockTypingState = GetSubstitute<IDisposable>();
+
+        mockChannel.Name.Returns("test-channel");
+        mockChannel.EnterTypingState().Returns(mockTypingState);
+        mockChannel
+            .SendMessageAsync(Arg.Any<Embed>())
+            .Returns(
+                Task.FromException<(string SentToChannel, string MessageContent)>(
+                    new InvalidOperationException("send failed")
+                )
+            );
+
+        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+        client.LoginState.Returns(LoginState.LoggedIn);
+
+        await bot.PublishAsync(
+            builder: new EmbedBuilder().WithTitle("Test"),
+            cancellationToken: this.CancellationToken()
+        );
+
+        await client.Received(1).LogoutAsync();
+        await client.Received(1).StopAsync();
+        await client.Received(1).LoginAsync(tokenType: TokenType.Bot, token: Config.Token);
+    }
+
+    [Fact]
+    public async Task PublishAsync_WhenSendFails_WhileNotLoggedIn_ReconnectsWithoutLogout()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
+        IDisposable mockTypingState = GetSubstitute<IDisposable>();
+
+        mockChannel.Name.Returns("test-channel");
+        mockChannel.EnterTypingState().Returns(mockTypingState);
+        mockChannel
+            .SendMessageAsync(Arg.Any<Embed>())
+            .Returns(
+                Task.FromException<(string SentToChannel, string MessageContent)>(
+                    new InvalidOperationException("send failed")
+                )
+            );
+
+        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+        client.LoginState.Returns(LoginState.LoggedOut);
+
+        await bot.PublishAsync(
+            builder: new EmbedBuilder().WithTitle("Test"),
+            cancellationToken: this.CancellationToken()
+        );
+
+        await client.DidNotReceive().LogoutAsync();
+        await client.Received(1).LoginAsync(tokenType: TokenType.Bot, token: Config.Token);
+    }
+
+    [Fact]
+    public async Task PublishAsync_WhenReconnectFails_LogsError()
+    {
+        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
+
+        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
+        IDisposable mockTypingState = GetSubstitute<IDisposable>();
+
+        mockChannel.Name.Returns("test-channel");
+        mockChannel.EnterTypingState().Returns(mockTypingState);
+        mockChannel
+            .SendMessageAsync(Arg.Any<Embed>())
+            .Returns(
+                Task.FromException<(string SentToChannel, string MessageContent)>(
+                    new InvalidOperationException("send failed")
+                )
+            );
+
+        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+        client.LoginState.Returns(LoginState.LoggedIn);
+        client.LogoutAsync().Returns(Task.FromException(new InvalidOperationException("logout failed")));
+
+        await bot.PublishAsync(
+            builder: new EmbedBuilder().WithTitle("Test"),
+            cancellationToken: this.CancellationToken()
+        );
+
+        logger.Received(2).IsEnabled(LogLevel.Error);
+    }
+
+    [Fact]
+    public async Task StartAsync_CallsLoginStartAndSetGame()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        await bot.StartAsync(this.CancellationToken());
+
+        await client.Received(1).LoginAsync(tokenType: TokenType.Bot, token: Config.Token);
+        await client.Received(1).StartAsync();
+        await client.Received(1).SetGameAsync(name: "GitHub", streamUrl: null, type: ActivityType.Watching);
+    }
+
+    [Fact]
+    public async Task StopAsync_CallsLogout()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        await bot.StopAsync(this.CancellationToken());
+
+        await client.Received(1).LogoutAsync();
+    }
+
+    [Fact]
+    public async Task LogAsync_Debug_LogsAtDebugLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(new LogMessage(LogSeverity.Debug, source: "Test", message: "Debug message"));
+
+        logger.Received(1).IsEnabled(LogLevel.Debug);
+    }
+
+    [Fact]
+    public async Task LogAsync_Verbose_LogsAtInformationLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(new LogMessage(LogSeverity.Verbose, source: "Test", message: "Verbose message"));
+
+        logger.Received(1).IsEnabled(LogLevel.Information);
+    }
+
+    [Fact]
+    public async Task LogAsync_Info_LogsAtInformationLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(new LogMessage(LogSeverity.Info, source: "Test", message: "Info message"));
+
+        logger.Received(1).IsEnabled(LogLevel.Information);
+    }
+
+    [Fact]
+    public async Task LogAsync_Warning_LogsAtWarningLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(new LogMessage(LogSeverity.Warning, source: "Test", message: "Warning message"));
+
+        logger.Received(1).IsEnabled(LogLevel.Warning);
+    }
+
+    [Fact]
+    public async Task LogAsync_ErrorWithoutException_LogsAtErrorLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(new LogMessage(LogSeverity.Error, source: "Test", message: "Error message"));
+
+        logger.Received(1).IsEnabled(LogLevel.Error);
+    }
+
+    [Fact]
+    public async Task LogAsync_ErrorWithException_LogsAtErrorLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(
+            new LogMessage(
+                LogSeverity.Error,
+                source: "Test",
+                message: "Error message",
+                exception: new InvalidOperationException("test error")
+            )
+        );
+
+        logger.Received(1).IsEnabled(LogLevel.Error);
+    }
+
+    [Fact]
+    public async Task LogAsync_CriticalWithoutException_LogsAtCriticalLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(new LogMessage(LogSeverity.Critical, source: "Test", message: "Critical message"));
+
+        logger.Received(1).IsEnabled(LogLevel.Critical);
+    }
+
+    [Fact]
+    public async Task LogAsync_CriticalWithException_LogsAtCriticalLevel()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(
+            new LogMessage(
+                LogSeverity.Critical,
+                source: "Test",
+                message: "Critical message",
+                exception: new InvalidOperationException("critical error")
+            )
+        );
+
+        logger.Received(1).IsEnabled(LogLevel.Critical);
+    }
+
+    [Fact]
+    public async Task LogAsync_UnknownSeverity_LogsAsCritical()
+    {
+        (ILogger<DiscordBot> logger, Func<LogMessage, Task> handler) = this.CreateBotForLogTests();
+
+        await handler(new LogMessage((LogSeverity)99, source: "Test", message: "Unknown severity message"));
+
+        logger.Received(1).IsEnabled(LogLevel.Critical);
+    }
+
+    [Fact]
+    public async Task PublishAsync_WhenChannelFound_WithNullTitle_SendsMessage()
+    {
+        (IDiscordRawClient client, _, DiscordBot bot) = this.CreateBot();
+
+        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
+        IDisposable mockTypingState = GetSubstitute<IDisposable>();
+
+        mockChannel.Name.Returns("test-channel");
+        mockChannel.EnterTypingState().Returns(mockTypingState);
+        mockChannel
+            .SendMessageAsync(Arg.Any<Embed>())
+            .Returns(Task.FromResult<(string SentToChannel, string MessageContent)>(("test-channel", string.Empty)));
+
+        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+
+        await bot.PublishAsync(builder: new EmbedBuilder(), cancellationToken: this.CancellationToken());
+
+        await mockChannel.Received(1).SendMessageAsync(Arg.Any<Embed>());
+    }
+
+    [Fact]
+    public async Task PublishAsync_WhenSendFails_WithNullTitle_LogsErrorAndReconnects()
+    {
+        (IDiscordRawClient client, ILogger<DiscordBot> logger, DiscordBot bot) = this.CreateBot();
+
+        IDiscordChannel mockChannel = GetSubstitute<IDiscordChannel>();
+        IDisposable mockTypingState = GetSubstitute<IDisposable>();
+
+        mockChannel.Name.Returns("test-channel");
+        mockChannel.EnterTypingState().Returns(mockTypingState);
+        mockChannel
+            .SendMessageAsync(Arg.Any<Embed>())
+            .Returns(
+                Task.FromException<(string SentToChannel, string MessageContent)>(
+                    new InvalidOperationException("send failed")
+                )
+            );
+
+        client.FindChannel(serverName: Arg.Any<string>(), channelName: Arg.Any<string>()).Returns(mockChannel);
+        client.LoginState.Returns(LoginState.LoggedOut);
+
+        await bot.PublishAsync(builder: new EmbedBuilder(), cancellationToken: this.CancellationToken());
+
+        logger.Received(1).IsEnabled(LogLevel.Error);
+        await client.DidNotReceive().LogoutAsync();
+    }
+}
diff --git a/src/BuildBot.Discord.Tests/Services/MessageChannelTests.cs b/src/BuildBot.Discord.Tests/Services/MessageChannelTests.cs
new file mode 100644
index 000000000..97c80df71
--- /dev/null
+++ b/src/BuildBot.Discord.Tests/Services/MessageChannelTests.cs
@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BuildBot.Discord;
+using BuildBot.Discord.Services;
+using FunFair.Test.Common;
+using Xunit;
+
+namespace BuildBot.Discord.Tests.Services;
+
+public sealed class MessageChannelTests : TestBase
+{
+    [Fact]
+    public async Task PublishAsync_ThenReadAllAsync_ReturnsPublishedMessage()
+    {
+        MessageChannel<string> channel = new();
+        const string testMessage = "hello";
+
+        await channel.PublishAsync(message: testMessage, cancellationToken: this.CancellationToken());
+
+        using CancellationTokenSource cts = new();
+        cts.CancelAfter(5000);
+
+        await using IAsyncEnumerator<string> enumerator = channel.ReadAllAsync(cts.Token).GetAsyncEnumerator(cts.Token);
+        bool hasValue = await enumerator.MoveNextAsync();
+
+        Assert.True(condition: hasValue, userMessage: "Expected to receive a published message");
+
+        string received = enumerator.Current;
+
+        Assert.Equal(expected: testMessage, actual: received);
+    }
+}
diff --git a/src/BuildBot.Discord/DiscordSetup.cs b/src/BuildBot.Discord/DiscordSetup.cs
index cc9c3ae36..1eee85b41 100644
--- a/src/BuildBot.Discord/DiscordSetup.cs
+++ b/src/BuildBot.Discord/DiscordSetup.cs
@@ -10,6 +10,7 @@ public static IServiceCollection AddDiscord(this IServiceCollection services, Di
     {
         return services
             .AddSingleton(discordConfig)
+            .AddSingleton<IDiscordRawClient>(_ => new DiscordSocketClientAdapter())
             .AddSingleton<DiscordBot>()
             .AddSingleton<IDiscordBot>(s => s.GetRequiredService<DiscordBot>())
             .AddSingleton<IComponentStatus>(s => s.GetRequiredService<DiscordBot>())
diff --git a/src/BuildBot.Discord/IDiscordBot.cs b/src/BuildBot.Discord/IDiscordBot.cs
index 54cb69eac..a2883eca6 100644
--- a/src/BuildBot.Discord/IDiscordBot.cs
+++ b/src/BuildBot.Discord/IDiscordBot.cs
@@ -6,6 +6,10 @@ namespace BuildBot.Discord;
 
 public interface IDiscordBot
 {
+    Task StartAsync(CancellationToken cancellationToken);
+
+    Task StopAsync(CancellationToken cancellationToken);
+
     ValueTask PublishAsync(EmbedBuilder builder, CancellationToken cancellationToken);
 
     ValueTask PublishToReleaseChannelAsync(EmbedBuilder builder, CancellationToken cancellationToken);
diff --git a/src/BuildBot.Discord/Services/BotService.cs b/src/BuildBot.Discord/Services/BotService.cs
index 25a5be623..721bf18e7 100644
--- a/src/BuildBot.Discord/Services/BotService.cs
+++ b/src/BuildBot.Discord/Services/BotService.cs
@@ -11,14 +11,14 @@ namespace BuildBot.Discord.Services;
 public sealed class BotService : IHostedService, IDisposable
 {
     private static readonly TimeSpan InterMessageDelay = TimeSpan.FromSeconds(1);
-    private readonly DiscordBot _bot;
+    private readonly IDiscordBot _bot;
     private readonly IMessageChannel<BotMessage> _botMessageChannel;
     private readonly IMessageChannel<BotReleaseMessage> _botReleaseMessageChannel;
     private readonly IDisposable _messageSubscription;
     private readonly IDisposable _releaseMessageSubscription;
 
     public BotService(
-        DiscordBot bot,
+        IDiscordBot bot,
         IMessageChannel<BotMessage> botMessageChannel,
         IMessageChannel<BotReleaseMessage> botReleaseMessageChannel
     )
@@ -56,12 +56,12 @@ public void Dispose()
 
     public Task StartAsync(CancellationToken cancellationToken)
     {
-        return this._bot.StartAsync();
+        return this._bot.StartAsync(cancellationToken);
     }
 
     public Task StopAsync(CancellationToken cancellationToken)
     {
-        return this._bot.StopAsync();
+        return this._bot.StopAsync(cancellationToken);
     }
 
     private ValueTask PublishMessageAsync(BotMessage message, in CancellationToken cancellationToken)
diff --git a/src/BuildBot.Discord/Services/DiscordBot.cs b/src/BuildBot.Discord/Services/DiscordBot.cs
index 438254a42..3da7918db 100644
--- a/src/BuildBot.Discord/Services/DiscordBot.cs
+++ b/src/BuildBot.Discord/Services/DiscordBot.cs
@@ -1,12 +1,9 @@
 using System;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using BuildBot.Discord.Services.LoggingExtensions;
 using BuildBot.ServiceModel.ComponentStatus;
 using Discord;
-using Discord.Rest;
-using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
 
 namespace BuildBot.Discord.Services;
@@ -15,24 +12,16 @@ public sealed class DiscordBot : IDiscordBot, IComponentStatus
 {
     private static readonly TimeSpan TypingDelay = TimeSpan.FromSeconds(2);
     private readonly DiscordBotConfiguration _botConfiguration;
-    private readonly DiscordSocketClient _client;
+    private readonly IDiscordRawClient _client;
     private readonly ILogger<DiscordBot> _logger;
-
     private readonly SemaphoreSlim _semaphore = new(1);
 
-    public DiscordBot(DiscordBotConfiguration botConfiguration, ILogger<DiscordBot> logger)
+    public DiscordBot(IDiscordRawClient client, DiscordBotConfiguration botConfiguration, ILogger<DiscordBot> logger)
     {
-        this._logger = logger;
-        this._client = new(
-            new()
-            {
-                GatewayIntents =
-                    GatewayIntents.Guilds | GatewayIntents.GuildMessageTyping | GatewayIntents.GuildMessages,
-            }
-        );
+        this._client = client;
         this._botConfiguration = botConfiguration;
-
-        this._client.Log += this.LogAsync;
+        this._logger = logger;
+        this._client.RegisterLogHandler(this.LogAsync);
     }
 
     private static EmbedAuthorBuilder Author { get; } =
@@ -48,9 +37,9 @@ public ServiceStatus GetStatus()
 
     public async ValueTask PublishAsync(EmbedBuilder builder, CancellationToken cancellationToken)
     {
-        SocketTextChannel? socketTextChannel = this.GetChannel(this._botConfiguration.Channel);
+        IDiscordChannel? channel = this.GetChannel(this._botConfiguration.Channel);
 
-        if (socketTextChannel is null)
+        if (channel is null)
         {
             this._logger.LogDiscordChannelNotFound(
                 channelName: this._botConfiguration.Channel,
@@ -60,18 +49,14 @@ public async ValueTask PublishAsync(EmbedBuilder builder, CancellationToken canc
             return;
         }
 
-        await this.PublishCommonAsync(
-            builder: builder,
-            socketTextChannel: socketTextChannel,
-            cancellationToken: cancellationToken
-        );
+        await this.PublishCommonAsync(builder: builder, channel: channel, cancellationToken: cancellationToken);
     }
 
     public async ValueTask PublishToReleaseChannelAsync(EmbedBuilder builder, CancellationToken cancellationToken)
     {
-        SocketTextChannel? socketTextChannel = this.GetChannel(this._botConfiguration.ReleaseChannel);
+        IDiscordChannel? channel = this.GetChannel(this._botConfiguration.ReleaseChannel);
 
-        if (socketTextChannel is null)
+        if (channel is null)
         {
             this._logger.LogDiscordChannelNotFound(
                 channelName: this._botConfiguration.Channel,
@@ -81,29 +66,25 @@ public async ValueTask PublishToReleaseChannelAsync(EmbedBuilder builder, Cancel
             return;
         }
 
-        await this.PublishCommonAsync(
-            builder: builder,
-            socketTextChannel: socketTextChannel,
-            cancellationToken: cancellationToken
-        );
+        await this.PublishCommonAsync(builder: builder, channel: channel, cancellationToken: cancellationToken);
     }
 
     private async ValueTask PublishCommonAsync(
         EmbedBuilder builder,
-        SocketTextChannel socketTextChannel,
+        IDiscordChannel channel,
         CancellationToken cancellationToken
     )
     {
         try
         {
-            this._logger.LogSendingMessage(channelName: socketTextChannel.Name, message: builder.Title);
+            this._logger.LogSendingMessage(channelName: channel.Name, message: builder.Title ?? string.Empty);
 
-            using (socketTextChannel.EnterTypingState())
+            using (channel.EnterTypingState())
             {
                 Embed embed = IncludeStandardParameters(builder);
 
-                RestUserMessage msg = await socketTextChannel.SendMessageAsync(text: string.Empty, embed: embed);
-                this.LogSent(msg);
+                (string sentToChannel, string messageContent) = await channel.SendMessageAsync(embed);
+                this.LogSent(channelName: sentToChannel, content: messageContent);
                 await Task.Delay(delay: TypingDelay, cancellationToken: cancellationToken);
             }
         }
@@ -111,7 +92,7 @@ CancellationToken cancellationToken
         {
             this._logger.FailedToPublishMessage(
                 channelName: this._botConfiguration.Channel,
-                title: builder.Title,
+                title: builder.Title ?? string.Empty,
                 message: exception.Message,
                 exception: exception
             );
@@ -120,9 +101,9 @@ CancellationToken cancellationToken
         }
     }
 
-    private void LogSent(RestUserMessage msg)
+    private void LogSent(string channelName, string content)
     {
-        this._logger.LogSentMessage(channelName: msg.Channel.Name, message: msg.CleanContent);
+        this._logger.LogSentMessage(channelName: channelName, message: content);
     }
 
     private static Embed IncludeStandardParameters(EmbedBuilder builder)
@@ -130,15 +111,9 @@ private static Embed IncludeStandardParameters(EmbedBuilder builder)
         return builder.WithAuthor(Author).Build();
     }
 
-    private SocketTextChannel? GetChannel(string channelName)
+    private IDiscordChannel? GetChannel(string channelName)
     {
-        SocketGuild? guild = this._client.Guilds.FirstOrDefault(predicate: g =>
-            StringComparer.Ordinal.Equals(x: g.Name, y: this._botConfiguration.Server)
-        );
-
-        return guild?.TextChannels.FirstOrDefault(predicate: c =>
-            StringComparer.OrdinalIgnoreCase.Equals(x: c.Name, y: channelName)
-        );
+        return this._client.FindChannel(serverName: this._botConfiguration.Server, channelName: channelName);
     }
 
     private Task LogAsync(LogMessage arg)
@@ -204,20 +179,15 @@ private Task LogDebugAsync(LogMessage arg)
         return Task.CompletedTask;
     }
 
-    public async Task StartAsync()
+    public async Task StartAsync(CancellationToken cancellationToken)
     {
-        // login
         await this._client.LoginAsync(tokenType: TokenType.Bot, token: this._botConfiguration.Token);
-
-        // and start
         await this._client.StartAsync();
-
         await this._client.SetGameAsync(name: "GitHub", streamUrl: null, type: ActivityType.Watching);
     }
 
-    public Task StopAsync()
+    public Task StopAsync(CancellationToken cancellationToken)
     {
-        // and logout
         return this._client.LogoutAsync();
     }
 
@@ -234,9 +204,7 @@ private async ValueTask ReconnectAsync(CancellationToken cancellationToken)
             }
 
             await this._client.LoginAsync(tokenType: TokenType.Bot, token: this._botConfiguration.Token);
-
             await this._client.StartAsync();
-
             await this._client.SetGameAsync(name: "GitHub", streamUrl: null, type: ActivityType.Watching);
         }
         catch (Exception exception)
diff --git a/src/BuildBot.Discord/Services/DiscordChannelAdapter.cs b/src/BuildBot.Discord/Services/DiscordChannelAdapter.cs
new file mode 100644
index 000000000..cf64a6cda
--- /dev/null
+++ b/src/BuildBot.Discord/Services/DiscordChannelAdapter.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Rest;
+using Discord.WebSocket;
+
+namespace BuildBot.Discord.Services;
+
+internal sealed class DiscordChannelAdapter : IDiscordChannel
+{
+    private readonly SocketTextChannel _channel;
+
+    public DiscordChannelAdapter(SocketTextChannel channel)
+    {
+        this._channel = channel;
+    }
+
+    public string Name => this._channel.Name;
+
+    public IDisposable EnterTypingState()
+    {
+        return this._channel.EnterTypingState();
+    }
+
+    public async Task<(string SentToChannel, string MessageContent)> SendMessageAsync(Embed embed)
+    {
+        RestUserMessage msg = await this._channel.SendMessageAsync(text: string.Empty, embed: embed);
+
+        return (msg.Channel.Name, msg.CleanContent);
+    }
+}
diff --git a/src/BuildBot.Discord/Services/DiscordSocketClientAdapter.cs b/src/BuildBot.Discord/Services/DiscordSocketClientAdapter.cs
new file mode 100644
index 000000000..bc7c47ad8
--- /dev/null
+++ b/src/BuildBot.Discord/Services/DiscordSocketClientAdapter.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Discord.WebSocket;
+
+namespace BuildBot.Discord.Services;
+
+internal sealed class DiscordSocketClientAdapter : IDiscordRawClient
+{
+    private readonly DiscordSocketClient _client;
+
+    public DiscordSocketClientAdapter()
+    {
+        this._client = new(
+            new()
+            {
+                GatewayIntents =
+                    GatewayIntents.Guilds | GatewayIntents.GuildMessageTyping | GatewayIntents.GuildMessages,
+            }
+        );
+    }
+
+    public LoginState LoginState => this._client.LoginState;
+
+    public IDiscordChannel? FindChannel(string serverName, string channelName)
+    {
+        SocketGuild? guild = this._client.Guilds.FirstOrDefault(predicate: g =>
+            StringComparer.Ordinal.Equals(x: g.Name, y: serverName)
+        );
+
+        SocketTextChannel? textChannel = guild?.TextChannels.FirstOrDefault(predicate: c =>
+            StringComparer.OrdinalIgnoreCase.Equals(x: c.Name, y: channelName)
+        );
+
+        return textChannel is null ? null : new DiscordChannelAdapter(textChannel);
+    }
+
+    public Task LoginAsync(TokenType tokenType, string token)
+    {
+        return this._client.LoginAsync(tokenType: tokenType, token: token);
+    }
+
+    public Task StartAsync()
+    {
+        return this._client.StartAsync();
+    }
+
+    public Task StopAsync()
+    {
+        return this._client.StopAsync();
+    }
+
+    public Task LogoutAsync()
+    {
+        return this._client.LogoutAsync();
+    }
+
+    public Task SetGameAsync(string name, string? streamUrl, ActivityType type)
+    {
+        return this._client.SetGameAsync(name: name, streamUrl: streamUrl, type: type);
+    }
+
+    public void RegisterLogHandler(Func<LogMessage, Task> handler)
+    {
+        this._client.Log += handler;
+    }
+}
diff --git a/src/BuildBot.Discord/Services/IDiscordChannel.cs b/src/BuildBot.Discord/Services/IDiscordChannel.cs
new file mode 100644
index 000000000..210ea45b2
--- /dev/null
+++ b/src/BuildBot.Discord/Services/IDiscordChannel.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Threading.Tasks;
+using Discord;
+
+namespace BuildBot.Discord.Services;
+
+public interface IDiscordChannel
+{
+    string Name { get; }
+
+    IDisposable EnterTypingState();
+
+    Task<(string SentToChannel, string MessageContent)> SendMessageAsync(Embed embed);
+}
diff --git a/src/BuildBot.Discord/Services/IDiscordRawClient.cs b/src/BuildBot.Discord/Services/IDiscordRawClient.cs
new file mode 100644
index 000000000..c32136598
--- /dev/null
+++ b/src/BuildBot.Discord/Services/IDiscordRawClient.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Threading.Tasks;
+using Discord;
+
+namespace BuildBot.Discord.Services;
+
+public interface IDiscordRawClient
+{
+    LoginState LoginState { get; }
+
+    IDiscordChannel? FindChannel(string serverName, string channelName);
+
+    Task LoginAsync(TokenType tokenType, string token);
+
+    Task StartAsync();
+
+    Task StopAsync();
+
+    Task LogoutAsync();
+
+    Task SetGameAsync(string name, string? streamUrl, ActivityType type);
+
+    void RegisterLogHandler(Func<LogMessage, Task> handler);
+}
diff --git a/src/BuildBot.slnx b/src/BuildBot.slnx
index 8dc5fe85f..11bb2eda9 100644
--- a/src/BuildBot.slnx
+++ b/src/BuildBot.slnx
@@ -13,6 +13,7 @@
   </Folder>
   <Project Path="BuildBot.CloudFormation.Tests/BuildBot.CloudFormation.Tests.csproj" />
   <Project Path="BuildBot.CloudFormation/BuildBot.CloudFormation.csproj" />
+  <Project Path="BuildBot.Discord.Tests/BuildBot.Discord.Tests.csproj" />
   <Project Path="BuildBot.Discord/BuildBot.Discord.csproj" />
   <Project Path="BuildBot.GitHub.Tests/BuildBot.GitHub.Tests.csproj" />
   <Project Path="BuildBot.GitHub/BuildBot.GitHub.csproj" />
diff --git a/src/UnitTests.props b/src/UnitTests.props
index c4cad6d45..db1df56e1 100644
--- a/src/UnitTests.props
+++ b/src/UnitTests.props
@@ -48,9 +48,26 @@
             <_CoverageSettingsLines Include="        &lt;Attribute&gt;^System%5C.CodeDom%5C.Compiler%5C.GeneratedCodeAttribute$&lt;/Attribute&gt;" />
             <_CoverageSettingsLines Include="      &lt;/Exclude&gt;" />
             <_CoverageSettingsLines Include="    &lt;/Attributes&gt;" />
+        </ItemGroup>
+
+        <!-- Add Functions exclude section if any function exclusions are defined -->
+        <ItemGroup Condition="'@(_CoverageExcludedFunctions)' != ''">
+            <_CoverageSettingsLines Include="    &lt;Functions&gt;" />
+            <_CoverageSettingsLines Include="      &lt;Exclude&gt;" />
+        </ItemGroup>
+        <ItemGroup Condition="'@(_CoverageExcludedFunctions)' != ''">
+            <_CoverageSettingsLines Include="        &lt;Function&gt;%(_CoverageExcludedFunctions.Identity)&lt;/Function&gt;" />
+        </ItemGroup>
+        <ItemGroup Condition="'@(_CoverageExcludedFunctions)' != ''">
+            <_CoverageSettingsLines Include="      &lt;/Exclude&gt;" />
+            <_CoverageSettingsLines Include="    &lt;/Functions&gt;" />
+        </ItemGroup>
+
+        <ItemGroup>
             <_CoverageSettingsLines Include="  &lt;/CodeCoverage&gt;" />
             <_CoverageSettingsLines Include="&lt;/Configuration&gt;" />
         </ItemGroup>
+
         <WriteLinesToFile
             File="$(_CoverageSettingsFile)"
             Lines="@(_CoverageSettingsLines)"