bugfixes/enhancements

prevent users from trying to set the console's level to owner
fix issue with setting multiple owners
update/improve unit tests

Tests/ApplicationTests/CommandTests.cs

@@ -3,21 +3,17 @@ using System;
 using SharedLibraryCore.Interfaces;
 using IW4MAdmin;
 using FakeItEasy;
-using IW4MAdmin.Application.EventParsers;
 using System.Linq;
-using IW4MAdmin.Plugins.Stats.Models;
-using IW4MAdmin.Application.Helpers;
-using IW4MAdmin.Plugins.Stats.Config;
-using System.Collections.Generic;
 using SharedLibraryCore.Database.Models;
 using Microsoft.Extensions.DependencyInjection;
-using IW4MAdmin.Plugins.Stats.Helpers;
 using ApplicationTests.Fixtures;
 using System.Threading.Tasks;
 using SharedLibraryCore.Commands;
 using SharedLibraryCore.Configuration;
 using SharedLibraryCore;
 using ApplicationTests.Mocks;
+using SharedLibraryCore.Services;
+using static SharedLibraryCore.Database.Models.EFClient;
 
 namespace ApplicationTests
 {
@@ -28,7 +24,10 @@ namespace ApplicationTests
         private IServiceProvider serviceProvider;
         private ITranslationLookup transLookup;
         private CommandConfiguration cmdConfig;
-        private MockEventHandler mockEventHandler;
+        private ApplicationConfiguration appConfig;
+        private EventHandlerMock mockEventHandler;
+        private ClientService clientService;
+        private IManager manager;
 
         [SetUp]
         public void Setup()
@@ -37,24 +36,31 @@ namespace ApplicationTests
             cmdConfig = new CommandConfiguration();
 
             serviceProvider = new ServiceCollection()
-                .BuildBase(new MockEventHandler(true))
-                .BuildServiceProvider();
+                .BuildBase(new EventHandlerMock(true))
+                .BuildServiceProvider()
+                .SetupTestHooks();
 
-            mockEventHandler = serviceProvider.GetRequiredService<MockEventHandler>();
-
-            var mgr = serviceProvider.GetRequiredService<IManager>();
+            mockEventHandler = serviceProvider.GetRequiredService<EventHandlerMock>();
+            manager = serviceProvider.GetRequiredService<IManager>();
             transLookup = serviceProvider.GetRequiredService<ITranslationLookup>();
+            clientService = serviceProvider.GetRequiredService<ClientService>();
+            appConfig = serviceProvider.GetRequiredService<ApplicationConfiguration>();
 
-            A.CallTo(() => mgr.GetCommands())
+            A.CallTo(() => manager.GetClientService())
+                .Returns(clientService);
+
+            A.CallTo(() => clientService.UpdateLevel(A<Permission>.Ignored, A<EFClient>.Ignored, A<EFClient>.Ignored))
+                .Returns(Task.CompletedTask);
+
+            A.CallTo(() => manager.GetCommands())
                 .Returns(new Command[]
                 {
                     new ImpersonatableCommand(cmdConfig, transLookup),
                     new NonImpersonatableCommand(cmdConfig, transLookup)
                 });
 
-            A.CallTo(() => mgr.AddEvent(A<GameEvent>.Ignored))
-               .Invokes((fakeCall) => mockEventHandler.HandleEvent(mgr, fakeCall.Arguments[0] as GameEvent));
-
+            A.CallTo(() => manager.AddEvent(A<GameEvent>.Ignored))
+               .Invokes((fakeCall) => mockEventHandler.HandleEvent(manager, fakeCall.Arguments[0] as GameEvent));
         }
 
         #region RUNAS
@@ -174,5 +180,343 @@ namespace ApplicationTests
             Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Command && !_event.Failed));
         }
         #endregion
+
+        #region SETLEVEL
+        [Test]
+        public async Task Test_SetLevelFailOnSelf()
+        {
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.Owner;
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = target,
+                Data = "Administrator",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Owner, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission));
+        }
+
+        [Test]
+        public async Task Test_SetLevelFailWithSourcePrivilegeTooLow()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Moderator;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.Administrator;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Administrator",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Administrator, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission));
+        }
+
+        [Test]
+        public async Task Test_SetLevelFailWithExistingOwner_AndOnlyOneOwnerAllowed()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Owner",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.User, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission));
+        }
+
+        [Test]
+        public async Task Test_SetLevelFailWithStepPrivilegesDisabled_AndNonOwner()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.SeniorAdmin;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.Moderator;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Administrator",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Moderator, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission));
+        }
+
+        [Test]
+        public async Task Test_SetLevelFailWithStepPrivilegesEnabled_ButNewPermissionTooHigh()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Moderator;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+            appConfig.EnableSteppedHierarchy = true;
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Moderator",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.User, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission));
+        }
+
+        [Test]
+        public async Task Test_SetLevelFailInvalidGroup()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Owner;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Banned",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.User, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission));
+        }
+
+        [Test]
+        public async Task Test_SetLevelSucceedWithNoExistingOwner_AndOnlyOneOwnerAllowed()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Owner;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(0));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Owner",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Owner, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission && !_event.Failed));
+        }
+
+        [Test]
+        public async Task Test_SetLevelOwnerSucceedWithMultiOwnerAllowed()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Owner;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+            appConfig.EnableMultipleOwners = true;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Owner",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Owner, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission && !_event.Failed));
+        }
+
+        [Test]
+        public async Task Test_SetLevelOwnerSucceedWithMultiOwnerAllowed_AndSteppedPrivileges()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Owner;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+            appConfig.EnableMultipleOwners = true;
+            appConfig.EnableSteppedHierarchy = true;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Owner",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Owner, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission && !_event.Failed));
+        }
+
+        [Test]
+        public async Task Test_SetLevelSucceedWithSteppedPrivileges()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Moderator;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+            appConfig.EnableSteppedHierarchy = true;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Trusted",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Trusted, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission && !_event.Failed));
+        }
+
+        [Test]
+        public async Task Test_SetLevelSucceed()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Owner;
+            var target = ClientGenerators.CreateBasicClient(server);
+            target.Level = Permission.User;
+            appConfig.EnableSteppedHierarchy = true;
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = target,
+                Origin = origin,
+                Data = "Trusted",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.Trusted, target.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission && !_event.Failed));
+        }
+
+        [Test]
+        public async Task Test_SetLevelSucceed_AndFindsIngameClient()
+        {
+            var server = serviceProvider.GetRequiredService<IW4MServer>();
+            var cmd = new SetLevelCommand(cmdConfig, transLookup, logger);
+            var origin = ClientGenerators.CreateBasicClient(server);
+            origin.Level = Permission.Owner;
+            var databaseTarget = ClientGenerators.CreateDatabaseClient();
+            databaseTarget.Level = Permission.Administrator;
+
+            var ingameTarget = ClientGenerators.CreateBasicClient(server);
+            ingameTarget.Level = Permission.Administrator;
+
+            A.CallTo(() => manager.GetActiveClients())
+                .Returns(new[] { ingameTarget });
+
+            A.CallTo(() => clientService.GetOwnerCount())
+                .Returns(Task.FromResult(1));
+
+            var gameEvent = new GameEvent()
+            {
+                Target = databaseTarget,
+                Origin = origin,
+                Data = "User",
+                Owner = server,
+            };
+
+            await cmd.ExecuteAsync(gameEvent);
+
+            Assert.AreEqual(Permission.User, ingameTarget.Level);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission && !_event.Failed));
+        }
+        #endregion
     }
 }

Tests/ApplicationTests/DependencyInjectionExtensions.cs

@@ -3,9 +3,11 @@ using ApplicationTests.Mocks;
 using FakeItEasy;
 using IW4MAdmin;
 using Microsoft.Extensions.DependencyInjection;
+using SharedLibraryCore.Configuration;
 using SharedLibraryCore.Database;
 using SharedLibraryCore.Interfaces;
 using SharedLibraryCore.Services;
+using System;
 
 namespace ApplicationTests
 {
@@ -16,11 +18,11 @@ namespace ApplicationTests
 
             if (eventHandler == null)
             {
-                eventHandler = new MockEventHandler();
-                serviceCollection.AddSingleton(eventHandler as MockEventHandler);
+                eventHandler = new EventHandlerMock();
+                serviceCollection.AddSingleton(eventHandler as EventHandlerMock);
             }
 
-            else if (eventHandler is MockEventHandler mockEventHandler)
+            else if (eventHandler is EventHandlerMock mockEventHandler)
             {
                 serviceCollection.AddSingleton(mockEventHandler);
             }
@@ -42,7 +44,10 @@ namespace ApplicationTests
                 .AddSingleton<DataFileLoader>()
                 .AddSingleton(A.Fake<ClientService>())
                 .AddSingleton(A.Fake<IGameLogReaderFactory>())
-                .AddSingleton(eventHandler);
+                .AddSingleton(eventHandler)
+                .AddSingleton(ConfigurationGenerators.CreateApplicationConfiguration())
+                .AddSingleton(ConfigurationGenerators.CreateCommandConfiguration())
+                .AddSingleton<IConfigurationHandler<ApplicationConfiguration>, ApplicationConfigurationHandlerMock>();
 
             serviceCollection.AddSingleton(_sp => new IW4MServer(_sp.GetRequiredService<IManager>(), ConfigurationGenerators.CreateServerConfiguration(),
                 _sp.GetRequiredService<ITranslationLookup>(), _sp.GetRequiredService<IRConConnectionFactory>(), _sp.GetRequiredService<IGameLogReaderFactory>())
@@ -52,5 +57,14 @@ namespace ApplicationTests
 
             return serviceCollection;
         }
+
+        public static IServiceProvider SetupTestHooks(this IServiceProvider serviceProvider)
+        {
+            var mgr = serviceProvider.GetRequiredService<IManager>();
+            A.CallTo(() => mgr.GetApplicationSettings())
+                .Returns(serviceProvider.GetRequiredService<IConfigurationHandler<ApplicationConfiguration>>());
+
+            return serviceProvider;
+        }
     }
 }

Tests/ApplicationTests/Fixtures/ConfigurationGenerators.cs

@@ -18,5 +18,7 @@ namespace ApplicationTests.Fixtures
                 Say = "say"
             }
         };
+        public static ApplicationConfiguration CreateApplicationConfiguration() => new ApplicationConfiguration() { Servers = new[] { CreateServerConfiguration() } };
+        public static CommandConfiguration CreateCommandConfiguration() => new CommandConfiguration();
     }
 }

Tests/ApplicationTests/IW4MServerTests.cs

@@ -25,7 +25,8 @@ namespace ApplicationTests
         private IManager fakeManager;
         private IRConConnection fakeRConConnection;
         private IRConParser fakeRConParser;
-        private MockEventHandler mockEventHandler;
+        private EventHandlerMock mockEventHandler;
+        private ApplicationConfiguration appConfig;
 
         [SetUp]
         public void Setup()
@@ -36,7 +37,8 @@ namespace ApplicationTests
             fakeManager = serviceProvider.GetRequiredService<IManager>();
             fakeRConConnection = serviceProvider.GetRequiredService<IRConConnection>();
             fakeRConParser = serviceProvider.GetRequiredService<IRConParser>();
-            mockEventHandler = serviceProvider.GetRequiredService<MockEventHandler>();
+            mockEventHandler = serviceProvider.GetRequiredService<EventHandlerMock>();
+            appConfig = serviceProvider.GetRequiredService<ApplicationConfiguration>();
 
             var rconConnectionFactory = serviceProvider.GetRequiredService<IRConConnectionFactory>();
 
@@ -517,12 +519,7 @@ namespace ApplicationTests
         {
             var server = serviceProvider.GetService<IW4MServer>();
             var fakeConfigHandler = A.Fake<IConfigurationHandler<ApplicationConfiguration>>();
-
-            A.CallTo(() => fakeManager.GetApplicationSettings())
-                .Returns(fakeConfigHandler);
-
-            A.CallTo(() => fakeConfigHandler.Configuration())
-                .Returns(new ApplicationConfiguration() { IgnoreServerConnectionLost = true });
+            appConfig.IgnoreServerConnectionLost = true;
 
             A.CallTo(() => fakeRConParser.GetStatusAsync(A<IRConConnection>.Ignored))
                 .ThrowsAsync(new NetworkException("err"));
@@ -535,7 +532,6 @@ namespace ApplicationTests
 
             A.CallTo(() => fakeLogger.WriteError(A<string>.Ignored))
               .MustNotHaveHappened();
-            Assert.IsEmpty(mockEventHandler.Events);
         }
 
         [Test]
@@ -544,12 +540,6 @@ namespace ApplicationTests
             var server = serviceProvider.GetService<IW4MServer>();
             var fakeConfigHandler = A.Fake<IConfigurationHandler<ApplicationConfiguration>>();
 
-            A.CallTo(() => fakeManager.GetApplicationSettings())
-                .Returns(fakeConfigHandler);
-
-            A.CallTo(() => fakeConfigHandler.Configuration())
-                .Returns(new ApplicationConfiguration() { IgnoreServerConnectionLost = false });
-
             A.CallTo(() => fakeRConParser.GetStatusAsync(A<IRConConnection>.Ignored))
                 .ThrowsAsync(new NetworkException("err"));
 
@@ -568,7 +558,7 @@ namespace ApplicationTests
             A.CallTo(() => fakeLogger.WriteError(A<string>.Ignored))
                 .MustHaveHappenedOnceExactly();
 
-            Assert.IsNotEmpty(mockEventHandler.Events);
+            Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ConnectionLost));
             Assert.AreEqual("err", (mockEventHandler.Events[0].Extra as NetworkException).Message);
         }
     }

Tests/ApplicationTests/Mocks/ApplicationConfigurationHandlerMock.cs

@@ -0,0 +1,36 @@
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Interfaces;
+using System;
+using System.Threading.Tasks;
+
+namespace ApplicationTests.Mocks
+{
+    class ApplicationConfigurationHandlerMock : IConfigurationHandler<ApplicationConfiguration>
+    {
+        private readonly ApplicationConfiguration _appConfig;
+
+        public ApplicationConfigurationHandlerMock(ApplicationConfiguration configuration)
+        {
+            _appConfig = configuration;
+        }
+
+        public string FileName => "";
+
+        public void Build()
+        {
+            
+        }
+
+        public ApplicationConfiguration Configuration() => _appConfig;
+
+        public Task Save()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Set(ApplicationConfiguration config)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Tests/ApplicationTests/Mocks/EventHandlerMock.cs

@@ -4,12 +4,12 @@ using System.Collections.Generic;
 
 namespace ApplicationTests.Mocks
 {
-    class MockEventHandler : IEventHandler
+    class EventHandlerMock : IEventHandler
     {
         public IList<GameEvent> Events = new List<GameEvent>();
         private readonly bool _autoExecute;
 
-        public MockEventHandler(bool autoExecute = false)
+        public EventHandlerMock(bool autoExecute = false)
         {
             _autoExecute = autoExecute;
         }

Tests/ApplicationTests/PluginTests.cs

@@ -2,6 +2,7 @@
 using ApplicationTests.Mocks;
 using FakeItEasy;
 using IW4MAdmin;
+using IW4MAdmin.Application.Factories;
 using IW4MAdmin.Application.Misc;
 using Microsoft.Extensions.DependencyInjection;
 using NUnit.Framework;
@@ -24,14 +25,16 @@ namespace ApplicationTests
         private static string PLUGIN_DIR = @"X:\IW4MAdmin\Plugins\ScriptPlugins";
         private IServiceProvider serviceProvider;
         private IManager fakeManager;
-        private MockEventHandler mockEventHandler;
+        private EventHandlerMock mockEventHandler;
 
         [SetUp]
         public void Setup()
         {
-            serviceProvider = new ServiceCollection().BuildBase().BuildServiceProvider();
+            serviceProvider = new ServiceCollection().BuildBase()
+                .AddSingleton<IScriptCommandFactory, ScriptCommandFactory>()
+                .BuildServiceProvider();
             fakeManager = serviceProvider.GetRequiredService<IManager>();
-            mockEventHandler = serviceProvider.GetRequiredService<MockEventHandler>();
+            mockEventHandler = serviceProvider.GetRequiredService<EventHandlerMock>();
 
             var rconConnectionFactory = serviceProvider.GetRequiredService<IRConConnectionFactory>();
 
@@ -62,7 +65,7 @@ namespace ApplicationTests
             A.CallTo(() => fakeManager.GetClientService())
                 .Returns(fakeClientService);
 
-            await plugin.Initialize(serviceProvider.GetRequiredService<IManager>());
+            await plugin.Initialize(serviceProvider.GetRequiredService<IManager>(), serviceProvider.GetRequiredService<IScriptCommandFactory>());
 
             var gameEvent = new GameEvent()
             {

Tests/ApplicationTests/StatsTests.cs

@@ -22,14 +22,17 @@ namespace ApplicationTests
     {
         ILogger logger;
         private IServiceProvider serviceProvider;
+        private IConfigurationHandlerFactory handlerFactory;
 
         [SetUp]
         public void Setup()
         {
             logger = A.Fake<ILogger>();
+            handlerFactory = A.Fake<IConfigurationHandlerFactory>();
 
             serviceProvider = new ServiceCollection()
                 .BuildBase()
+                .AddSingleton<IW4MAdmin.Plugins.Stats.Plugin>()
                 .BuildServiceProvider();
 
             void testLog(string msg) => Console.WriteLine(msg);
@@ -44,9 +47,8 @@ namespace ApplicationTests
         public void TestKDR()
         {
             var mgr = A.Fake<IManager>();
-            var handlerFactory = A.Fake<IConfigurationHandlerFactory>();
             var config = A.Fake<IConfigurationHandler<StatsConfiguration>>();
-            var plugin = new IW4MAdmin.Plugins.Stats.Plugin(handlerFactory, null);
+            var plugin = serviceProvider.GetRequiredService<IW4MAdmin.Plugins.Stats.Plugin>();
 
             A.CallTo(() => config.Configuration())
                 .Returns(new StatsConfiguration()