hopefully finished with RCon changes.

added more tests.
fixed issues from event changes (there's most definitely still issues related to that)

Plugins/Tests/ClientTests.cs

@@ -1,5 +1,6 @@
 using IW4MAdmin.Application;
 using SharedLibraryCore;
+using SharedLibraryCore.Commands;
 using SharedLibraryCore.Objects;
 using System;
 using System.Collections.Generic;
@@ -14,7 +15,7 @@ namespace Tests
     public class ClientTests
     {
         readonly ApplicationManager Manager;
-        const int TestTimeout = 5000;
+        const int TestTimeout = 10000;
 
         public ClientTests(ManagerFixture fixture)
         {
@@ -40,7 +41,7 @@ namespace Tests
         }
 
         [Fact]
-        public void WarnPlayerShouldSucceed()
+        public void WarnClientShouldSucceed()
         {
             while (!Manager.IsInitialized)
             {
@@ -51,21 +52,31 @@ namespace Tests
 
             Assert.False(client == null, "no client found to warn");
 
-            var warnEvent = client.Warn("test warn", new Player() { ClientId = 1, Level = Player.Permission.Console });
+            var warnEvent = client.Warn("test warn", new Player() { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
             warnEvent.OnProcessed.Wait(TestTimeout);
 
-            Assert.True(client.Warnings == 1 || 
+            Assert.True(client.Warnings == 1 ||
                 warnEvent.Failed, "warning did not get applied");
 
-            warnEvent = client.Warn("test warn", new Player() { ClientId = 1, Level = Player.Permission.Banned });
+            warnEvent = client.Warn("test warn", new Player() { ClientId = 1, Level = Player.Permission.Banned, CurrentServer = client.CurrentServer });
             warnEvent.OnProcessed.Wait(TestTimeout);
 
             Assert.True(warnEvent.FailReason == GameEvent.EventFailReason.Permission &&
                 client.Warnings == 1, "warning was applied without proper permissions");
+
+            // warn clear
+            var warnClearEvent = client.WarnClear(new Player { ClientId = 1, Level = Player.Permission.Banned, CurrentServer = client.CurrentServer });
+
+            Assert.True(warnClearEvent.FailReason == GameEvent.EventFailReason.Permission &&
+                client.Warnings == 1, "warning was removed without proper permissions");
+
+            warnClearEvent = client.WarnClear(new Player { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
+
+            Assert.True(!warnClearEvent.Failed && client.Warnings == 0, "warning was not cleared");
         }
 
         [Fact]
-        public void ReportPlayerShouldSucceed()
+        public void ReportClientShouldSucceed()
         {
             while (!Manager.IsInitialized)
             {
@@ -73,21 +84,21 @@ namespace Tests
             }
 
             var client = Manager.Servers.First().GetPlayersAsList().FirstOrDefault();
-
             Assert.False(client == null, "no client found to report");
 
             // succeed
-            var reportEvent = client.Report("test report", new Player() { ClientId = 1, Level = Player.Permission.Console });
+            var reportEvent = client.Report("test report", new Player() { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
             reportEvent.OnProcessed.Wait(TestTimeout);
 
             Assert.True(!reportEvent.Failed &&
                 client.CurrentServer.Reports.Count(r => r.Target.NetworkId == client.NetworkId) == 1, $"report was not applied [{reportEvent.FailReason.ToString()}]");
 
             // fail
-            reportEvent = client.Report("test report", new Player() { ClientId = 2, Level = Player.Permission.Banned });
+            reportEvent = client.Report("test report", new Player() { ClientId = 1, NetworkId = 1, Level = Player.Permission.Banned, CurrentServer = client.CurrentServer });
 
             Assert.True(reportEvent.FailReason == GameEvent.EventFailReason.Permission &&
-               client.CurrentServer.Reports.Count(r => r.Target.NetworkId == client.NetworkId) == 1, $"report was applied without proper permission");
+               client.CurrentServer.Reports.Count(r => r.Target.NetworkId == client.NetworkId) == 1,
+               $"report was applied without proper permission [{reportEvent.FailReason.ToString()},{ client.CurrentServer.Reports.Count(r => r.Target.NetworkId == client.NetworkId)}]");
 
             // fail
             reportEvent = client.Report("test report", client);
@@ -96,10 +107,146 @@ namespace Tests
                client.CurrentServer.Reports.Count(r => r.Target.NetworkId == client.NetworkId) == 1, $"report was applied to self");
 
             // fail
-            reportEvent = client.Report("test report", new Player() { ClientId = 1, Level = Player.Permission.Console});
+            reportEvent = client.Report("test report", new Player() { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
 
             Assert.True(reportEvent.FailReason == GameEvent.EventFailReason.Exception &&
                client.CurrentServer.Reports.Count(r => r.Target.NetworkId == client.NetworkId) == 1, $"duplicate report was applied");
         }
+
+        [Fact]
+        public void FlagClientShouldSucceed()
+        {
+            while (!Manager.IsInitialized)
+            {
+                Thread.Sleep(100);
+            }
+
+            var client = Manager.Servers.First().GetPlayersAsList().FirstOrDefault();
+            Assert.False(client == null, "no client found to flag");
+
+            var flagEvent = client.Flag("test flag", new Player { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
+            flagEvent.OnProcessed.Wait();
+
+            // succeed 
+            Assert.True(!flagEvent.Failed &&
+                client.Level == Player.Permission.Flagged, $"player is not flagged [{flagEvent.FailReason.ToString()}]");
+            Assert.False(client.ReceivedPenalties.FirstOrDefault(p => p.Offense == "test flag") == null, "flag was not applied");
+
+            flagEvent = client.Flag("test flag", new Player { ClientId = 1, Level = Player.Permission.Banned, CurrentServer = client.CurrentServer });
+            flagEvent.OnProcessed.Wait();
+
+            // fail
+            Assert.True(client.ReceivedPenalties.Count == 1, "flag was applied without permisions");
+
+            flagEvent = client.Flag("test flag", new Player { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
+            flagEvent.OnProcessed.Wait();
+
+            // fail
+            Assert.True(client.ReceivedPenalties.Count == 1, "duplicate flag was applied");
+
+            var unflagEvent = client.Unflag("test unflag", new Player { ClientId = 1, Level = Player.Permission.Banned, CurrentServer = client.CurrentServer });
+            unflagEvent.OnProcessed.Wait();
+
+            // fail
+            Assert.False(client.Level == Player.Permission.User, "user was unflagged without permissions");
+
+            unflagEvent = client.Unflag("test unflag", new Player { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
+            unflagEvent.OnProcessed.Wait();
+
+            // succeed
+            Assert.True(client.Level == Player.Permission.User, "user was not unflagged");
+
+            unflagEvent = client.Unflag("test unflag", new Player { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
+            unflagEvent.OnProcessed.Wait();
+
+            // succeed
+            Assert.True(unflagEvent.FailReason == GameEvent.EventFailReason.Invalid, "user was not flagged");
+        }
+
+        [Fact]
+        void KickClientShouldSucceed()
+        {
+            while (!Manager.IsInitialized)
+            {
+                Thread.Sleep(100);
+            }
+
+            var client = Manager.Servers.First().GetPlayersAsList().FirstOrDefault();
+            Assert.False(client == null, "no client found to kick");
+
+            var kickEvent = client.Kick("test kick", new Player() { ClientId = 1, Level = Player.Permission.Banned, CurrentServer = client.CurrentServer });
+            kickEvent.OnProcessed.Wait();
+
+            Assert.True(kickEvent.FailReason == GameEvent.EventFailReason.Permission, "client was kicked without permission");
+
+            kickEvent = client.Kick("test kick", new Player() { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer });
+            kickEvent.OnProcessed.Wait();
+
+            Assert.True(Manager.Servers.First().GetPlayersAsList().FirstOrDefault(c => c.NetworkId == client.NetworkId) == null, "client was not kicked");
+        }
+
+        [Fact]
+        void TempBanClientShouldSucceed()
+        {
+            while (!Manager.IsInitialized)
+            {
+                Thread.Sleep(100);
+            }
+
+            var client = Manager.Servers.First().GetPlayersAsList().FirstOrDefault();
+            Assert.False(client == null, "no client found to tempban");
+
+            var tbCommand = new CTempBan();
+            tbCommand.ExecuteAsync(new GameEvent()
+            {
+                Origin = new Player() { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer },
+                Target = client,
+                Data = "5days test tempban",
+                Type = GameEvent.EventType.Command,
+                Owner = client.CurrentServer
+            }).Wait();
+
+            Assert.True(Manager.GetPenaltyService().GetActivePenaltiesAsync(client.AliasLinkId).Result.Count(p => p.Type == Penalty.PenaltyType.TempBan) == 1,
+                "tempban was not added");
+        }
+
+        [Fact]
+        void BanUnbanClientShouldSucceed()
+        {
+            while (!Manager.IsInitialized)
+            {
+                Thread.Sleep(100);
+            }
+
+            var client = Manager.Servers.First().GetPlayersAsList().FirstOrDefault();
+            Assert.False(client == null, "no client found to ban");
+
+            var banCommand = new CBan();
+            banCommand.ExecuteAsync(new GameEvent()
+            {
+                Origin = new Player() { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer },
+                Target = client,
+                Data = "test ban",
+                Type = GameEvent.EventType.Command,
+                Owner = client.CurrentServer
+            }).Wait();
+
+            Assert.True(Manager.GetPenaltyService().GetActivePenaltiesAsync(client.AliasLinkId).Result.Count(p => p.Type == Penalty.PenaltyType.Ban) == 1,
+                "ban was not added");
+
+            var unbanCommand = new CUnban();
+            unbanCommand.ExecuteAsync(new GameEvent()
+            {
+                Origin = new Player() { ClientId = 1, Level = Player.Permission.Console, CurrentServer = client.CurrentServer },
+                Target = Manager.GetClientService().Find(c => c.NetworkId == client.NetworkId).Result.First().AsPlayer(),
+                Data = "test unban",
+                Type = GameEvent.EventType.Command,
+                Owner = client.CurrentServer
+            }).Wait();
+
+            Assert.True(Manager.GetPenaltyService().GetActivePenaltiesAsync(client.AliasLinkId).Result.Count(p => p.Type == Penalty.PenaltyType.Ban) == 0,
+                "ban was not removed");
+
+        }
     }
 }