Use strong typed errors instead of strings

ArmaForces.Arma.Server.Tests/Features/Servers/DedicatedServerTests.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using ArmaForces.Arma.Server.Common.Errors;
 using ArmaForces.Arma.Server.Config;
 using ArmaForces.Arma.Server.Exceptions;
 using ArmaForces.Arma.Server.Features.Keys;
@@ -42,7 +43,7 @@ public DedicatedServerTests()
 
             _modsetConfigMock
                 .Setup(x => x.CopyConfigFiles())
-                .Returns(Result.Success);
+                .Returns(UnitResult.Success<IError>);
         }
 
         [Fact]
@@ -116,7 +117,7 @@ public void Start_ServerIsRunning_ThrowsServerRunningException()
             var armaProcessMock = new Mock<IArmaProcess>();
             armaProcessMock
                 .Setup(x => x.Start())
-                .Returns(Result.Success);
+                .Returns(UnitResult.Success<IError>());
             armaProcessMock
                 .Setup(x => x.IsStopped)
                 .Returns(false);
@@ -151,7 +152,7 @@ private static Mock<IArmaProcess> CreateArmaProcessMock(bool isServer = false)
 
             armaProcessMock
                 .Setup(x => x.Start())
-                .Returns(Result.Success);
+                .Returns(UnitResult.Success<IError>());
             armaProcessMock
                 .Setup(x => x.IsStopped)
                 .Returns(true);

ArmaForces.Arma.Server.Tests/Helpers/Extensions/ResultAssertionExtensions.cs

@@ -1,12 +1,13 @@
-using CSharpFunctionalExtensions;
+using ArmaForces.Arma.Server.Common.Errors;
+using CSharpFunctionalExtensions;
 using FluentAssertions;
 using FluentAssertions.Execution;
 
 namespace ArmaForces.Arma.Server.Tests.Helpers.Extensions
 {
     public static class ResultAssertionExtensions
     {
-        public static void ShouldBeSuccess(this Result result)
+        public static void ShouldBeSuccess<TError>(this UnitResult<TError> result)
         {
             using (new AssertionScope())
             {
@@ -19,12 +20,39 @@ public static void ShouldBeSuccess(this Result result)
             }
         }
 
-        public static void ShouldBeSuccess<T>(this Result<T> result)
+        public static void ShouldBeFailure<TError>(this UnitResult<TError> result, TError expectedError)
+        {
+            using (new AssertionScope())
+            {
+                result.IsFailure.Should().BeTrue();
+
+                if (result.IsFailure)
+                {
+                    result.Error.Should().BeEquivalentTo(expectedError);
+                }
+            }
+        }
+
+        public static void ShouldBeFailure<TError>(this UnitResult<TError> result, string expectedErrorMessage)
+            where TError: IError
+        {
+            using (new AssertionScope())
+            {
+                result.IsFailure.Should().BeTrue();
+
+                if (result.IsFailure)
+                {
+                    result.Error.Message.Should().BeEquivalentTo(expectedErrorMessage);
+                }
+            }
+        }
+
+        public static void ShouldBeSuccess<T, E>(this Result<T, E> result)
         {
             result.IsSuccess.Should().BeTrue();
         }
 
-        public static void ShouldBeSuccess<T>(this Result<T> result, T expectedValue)
+        public static void ShouldBeSuccess<T, E>(this Result<T, E> result, T expectedValue)
         {
             using (new AssertionScope())
             {
@@ -41,28 +69,29 @@ public static void ShouldBeSuccess<T>(this Result<T> result, T expectedValue)
             }
         }
 
-        public static void ShouldBeFailure(this Result result, string expectedErrorMessage)
+        public static void ShouldBeFailure<T, E>(this Result<T, E> result, string expectedErrorMessage)
+            where E : IError
         {
             using (new AssertionScope())
             {
                 result.IsFailure.Should().BeTrue();
 
                 if (result.IsFailure)
                 {
-                    result.Error.Should().BeEquivalentTo(expectedErrorMessage);
+                    result.Error.Message.Should().BeEquivalentTo(expectedErrorMessage);
                 }
             }
         }
 
-        public static void ShouldBeFailure<T>(this Result<T> result, string expectedErrorMessage)
+        public static void ShouldBeFailure<T, E>(this Result<T, E> result, E expectedError)
         {
             using (new AssertionScope())
             {
                 result.IsFailure.Should().BeTrue();
 
                 if (result.IsFailure)
                 {
-                    result.Error.Should().BeEquivalentTo(expectedErrorMessage);
+                    result.Error.Should().BeEquivalentTo(expectedError);
                 }
             }
         }

ArmaForces.Arma.Server.Tests/Helpers/TestDedicatedServer.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using ArmaForces.Arma.Server.Common.Errors;
 using ArmaForces.Arma.Server.Features.Modsets;
 using ArmaForces.Arma.Server.Features.Processes;
 using ArmaForces.Arma.Server.Features.Servers;
@@ -45,27 +46,27 @@ public async Task<ServerStatus> GetServerStatusAsync(CancellationToken cancellat
             return new ServerStatus();
         }
 
-        public Result Start()
+        public UnitResult<IError> Start()
         {
-            if (!IsServerStopped) return Result.Failure("Server already running.");
+            if (!IsServerStopped) return new Error("Server already running.", TestErrorCode.ServerAlreadyRunning);
 
             IsServerStopped = false;
-            return Result.Success();
+            return UnitResult.Success<IError>();
         }
 
-        public async Task<Result> Shutdown()
+        public async Task<UnitResult<IError>> Shutdown()
         {
-            if (IsServerStopped) return Result.Failure("Server not running.");
+            if (IsServerStopped) return new Error("Server not running.", ManagerErrorCode.ServerStopped);
 
             IsServerStopped = true;
-            return Result.Success();
+            return UnitResult.Success<IError>();
         }
 
-        public Result AddAndStartHeadlessClients(IEnumerable<IArmaProcess> headlessClients)
-            => Result.Success();
+        public UnitResult<IError> AddAndStartHeadlessClients(IEnumerable<IArmaProcess> headlessClients)
+            => UnitResult.Success<IError>();
 
-        public Task<Result> RemoveHeadlessClients(int headlessClientsToRemove)
-            => Task.FromResult(Result.Success());
+        public Task<UnitResult<IError>> RemoveHeadlessClients(int headlessClientsToRemove)
+            => Task.FromResult(UnitResult.Success<IError>());
 
         public event Func<IDedicatedServer, Task> OnServerShutdown = null!;
 

ArmaForces.Arma.Server.Tests/Helpers/TestErrorCode.cs

@@ -0,0 +1,15 @@
+using ArmaForces.Arma.Server.Common.Errors;
+
+namespace ArmaForces.Arma.Server.Tests.Helpers;
+
+public class TestErrorCode : IErrorCode
+{
+    public int? Value { get; init;  }
+
+    public bool Is<T>(T value)
+    {
+        throw new System.NotImplementedException();
+    }
+
+    public static ErrorCode ServerAlreadyRunning => new();
+}

ArmaForces.Arma.Server/Common/Errors/Error.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Net;
+using CSharpFunctionalExtensions;
+
+namespace ArmaForces.Arma.Server.Common.Errors;
+
+/// <summary>
+/// Represents details of an error.
+/// </summary>
+public record Error: IError
+{
+    public string Message { get; init; }
+    public IErrorCode Code { get; init; }
+    public IError? InnerError { get; init; }
+
+    /// <summary>
+    /// Creates error instance.
+    /// </summary>
+    /// <param name="message">Message describing error details.</param>
+    /// <param name="code">Code of the error.</param>
+    /// <param name="innerError">Optional inner error.</param>
+    public Error(string message, IErrorCode code, IError? innerError = null)
+    {
+        Message = message;
+        Code = code;
+        InnerError = innerError;
+    }
+
+    public Error(string message, HttpStatusCode statusCode)
+        : this(message, new ErrorCode(statusCode)) { }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="error"></param>
+    /// <returns></returns>
+    public static implicit operator UnitResult<IError>(Error error) => UnitResult.Failure<IError>(error);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    /// <exception cref="NotImplementedException"></exception>
+    public ICombine Combine(ICombine value)
+    {
+        throw new NotImplementedException();
+    }
+}

ArmaForces.Arma.Server/Common/Errors/ErrorCode.cs

@@ -0,0 +1,34 @@
+using System.Net;
+
+namespace ArmaForces.Arma.Server.Common.Errors;
+
+public class ErrorCode : IErrorCode
+{
+    public HttpStatusCode? HttpStatusCode { get; } = null;
+
+    public virtual int? Value => (int?) HttpStatusCode;
+
+    public ErrorCode()
+    {
+    }
+
+    public ErrorCode(HttpStatusCode httpStatusCode)
+    {
+        HttpStatusCode = httpStatusCode;
+    }
+
+    public bool Is<T>(T value) => value switch 
+    {
+        HttpStatusCode httpStatusCode => httpStatusCode == HttpStatusCode,
+        int intValue => Value == intValue,
+        _ => false
+    };
+
+    public override string ToString() => HttpStatusCode.ToString() ?? "Unknown";
+
+    public static implicit operator ErrorCode(HttpStatusCode httpStatusCode) => new(httpStatusCode);
+
+    public static bool operator ==(ErrorCode errorCode, HttpStatusCode httpStatusCode) => errorCode.HttpStatusCode == httpStatusCode;
+
+    public static bool operator !=(ErrorCode errorCode, HttpStatusCode httpStatusCode) => !(errorCode == httpStatusCode);
+}

ArmaForces.Arma.Server/Common/Errors/IError.cs

@@ -0,0 +1,19 @@
+using CSharpFunctionalExtensions;
+
+namespace ArmaForces.Arma.Server.Common.Errors;
+
+public interface IError : ICombine
+{
+    public string Message { get; init; }
+
+    public IErrorCode Code { get; init; }
+
+    public IError? InnerError { get; init; }
+}
+
+public interface IErrorCode
+{
+    public int? Value { get; }
+
+    public bool Is<T>(T value);
+}

ArmaForces.Arma.Server/Config/IConfig.cs

@@ -1,4 +1,5 @@
-using CSharpFunctionalExtensions;
+using ArmaForces.Arma.Server.Common.Errors;
+using CSharpFunctionalExtensions;
 
 namespace ArmaForces.Arma.Server.Config {
     public interface IConfig {
@@ -26,6 +27,6 @@ public interface IConfig {
         /// Copies and fills config files.
         /// </summary>
         /// <returns>Result</returns>
-        Result CopyConfigFiles();
+        UnitResult<IError> CopyConfigFiles();
     }
 }

ArmaForces.Arma.Server/Config/ModsetConfig.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using System.IO.Abstractions;
 using System.Text.Json;
+using ArmaForces.Arma.Server.Common.Errors;
 using CSharpFunctionalExtensions;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -46,7 +47,7 @@
             SetProperties();
         }
 
-        public Result CopyConfigFiles()
+        public UnitResult<IError> CopyConfigFiles()
         {
             return _serverConfig.CopyConfigFiles()
                 .Bind(GetOrCreateModsetConfigDir)
@@ -70,7 +71,7 @@
             {
                 var modsetConfigModel =
                     JsonSerializer.Deserialize<ConfigSimpleModel>(_fileSystem.File.ReadAllText(ConfigJson));
                 if (modsetConfigModel.Server?.Password != null)
                 {
                     return modsetConfigModel.Server.Password;
                 }
@@ -82,14 +83,14 @@
                 JsonSerializer.Deserialize<ConfigSimpleModel>(
                     _fileSystem.File.ReadAllText(_serverConfig.ConfigJson));
 
             return serverConfigModel.Server?.Password ?? string.Empty;
         }
 
         /// <summary>
         /// Prepares config directory and files for current modset
         /// </summary>
         /// <returns>path to modsetConfig</returns>
-        private Result GetOrCreateModsetConfigDir()
+        private UnitResult<IError> GetOrCreateModsetConfigDir()
         {
             // Check for directory if present
             if (!_fileSystem.Directory.Exists(DirectoryPath))
@@ -98,11 +99,11 @@
             }
 
             return _fileSystem.File.Exists(ConfigJson)
-                ? Result.Success()
+                ? UnitResult.Success<IError>()
                 : CreateConfigJson();
         }
 
-        private Result CreateConfigJson()
+        private UnitResult<IError> CreateConfigJson()
         {
             // Set hostName according to pattern
             var sampleServer = new Dictionary<string, string>();
@@ -116,13 +117,13 @@
                 var serializedJson = JsonSerializer.Serialize(sampleJSON, serializerOptions);
                 file.Write(serializedJson);
             }
-            return Result.Success();
+            return UnitResult.Success<IError>();
         }
 
         /// <summary>
         /// Prepares modset cfg files for server to load.
         /// </summary>
-        private Result PrepareModsetConfig()
+        private UnitResult<IError> PrepareModsetConfig()
         {
             // Apply modset config on top of default config
             var modsetConfig = new ConfigurationBuilder()
@@ -135,7 +136,7 @@
             CreateConfigFiles(_serverConfig.BasicCfg, BasicCfg, modsetConfig);
             CreateConfigFiles(_serverConfig.ServerCfg, ServerCfg, modsetConfig);
 
-            return Result.Success();
+            return UnitResult.Success<IError>();
         }
 
         private void CreateConfigFiles(