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) }); }