Add Job preference tests (#28625)

* Misc Job related changes

* Add JobTest

* A

* Aa

* Lets not confuse the yaml linter

* fixes

* a

Content.IntegrationTests/Tests/Round/JobTest.cs

@@ -0,0 +1,222 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using Content.IntegrationTests.Pair;
+using Content.Server.GameTicking;
+using Content.Server.Mind;
+using Content.Server.Roles;
+using Content.Shared.CCVar;
+using Content.Shared.GameTicking;
+using Content.Shared.Preferences;
+using Content.Shared.Roles;
+using Content.Shared.Roles.Jobs;
+using Robust.Shared.Network;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Round;
+
+[TestFixture]
+public sealed class JobTest
+{
+    private static ProtoId<JobPrototype> _passenger = "Passenger";
+    private static ProtoId<JobPrototype> _engineer = "StationEngineer";
+    private static ProtoId<JobPrototype> _captain = "Captain";
+
+    private static string _map = "JobTestMap";
+
+    [TestPrototypes]
+    public static string JobTestMap = @$"
+- type: gameMap
+  id: {_map}
+  mapName: {_map}
+  mapPath: /Maps/Test/empty.yml
+  minPlayers: 0
+  stations:
+    Empty:
+      stationProto: StandardNanotrasenStation
+      components:
+        - type: StationNameSetup
+          mapNameTemplate: ""Empty""
+        - type: StationJobs
+          availableJobs:
+            {_passenger}: [ -1, -1 ]
+            {_engineer}: [ -1, -1 ]
+            {_captain}: [ 1, 1 ]
+";
+
+    public void AssertJob(TestPair pair, ProtoId<JobPrototype> job, NetUserId? user = null, bool isAntag = false)
+    {
+        var jobSys = pair.Server.System<SharedJobSystem>();
+        var mindSys = pair.Server.System<MindSystem>();
+        var roleSys = pair.Server.System<RoleSystem>();
+        var ticker = pair.Server.System<GameTicker>();
+
+        user ??= pair.Client.User!.Value;
+
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.InRound));
+        Assert.That(ticker.PlayerGameStatuses[user.Value], Is.EqualTo(PlayerGameStatus.JoinedGame));
+
+        var uid = pair.Server.PlayerMan.SessionsDict.GetValueOrDefault(user.Value)?.AttachedEntity;
+        Assert.That(pair.Server.EntMan.EntityExists(uid));
+        var mind = mindSys.GetMind(uid!.Value);
+        Assert.That(pair.Server.EntMan.EntityExists(mind));
+        Assert.That(jobSys.MindTryGetJobId(mind, out var actualJob));
+        Assert.That(actualJob, Is.EqualTo(job));
+        Assert.That(roleSys.MindIsAntagonist(mind), Is.EqualTo(isAntag));
+    }
+
+    /// <summary>
+    /// Simple test that checks that starting the round spawns the player into the test map as a passenger.
+    /// </summary>
+    [Test]
+    public async Task StartRoundTest()
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            DummyTicker = false,
+            Connected = true,
+            InLobby = true
+        });
+
+        pair.Server.CfgMan.SetCVar(CCVars.GameMap, _map);
+        var ticker = pair.Server.System<GameTicker>();
+
+        // Initially in the lobby
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
+        Assert.That(pair.Client.AttachedEntity, Is.Null);
+        Assert.That(ticker.PlayerGameStatuses[pair.Client.User!.Value], Is.EqualTo(PlayerGameStatus.NotReadyToPlay));
+
+        // Ready up and start the round
+        ticker.ToggleReadyAll(true);
+        Assert.That(ticker.PlayerGameStatuses[pair.Client.User!.Value], Is.EqualTo(PlayerGameStatus.ReadyToPlay));
+        await pair.Server.WaitPost(() => ticker.StartRound());
+        await pair.RunTicksSync(10);
+
+        AssertJob(pair, _passenger);
+
+        await pair.Server.WaitPost(() => ticker.RestartRound());
+        await pair.CleanReturnAsync();
+    }
+
+    /// <summary>
+    /// Check that job preferences are respected.
+    /// </summary>
+    [Test]
+    public async Task JobPreferenceTest()
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            DummyTicker = false,
+            Connected = true,
+            InLobby = true
+        });
+
+        pair.Server.CfgMan.SetCVar(CCVars.GameMap, _map);
+        var ticker = pair.Server.System<GameTicker>();
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
+        Assert.That(pair.Client.AttachedEntity, Is.Null);
+
+        await pair.SetJobPriorities((_passenger, JobPriority.Medium), (_engineer, JobPriority.High));
+        ticker.ToggleReadyAll(true);
+        await pair.Server.WaitPost(() => ticker.StartRound());
+        await pair.RunTicksSync(10);
+
+        AssertJob(pair, _engineer);
+
+        await pair.Server.WaitPost(() => ticker.RestartRound());
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
+        await pair.SetJobPriorities((_passenger, JobPriority.High), (_engineer, JobPriority.Medium));
+        ticker.ToggleReadyAll(true);
+        await pair.Server.WaitPost(() => ticker.StartRound());
+        await pair.RunTicksSync(10);
+
+        AssertJob(pair, _passenger);
+
+        await pair.Server.WaitPost(() => ticker.RestartRound());
+        await pair.CleanReturnAsync();
+    }
+
+    /// <summary>
+    /// Check high priority jobs (e.g., captain) are selected before other roles, even if it means a player does not
+    /// get their preferred job.
+    /// </summary>
+    [Test]
+    public async Task JobWeightTest()
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            DummyTicker = false,
+            Connected = true,
+            InLobby = true
+        });
+
+        pair.Server.CfgMan.SetCVar(CCVars.GameMap, _map);
+        var ticker = pair.Server.System<GameTicker>();
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
+        Assert.That(pair.Client.AttachedEntity, Is.Null);
+
+        var captain = pair.Server.ProtoMan.Index(_captain);
+        var engineer = pair.Server.ProtoMan.Index(_engineer);
+        var passenger = pair.Server.ProtoMan.Index(_passenger);
+        Assert.That(captain.Weight, Is.GreaterThan(engineer.Weight));
+        Assert.That(engineer.Weight, Is.EqualTo(passenger.Weight));
+
+        await pair.SetJobPriorities((_passenger, JobPriority.Medium), (_engineer, JobPriority.High), (_captain, JobPriority.Low));
+        ticker.ToggleReadyAll(true);
+        await pair.Server.WaitPost(() => ticker.StartRound());
+        await pair.RunTicksSync(10);
+
+        AssertJob(pair, _captain);
+
+        await pair.Server.WaitPost(() => ticker.RestartRound());
+        await pair.CleanReturnAsync();
+    }
+
+    /// <summary>
+    /// Check that jobs are preferentially given to players that have marked those jobs as higher priority.
+    /// </summary>
+    [Test]
+    public async Task JobPriorityTest()
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            DummyTicker = false,
+            Connected = true,
+            InLobby = true
+        });
+
+        pair.Server.CfgMan.SetCVar(CCVars.GameMap, _map);
+        var ticker = pair.Server.System<GameTicker>();
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
+        Assert.That(pair.Client.AttachedEntity, Is.Null);
+
+        await pair.Server.AddDummySessions(5);
+        await pair.RunTicksSync(5);
+
+        var engineers = pair.Server.PlayerMan.Sessions.Select(x => x.UserId).ToList();
+        var captain = engineers[3];
+        engineers.RemoveAt(3);
+
+        await pair.SetJobPriorities(captain, (_captain, JobPriority.High), (_engineer, JobPriority.Medium));
+        foreach (var engi in engineers)
+        {
+            await pair.SetJobPriorities(engi, (_captain, JobPriority.Medium), (_engineer, JobPriority.High));
+        }
+
+        ticker.ToggleReadyAll(true);
+        await pair.Server.WaitPost(() => ticker.StartRound());
+        await pair.RunTicksSync(10);
+
+        AssertJob(pair, _captain, captain);
+        Assert.Multiple(() =>
+        {
+            foreach (var engi in engineers)
+            {
+                AssertJob(pair, _engineer, engi);
+            }
+        });
+
+        await pair.Server.WaitPost(() => ticker.RestartRound());
+        await pair.CleanReturnAsync();
+    }
+}