public async Task Test_RunAsQueuesEventAndResponse()
{
var cmd = serviceProvider.GetRequiredService <RunAsCommand>();
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
target.Level = EFClient.Permission.Moderator;
var origin = ClientGenerators.CreateBasicClient(server);
origin.NetworkId = 100;
origin.Level = EFClient.Permission.Administrator;
var gameEvent = new GameEvent()
{
Target = target,
Origin = origin,
Data = nameof(ImpersonatableCommand),
Owner = server
};
await cmd.ExecuteAsync(gameEvent);
Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell /*&& _event.Target == origin todo: fake the command result*/));
Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Command && !_event.Failed));
}
public async Task Test_SetLevelFailWithStepPrivilegesDisabled_AndNonOwner()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var cmd = serviceProvider.GetRequiredService <SetLevelCommand>();
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));
}
public async Task Test_SetLevelFailWithExistingOwner_AndOnlyOneOwnerAllowed()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var cmd = serviceProvider.GetRequiredService <SetLevelCommand>();
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));
}
public async Task Test_SetLevelFailWithStepPrivilegesEnabled_ButNewPermissionTooHigh()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var cmd = serviceProvider.GetRequiredService <SetLevelCommand>();
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));
}
private void SetupAliases()
{
using var ctx = serviceProvider.GetRequiredService <IDatabaseContextFactory>().CreateContext();
var client = ClientGenerators.CreateDatabaseClient();
var aliases = new[]
{
new EFAlias()
{
LinkId = client.AliasLinkId,
Name = "Test1",
IPAddress = -1,
DateAdded = DateTime.UtcNow.AddMinutes(-1)
},
new EFAlias()
{
LinkId = client.AliasLinkId,
Name = "Test2",
IPAddress = -1,
DateAdded = DateTime.UtcNow
}
};
ctx.Aliases.AddRange(aliases);
ctx.SaveChanges();
}
public async Task Test_SetLevelSucceed()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var cmd = serviceProvider.GetRequiredService <SetLevelCommand>();
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));
}
public async Task Test_SetLevelSucceed_AndFindsIngameClient()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var cmd = serviceProvider.GetRequiredService <SetLevelCommand>();
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));
}
public async Task Test_SetLevelFail_WhenFlagged()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var cmd = serviceProvider.GetRequiredService <SetLevelCommand>();
var origin = ClientGenerators.CreateBasicClient(server);
origin.Level = Permission.Owner;
var target = ClientGenerators.CreateBasicClient(server);
target.Level = Permission.Flagged;
var gameEvent = new GameEvent()
{
Target = target,
Origin = origin,
Data = "Banned",
Owner = server,
};
await cmd.ExecuteAsync(gameEvent);
Assert.AreEqual(Permission.Flagged, target.Level);
Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.ChangePermission));
}
public async Task Test_RunAsFailsOnDisallowedCommand()
{
var cmd = serviceProvider.GetRequiredService <RunAsCommand>();
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
target.Level = EFClient.Permission.Moderator;
var origin = ClientGenerators.CreateBasicClient(server);
origin.NetworkId = 100;
origin.Level = EFClient.Permission.Administrator;
var gameEvent = new GameEvent()
{
Target = target,
Origin = origin,
Owner = server,
Data = nameof(NonImpersonatableCommand)
};
await cmd.ExecuteAsync(gameEvent);
Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
// failed when validating the command
Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Command && _event.FailReason == GameEvent.EventFailReason.Invalid));
}
public async Task Test_ConcurrentCallsToUpdateStatHistoryDoesNotCauseException()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var configHandler = A.Fake <IConfigurationHandler <StatsConfiguration> >();
var mgr = new StatManager(serviceProvider.GetRequiredService <IManager>(), serviceProvider.GetRequiredService <IDatabaseContextFactory>(), configHandler);
var target = ClientGenerators.CreateDatabaseClient();
target.CurrentServer = server;
A.CallTo(() => configHandler.Configuration())
.Returns(new StatsConfiguration()
{
TopPlayersMinPlayTime = 0
});
var dbFactory = serviceProvider.GetRequiredService <IDatabaseContextFactory>();
var db = dbFactory.CreateContext(true);
db.Set <EFServer>().Add(new EFServer()
{
EndPoint = server.EndPoint.ToString()
});
db.Clients.Add(target);
db.SaveChanges();
mgr.AddServer(server);
await mgr.AddPlayer(target);
var stats = target.GetAdditionalProperty <EFClientStatistics>("ClientStats");
await mgr.UpdateStatHistory(target, stats);
}
public void Test_Kick_FailSamePermission()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var origin = ClientGenerators.CreateBasicClient(server);
var result = target.Kick("test", origin);
Assert.True(result.Failed);
Assert.AreEqual(GameEvent.EventFailReason.Permission, result.FailReason);
}
public void Test_Kick_Happy()
{
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var origin = ClientGenerators.CreateBasicClient(server);
origin.Level = EFClient.Permission.Owner;
var result = target.Kick("test", origin);
Assert.False(result.Failed);
Assert.AreEqual(EFClient.ClientState.Disconnecting, target.State);
}
public async Task Test_StatsQueryHelper_Get()
{
var queryHelper = serviceProvider.GetRequiredService <StatsResourceQueryHelper>();
await using var context = contextFactory.CreateContext();
var server = new EFServer()
{
ServerId = 1
};
var stats = new EFClientStatistics()
{
Client = ClientGenerators.CreateBasicClient(null),
SPM = 100,
Server = server
};
var ratingHistory = new EFClientRatingHistory()
{
Client = stats.Client,
Ratings = new[]
{
new EFRating()
{
Ranking = 100,
Server = server,
Newest = true
}
}
};
context.Set <EFClientStatistics>().Add(stats);
context.Set <EFClientRatingHistory>().Add(ratingHistory);
await context.SaveChangesAsync();
var query = new StatsInfoRequest()
{
ClientId = stats.Client.ClientId
};
var result = await queryHelper.QueryResource(query);
Assert.IsNotEmpty(result.Results);
Assert.AreEqual(stats.SPM, result.Results.First().ScorePerMinute);
Assert.AreEqual(ratingHistory.Ratings.First().Ranking, result.Results.First().Ranking);
context.Set <EFClientStatistics>().Remove(stats);
context.Set <EFClientRatingHistory>().Remove(ratingHistory);
context.Set <EFServer>().Remove(server);
await context.SaveChangesAsync();
}
public async Task Test_WarnBroadCastMessageForIngameClient()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var origin = ClientGenerators.CreateBasicClient(server);
await server.Warn("test reason", target, origin);
Assert.IsTrue(mockEventHandler.Events.Any(_event => _event.Type == SharedLibraryCore.GameEvent.EventType.Broadcast));
}
public async Task Test_KickQueuesPredisconnectEvent()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var origin = ClientGenerators.CreateBasicClient(server);
await server.Kick("test reason", target, origin);
Assert.IsTrue(mockEventHandler.Events.Any(_event => _event.Type == SharedLibraryCore.GameEvent.EventType.PreDisconnect && _event.Origin == target));
}
public async Task Test_KickExecutesKickCommand()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var origin = ClientGenerators.CreateBasicClient(server);
await server.Kick("test reason", target, origin);
A.CallTo(() => server.RconParser.ExecuteCommandAsync(A <IRConConnection> .Ignored, "kick"))
.MustHaveHappenedOnceExactly();
}
public async Task Test_WarnCreatesPenalty()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var origin = ClientGenerators.CreateBasicClient(server);
await server.Warn("test reason", target, origin);
A.CallTo(() => fakePenaltyService.Create(A <EFPenalty> .Ignored))
.MustHaveHappenedOnceExactly();
}
public async Task Test_RunAsFailsOnSelf()
{
var cmd = serviceProvider.GetRequiredService <RunAsCommand>();
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var gameEvent = new GameEvent()
{
Target = target,
Origin = target
};
await cmd.ExecuteAsync(gameEvent);
Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Command));
}
public async Task Test_BanQueuesSetLevelEvent()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
var origin = ClientGenerators.CreateBasicClient(server);
await server.Ban("test reason", target, origin);
Assert.IsTrue(mockEventHandler.Events.Any(_event => _event.Type == SharedLibraryCore.GameEvent.EventType.ChangePermission &&
_event.Origin == origin &&
_event.Target == target &&
(EFClient.Permission)_event.Extra == EFClient.Permission.Banned));
}
public async Task Test_StatsController_ClientStats_Happy()
{
var client = ClientGenerators.CreateBasicClient(null);
var query = new StatsInfoRequest
{
ClientId = client.ClientId
};
var queryResult = new ResourceQueryHelperResult <StatsInfoResult>()
{
Results = new[]
{
new StatsInfoResult
{
Deaths = 1,
Kills = 1,
LastPlayed = DateTime.Now,
Performance = 100,
Ranking = 10,
ScorePerMinute = 500,
ServerGame = "IW4",
ServerId = 123,
ServerName = "IW4Host",
TotalSecondsPlayed = 100
}
},
TotalResultCount = 1,
RetrievedResultCount = 1
};
A.CallTo(() => fakeStatsQueryHelper.QueryResource(A <StatsInfoRequest> .Ignored))
.Returns(Task.FromResult(queryResult));
var result = await statsController.ClientStats(query.ClientId.Value);
Assert.IsInstanceOf <OkObjectResult>(result);
var viewResult = (result as OkObjectResult).Value as IEnumerable <StatsInfoResult>;
Assert.NotNull(viewResult);
Assert.AreEqual(queryResult.Results, viewResult);
}
public async Task Test_BanFindsIngameClientToExecuteFor()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var origin = ClientGenerators.CreateBasicClient(server);
var target = ClientGenerators.CreateBasicClient(server, isIngame: false);
var ingameTarget = ClientGenerators.CreateBasicClient(server);
A.CallTo(() => fakeManager.GetActiveClients())
.Returns(new[] { ingameTarget });
await server.Ban("test reason", target, origin);
Assert.IsTrue(mockEventHandler.Events.Any(_event => _event.Target == ingameTarget));
}
public async Task Test_QueryClientResource_SortDirection()
{
var firstClient = ClientGenerators.CreateBasicClient(null);
firstClient.ClientId = 0;
firstClient.NetworkId = -1;
firstClient.LastConnection = DateTime.Now.AddHours(-1);
firstClient.Name = "test";
var secondClient = ClientGenerators.CreateBasicClient(null);
secondClient.ClientId = 0;
secondClient.NetworkId = -2;
secondClient.LastConnection = DateTime.Now;
secondClient.Name = firstClient.Name;
var query = new FindClientRequest()
{
Name = firstClient.Name
};
using var context = contextFactory.CreateContext();
context.Clients.Add(firstClient);
context.Clients.Add(secondClient);
await context.SaveChangesAsync();
var result = await clientService.QueryResource(query);
Assert.IsNotEmpty(result.Results);
Assert.AreEqual(secondClient.NetworkId.ToString("X"), result.Results.First().Xuid);
Assert.AreEqual(firstClient.NetworkId.ToString("X"), result.Results.Last().Xuid);
query.Direction = SortDirection.Ascending;
result = await clientService.QueryResource(query);
Assert.IsNotEmpty(result.Results);
Assert.AreEqual(firstClient.NetworkId.ToString("X"), result.Results.First().Xuid);
Assert.AreEqual(secondClient.NetworkId.ToString("X"), result.Results.Last().Xuid);
context.Clients.Remove(firstClient);
context.Clients.Remove(secondClient);
await context.SaveChangesAsync();
}
public async Task Test_GenericGuidClientIsKicked()
{
var plugin = new ScriptPlugin(serviceProvider.GetRequiredService <ILogger>(), Path.Join(PLUGIN_DIR, "SharedGUIDKick.js"), PLUGIN_DIR);
var server = serviceProvider.GetRequiredService <IW4MServer>();
server.GameName = Server.Game.IW4;
var client = ClientGenerators.CreateBasicClient(server, hasIp: false, clientState: EFClient.ClientState.Connecting);
client.NetworkId = -1168897558496584395;
var databaseClient = ClientGenerators.CreateDatabaseClient(hasIp: false);
databaseClient.NetworkId = client.NetworkId;
var fakeClientService = serviceProvider.GetRequiredService <ClientService>();
A.CallTo(() => fakeClientService.GetUnique(A <long> .Ignored))
.Returns(Task.FromResult(databaseClient));
A.CallTo(() => fakeManager.GetClientService())
.Returns(fakeClientService);
await plugin.Initialize(serviceProvider.GetRequiredService <IManager>(), serviceProvider.GetRequiredService <IScriptCommandFactory>(), serviceProvider.GetRequiredService <IScriptPluginServiceResolver>());
var gameEvent = new GameEvent()
{
Origin = client,
Owner = server,
Type = GameEvent.EventType.PreConnect,
IsBlocking = true
};
await server.ExecuteEvent(gameEvent);
// connect
var e = mockEventHandler.Events[0];
await server.ExecuteEvent(e);
await plugin.OnEventAsync(e, server);
// kick
e = mockEventHandler.Events[1];
await server.ExecuteEvent(e);
}
public async Task Test_UnbanQueuesSetLevelEvent()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
A.CallTo(() => fakePenaltyService.RemoveActivePenalties(A <int> .Ignored))
.Returns(Task.CompletedTask);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var origin = ClientGenerators.CreateBasicClient(server);
var target = ClientGenerators.CreateBasicClient(server);
target.Level = EFClient.Permission.Banned;
target.AliasLink = new EFAliasLink();
await server.Unban("test reason", target, origin);
Assert.IsTrue(mockEventHandler.Events.Any(_event => _event.Type == SharedLibraryCore.GameEvent.EventType.ChangePermission && _event.Target == target));
}
public async Task Test_PrivateMessageAdmins_GameNotSupported()
{
var cmd = serviceProvider.GetRequiredService <PrivateMessageAdminsCommand>();
var server = serviceProvider.GetRequiredService <IW4MServer>();
var origin = ClientGenerators.CreateDatabaseClient();
origin.Level = Permission.Administrator;
origin.CurrentServer = server;
var gameEvent = EventGenerators.GenerateEvent(GameEvent.EventType.Command, "", server);
gameEvent.Origin = origin;
cmdConfig.Commands.Add(nameof(PrivateMessageAdminsCommand), new CommandProperties());
server.Clients[0] = origin;
server.Clients[1] = origin;
await cmd.ExecuteAsync(gameEvent);
int expectedEvents = 1;
Assert.AreEqual(expectedEvents, mockEventHandler.Events.Count(_event => _event.Type == GameEvent.EventType.Tell));
}
public async Task Test_QueryClientResource_NoMatch()
{
var query = new FindClientRequest()
{
Name = "test"
};
using var context = contextFactory.CreateContext();
var client = ClientGenerators.CreateBasicClient(null);
client.Name = "client";
context.Clients.Add(client);
await context.SaveChangesAsync();
var result = await clientService.QueryResource(query);
Assert.IsEmpty(result.Results);
context.Clients.Remove(client);
await context.SaveChangesAsync();
}
public async Task Test_TempBanFindsIngameClientToExecuteFor()
{
var fakePenaltyService = A.Fake <PenaltyService>();
A.CallTo(() => fakeManager.GetPenaltyService())
.Returns(fakePenaltyService);
var server = serviceProvider.GetRequiredService <IW4MServer>();
var origin = ClientGenerators.CreateBasicClient(server);
var target = ClientGenerators.CreateBasicClient(server, isIngame: false);
var ingameTarget = ClientGenerators.CreateBasicClient(server);
A.CallTo(() => fakeManager.GetActiveClients())
.Returns(new[] { ingameTarget });
await server.TempBan("test reason", TimeSpan.Zero, target, origin);
A.CallTo(() => server.RconParser.ExecuteCommandAsync(A <IRConConnection> .Ignored, "kick"))
.MustHaveHappenedOnceExactly();
}
public async Task Test_QueryClientResource_NameCaseInsensitivePartial()
{
var query = new FindClientRequest()
{
Name = "TEST"
};
using var context = contextFactory.CreateContext();
var client = ClientGenerators.CreateBasicClient(null);
client.Name = "atesticle";
context.Clients.Add(client);
await context.SaveChangesAsync();
var result = await clientService.QueryResource(query);
Assert.IsNotEmpty(result.Results);
Assert.IsTrue(result.Results.First().Name.ToUpper().Contains(query.Name));
context.Clients.Remove(client);
await context.SaveChangesAsync();
}
public async Task Test_RunAsFailsOnSamePrivilege()
{
var cmd = serviceProvider.GetRequiredService <RunAsCommand>();
var server = serviceProvider.GetRequiredService <IW4MServer>();
var target = ClientGenerators.CreateBasicClient(server);
target.Level = EFClient.Permission.Administrator;
var origin = ClientGenerators.CreateBasicClient(server);
origin.NetworkId = 100;
origin.Level = EFClient.Permission.Administrator;
var gameEvent = new GameEvent()
{
Target = target,
Origin = origin
};
await cmd.ExecuteAsync(gameEvent);
Assert.IsNotEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Tell));
Assert.IsEmpty(mockEventHandler.Events.Where(_event => _event.Type == GameEvent.EventType.Command));
}
public void Setup()
{
serviceProvider = new ServiceCollection()
.BuildBase()
.AddSingleton <ActionController>()
.AddSingleton <IManagerCommand, BanCommand>()
.AddSingleton <IManagerCommand, TempBanCommand>()
.AddSingleton <IManagerCommand, UnbanCommand>()
.AddSingleton <IManagerCommand, KickCommand>()
.AddSingleton <IManagerCommand, FlagClientCommand>()
.AddSingleton <IManagerCommand, UnflagClientCommand>()
.AddSingleton <IManagerCommand, SayCommand>()
.AddSingleton <IManagerCommand, SetLevelCommand>()
.BuildServiceProvider()
.SetupTestHooks();
contextFactory = serviceProvider.GetRequiredService <IDatabaseContextFactory>();
server = serviceProvider.GetRequiredService <IW4MServer>();
manager = serviceProvider.GetRequiredService <IManager>();
A.CallTo(() => manager.GetServers())
.Returns(new[] { server });
A.CallTo(() => manager.GetActiveClients())
.Returns(new[] { ClientGenerators.CreateBasicClient(server) });
}
