public PavlovServerController(SshServerSerivce service,
UserService userService,
PavlovServerService pavlovServerService,
ServerBansService serverBansService,
ServerSelectedMapService serverSelectedMapService,
MapsService mapsService,
SshServerSerivce sshServerSerivce,
ServerSelectedWhitelistService whitelistService,
SteamIdentityStatsServerService steamIdentityStatsServerService,
ServerSelectedModsService serverSelectedModsService,
SteamIdentityService steamIdentityService,
UserManager <LiteDbUser> userManager,
IToastifyService notyfService)
{
_notifyService = notyfService;
_service = service;
_userservice = userService;
_pavlovServerService = pavlovServerService;
_serverSelectedMapService = serverSelectedMapService;
_serverBansService = serverBansService;
_steamIdentityStatsServerService = steamIdentityStatsServerService;
_mapsService = mapsService;
_whitelistService = whitelistService;
_steamIdentityService = steamIdentityService;
_sshServerSerivce = sshServerSerivce;
_serverSelectedModsService = serverSelectedModsService;
UserManager = userManager;
}
public SteamIdentityServiceTest()
{
services = new ServicesBuilder();
_mocker = new AutoMocker();
services.Build(_mocker);
_steamIdentityService = _mocker.CreateInstance <SteamIdentityService>();
}
public TeamSelectedSteamIdentityServiceTest()
{
services = new ServicesBuilder();
_mocker = new AutoMocker();
services.Build(_mocker);
_userManager = services.GetUserManager();
_steamIdentityService = _mocker.CreateInstance <SteamIdentityService>();
_teamSelectedSteamIdentityService = _mocker.CreateInstance <TeamSelectedSteamIdentityService>();
_teamService = _mocker.CreateInstance <TeamService>();
}
public ServerSelectedWhitelistServiceTests()
{
services = new ServicesBuilder();
_mocker = new AutoMocker();
services.Build(_mocker);
_serverSelectedWhitelistService = _mocker.CreateInstance <ServerSelectedWhitelistService>();
_steamIdentityService = _mocker.CreateInstance <SteamIdentityService>();
_pavlovServerService = _mocker.CreateInstance <PavlovServerService>();
_sshServerSerivce = _mocker.CreateInstance <SshServerSerivce>();
_userManager = services.GetUserManager();
}
public static LiteDbUser InsertUserAndSteamIdentity(SteamIdentityService steamIdentityService,
UserManager <LiteDbUser> userManager, string userName = "******", string steamIdentityId = "1")
{
var user = UserServiceTests.SetUpUser(userManager, userName);
var identity = SteamIdentityServiceTest.SteamIdentity(steamIdentityId);
identity.LiteDbUser = user;
identity.LiteDbUserId = user.Id.ToString();
steamIdentityService.Upsert(identity).GetAwaiter().GetResult();
return(user);
}
public TeamController(TeamService teamService,
SteamIdentityService steamIdentityService,
UserService userService,
TeamSelectedSteamIdentityService teamSelectedSteamIdentityService,
UserManager <LiteDbUser> userManager)
{
_teamService = teamService;
_steamIdentityService = steamIdentityService;
_userService = userService;
_teamSelectedSteamIdentityService = teamSelectedSteamIdentityService;
_userManager = userManager;
}
public MatchServiceTest()
{
services = new ServicesBuilder();
_mocker = new AutoMocker();
services.Build(_mocker);
_pavlovServerService = _mocker.CreateInstance <PavlovServerService>();
_sshServerSerivce = _mocker.CreateInstance <SshServerSerivce>();
_teamService = _mocker.CreateInstance <TeamService>();
_matchService = _mocker.CreateInstance <MatchService>();
_steamIdentityService = _mocker.CreateInstance <SteamIdentityService>();
_matchSelectedSteamIdentitiesService = _mocker.CreateInstance <MatchSelectedSteamIdentitiesService>();
_matchSelectedTeamSteamIdentitiesService =
_mocker.CreateInstance <MatchSelectedTeamSteamIdentitiesService>();
_userManager = services.GetUserManager();
}
public MatchMakingController(UserService userService,
MatchService matchService,
PavlovServerService pavlovServerService, TeamService teamService,
MatchSelectedSteamIdentitiesService matchSelectedSteamIdentities,
SteamIdentityService steamIdentityService,
MapsService mapsService,
PublicViewListsService publicViewListsService,
TeamSelectedSteamIdentityService teamSelectedSteamIdentityService,
MatchSelectedTeamSteamIdentitiesService matchSelectedTeamSteamIdentitiesService)
{
_userservice = userService;
_matchService = matchService;
_pavlovServerService = pavlovServerService;
_teamService = teamService;
_steamIdentityService = steamIdentityService;
_matchSelectedSteamIdentitiesService = matchSelectedSteamIdentities;
_matchSelectedTeamSteamIdentitiesService = matchSelectedTeamSteamIdentitiesService;
_teamSelectedSteamIdentityService = teamSelectedSteamIdentityService;
_mapsService = mapsService;
_publicViewListsService = publicViewListsService;
}
public PavlovServerServiceTests()
{
services = new ServicesBuilder();
_mocker = new AutoMocker();
services.Build(_mocker);
_userManager = services.GetUserManager();
// Mock ValidatePavlovServer function
var tmpService = _mocker
.Setup <PavlovServerService, Task <PavlovServer> >(x =>
x.ValidatePavlovServer(It.IsAny <PavlovServer>(), It.IsAny <bool>()))
.ReturnsAsync((PavlovServer server, bool root) => server);
_mocker.Use(tmpService);
_pavlovServerService = _mocker.GetMock <PavlovServerService>().Object;
_sshServerSerivce = _mocker.CreateInstance <SshServerSerivce>();
_serverSelectedModsService = _mocker.CreateInstance <ServerSelectedModsService>();
_steamIdentityService = _mocker.CreateInstance <SteamIdentityService>();
}
public AccountController(
UserManager <LiteDbUser> userManager,
SignInManager <LiteDbUser> signInManager,
IEmailSender emailSender,
ReservedServersService reservedServersService,
SteamIdentityService steamIdentityService,
PavlovServerService pavlovServerService,
SshServerSerivce sshServerSerivce,
ILogger <AccountController> logger,
UserService userService)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_userService = userService;
_sshServerSerivce = sshServerSerivce;
_steamIdentityService = steamIdentityService;
_reservedServersService = reservedServersService;
_pavlovServerService = pavlovServerService;
}
public ManageController(
UserManager <LiteDbUser> userManager,
SignInManager <LiteDbUser> signInManager,
IEmailSender emailSender,
UserService userService,
SteamIdentityService steamIdentityService,
PavlovServerPlayerHistoryService pavlovServerPlayerHistoryService,
MatchService matchService,
SteamIdentityStatsServerService steamIdentityStatsServerService,
ILogger <ManageController> logger,
UrlEncoder urlEncoder)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_userService = userService;
_steamIdentityService = steamIdentityService;
_pavlovServerPlayerHistoryService = pavlovServerPlayerHistoryService;
_matchService = matchService;
_steamIdentityStatsServerService = steamIdentityStatsServerService;
}
public static Match CreateMatch(MatchService matchService, PavlovServer pavlovServer, bool teamMatch,
TeamService teamService, SteamIdentityService steamIdentityService, UserManager <LiteDbUser> userManager,
MatchSelectedSteamIdentitiesService matchSelectedSteamIdentitiesService,
MatchSelectedTeamSteamIdentitiesService matchSelectedTeamSteamIdentitiesService)
{
var user = ServerSelectedModServiceTests.InsertUserAndSteamIdentity(steamIdentityService, userManager,
"test");
var user2 = ServerSelectedModServiceTests.InsertUserAndSteamIdentity(steamIdentityService, userManager,
"test2", "2");
var steamIdentity1 = steamIdentityService.FindOne(user.Id).GetAwaiter().GetResult();
var steamIdentity2 = steamIdentityService.FindOne(user2.Id).GetAwaiter().GetResult();
var team1 = TeamSelectedSteamIdentityServiceTest.CreateTeam(teamService);
var team2 = TeamSelectedSteamIdentityServiceTest.CreateTeam(teamService, "test2");
if (teamMatch)
{
matchService.Upsert(new Match
{
Name = "Test",
MapId = "null",
GameMode = "TDM",
ForceStart = false,
ForceSop = false,
TimeLimit = 40,
PlayerSlots = 10,
Team0 = team1,
Team1 = team2,
PavlovServer = pavlovServer,
Status = Status.Preparing
}).GetAwaiter().GetResult();
}
else
{
matchService.Upsert(new Match
{
Name = "Test",
MapId = "null",
GameMode = "GUN",
ForceStart = false,
ForceSop = false,
TimeLimit = 40,
PlayerSlots = 10,
Team0 = team1,
PavlovServer = pavlovServer,
Status = Status.Preparing
}).GetAwaiter().GetResult();
}
var match = matchService.FindAll().GetAwaiter().GetResult().FirstOrDefault();
if (teamMatch)
{
match.MatchTeam0SelectedSteamIdentities = new List <MatchTeamSelectedSteamIdentity>
{
new()
{
SteamIdentityId = steamIdentity1.Id,
SteamIdentity = steamIdentity1,
matchId = match.Id,
TeamId = 0
}
};
match.MatchTeam1SelectedSteamIdentities = new List <MatchTeamSelectedSteamIdentity>
{
new()
{
SteamIdentityId = steamIdentity2.Id,
SteamIdentity = steamIdentity2,
matchId = match.Id,
TeamId = 1
}
};
matchSelectedTeamSteamIdentitiesService.Upsert(match.MatchTeam0SelectedSteamIdentities, match.Id, 0)
.GetAwaiter().GetResult();
matchSelectedTeamSteamIdentitiesService.Upsert(match.MatchTeam1SelectedSteamIdentities, match.Id, 1)
.GetAwaiter().GetResult();
}
else
{
match.MatchSelectedSteamIdentities = new List <MatchSelectedSteamIdentity>
{
new()
{
SteamIdentityId = steamIdentity1.Id,
SteamIdentity = steamIdentity1,
matchId = match.Id
},
new()
{
SteamIdentityId = steamIdentity2.Id,
SteamIdentity = steamIdentity2,
matchId = match.Id
}
};
matchSelectedSteamIdentitiesService.Upsert(match.MatchSelectedSteamIdentities, match.Id).GetAwaiter()
.GetResult();
}
matchService.Upsert(match);
return(match);
}
