828 lines
48 KiB
C#
828 lines
48 KiB
C#
using System.Net.Http.Json;
|
|
using System.Text.Json;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using SVSim.UnitTests.Infrastructure;
|
|
|
|
namespace SVSim.UnitTests.Integration.Guild;
|
|
|
|
using GuildEntity = SVSim.Database.Entities.Guild.Guild;
|
|
|
|
/// <summary>
|
|
/// Integration tests for the join-path state machine:
|
|
/// /guild/join (FREE / APPROVAL / ONLY_INVITE branches),
|
|
/// /guild/cancel_join_request,
|
|
/// /guild/join_request_list.
|
|
/// </summary>
|
|
public class GuildJoinFlowTests
|
|
{
|
|
private const string Vid = "0";
|
|
private const int Sid = 0;
|
|
private const string Stk = "";
|
|
|
|
private static object BaseReq() => new { viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk };
|
|
|
|
// Many wire fields use StringifiedIntConverter — values arrive as "123" not 123.
|
|
private static int GetStringifiedInt(JsonElement el, string prop)
|
|
=> int.Parse(el.GetProperty(prop).GetString()!);
|
|
|
|
private static long GetStringifiedLong(JsonElement el, string prop)
|
|
=> long.Parse(el.GetProperty(prop).GetString()!);
|
|
|
|
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
|
|
|
/// <summary>Creates a guild as the given client and returns the guild_id from /guild/info.</summary>
|
|
private static async Task<int> CreateGuildAndGetIdAsync(HttpClient client, string name, int joinCondition = 1)
|
|
{
|
|
var createResp = await client.PostAsync("/guild/create",
|
|
JsonContent.Create(new
|
|
{
|
|
guild_name = name,
|
|
activity = 1,
|
|
join_condition = joinCondition,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk
|
|
}));
|
|
Assert.That(createResp.IsSuccessStatusCode, Is.True,
|
|
$"create failed: {await createResp.Content.ReadAsStringAsync()}");
|
|
|
|
var infoResp = await client.PostAsync("/guild/info",
|
|
JsonContent.Create(new { viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var infoJson = await infoResp.Content.ReadAsStringAsync();
|
|
using var doc = JsonDocument.Parse(infoJson);
|
|
return GetStringifiedInt(doc.RootElement.GetProperty("guild").GetProperty("detail"), "guild_id");
|
|
}
|
|
|
|
// ─── FREE branch ─────────────────────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Free_join_makes_viewer_a_member_instantly()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_001UL, displayName: "FreeLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "FreeGuild", joinCondition: 1);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_002UL, displayName: "FreeJoiner");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
var joinResp = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var joinJson = await joinResp.Content.ReadAsStringAsync();
|
|
Assert.That(joinResp.IsSuccessStatusCode, Is.True, $"join HTTP failed: {joinJson}");
|
|
using var joinDoc = JsonDocument.Parse(joinJson);
|
|
if (joinDoc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"join returned error: {joinJson}");
|
|
|
|
// guild_status must be 2 (JOINING) — value is stringified.
|
|
Assert.That(GetStringifiedInt(joinDoc.RootElement, "guild_status"), Is.EqualTo(2),
|
|
$"guild_status must be 2 after FREE join, got: {joinJson}");
|
|
|
|
// B calling /guild/info should now be a member (guild_status=2).
|
|
var bInfoResp = await clientB.PostAsync("/guild/info",
|
|
JsonContent.Create(new { viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var bInfoJson = await bInfoResp.Content.ReadAsStringAsync();
|
|
using var bInfoDoc = JsonDocument.Parse(bInfoJson);
|
|
Assert.That(GetStringifiedInt(bInfoDoc.RootElement, "guild_status"), Is.EqualTo(2),
|
|
$"B should be a member after FREE join, got: {bInfoJson}");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Free_join_consumes_pending_invite()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_011UL, displayName: "FreeLeader2");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "FreeGuild2", joinCondition: 1);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_012UL, displayName: "FreeJoinerInvited");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// A invites B.
|
|
await clientA.PostAsync("/guild/invite",
|
|
JsonContent.Create(new { invited_viewer_id = (int)viewerB, invite_message = "",
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// B joins via FREE path.
|
|
var joinResp = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
Assert.That(joinResp.IsSuccessStatusCode, Is.True);
|
|
|
|
// After joining, B's invited_guild_list should be empty (invite consumed).
|
|
var invitedList = await clientB.PostAsync("/guild/invited_guild_list",
|
|
JsonContent.Create(new { page = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var ilDoc = JsonDocument.Parse(await invitedList.Content.ReadAsStringAsync());
|
|
Assert.That(ilDoc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(0),
|
|
"After joining, pending invites for the viewer should be consumed");
|
|
}
|
|
|
|
// ─── APPROVAL branch ─────────────────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Approval_join_creates_pending_request_not_membership()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_021UL, displayName: "ApprovalLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "ApprovalGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_022UL, displayName: "ApprovalApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// B applies.
|
|
var joinResp = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var joinJson = await joinResp.Content.ReadAsStringAsync();
|
|
Assert.That(joinResp.IsSuccessStatusCode, Is.True, $"join HTTP failed: {joinJson}");
|
|
using var joinDoc = JsonDocument.Parse(joinJson);
|
|
if (joinDoc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"APPROVAL join returned error: {joinJson}");
|
|
|
|
// B must NOT be a member yet (guild_status=0, no guild sub-object).
|
|
var bInfoResp = await clientB.PostAsync("/guild/info",
|
|
JsonContent.Create(new { viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var bInfoJson = await bInfoResp.Content.ReadAsStringAsync();
|
|
using var bInfoDoc = JsonDocument.Parse(bInfoJson);
|
|
Assert.That(GetStringifiedInt(bInfoDoc.RootElement, "guild_status"), Is.EqualTo(0),
|
|
$"B must NOT be a member after APPROVAL apply, got: {bInfoJson}");
|
|
|
|
// A (leader) should see B in the join_request_list.
|
|
var jrlResp = await clientA.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var jrlJson = await jrlResp.Content.ReadAsStringAsync();
|
|
Assert.That(jrlResp.IsSuccessStatusCode, Is.True, $"join_request_list HTTP failed: {jrlJson}");
|
|
using var jrlDoc = JsonDocument.Parse(jrlJson);
|
|
var list = jrlDoc.RootElement.GetProperty("list");
|
|
Assert.That(list.GetArrayLength(), Is.EqualTo(1), $"Leader should see 1 pending applicant, got: {jrlJson}");
|
|
// viewer_id in list entries is StringifiedLong.
|
|
Assert.That(GetStringifiedLong(list[0], "viewer_id"), Is.EqualTo(viewerB),
|
|
"The applicant must be viewer B");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Approval_join_is_idempotent()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_031UL, displayName: "IdempotentLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "IdempotentGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_032UL, displayName: "IdempotentApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
var joinPayload = new { guild_id = guildId, from_invite = false, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk };
|
|
|
|
// B applies twice.
|
|
await clientB.PostAsync("/guild/join", JsonContent.Create(joinPayload));
|
|
var join2 = await clientB.PostAsync("/guild/join", JsonContent.Create(joinPayload));
|
|
var join2Json = await join2.Content.ReadAsStringAsync();
|
|
Assert.That(join2.IsSuccessStatusCode, Is.True, $"Second apply must not HTTP-fail: {join2Json}");
|
|
using var join2Doc = JsonDocument.Parse(join2Json);
|
|
if (join2Doc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"Second apply must return Ok: {join2Json}");
|
|
|
|
// Still only 1 entry in the list.
|
|
var jrlResp = await clientA.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var jrlDoc = JsonDocument.Parse(await jrlResp.Content.ReadAsStringAsync());
|
|
Assert.That(jrlDoc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(1),
|
|
"Idempotent re-apply must not duplicate the pending row");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Approval_join_response_has_guild_status_APPLYING()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_025UL, displayName: "ApprovalLeaderStatus");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "ApprovalGuildStatus", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_026UL, displayName: "ApprovalApplicantStatus");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// B applies to the APPROVAL guild.
|
|
var joinResp = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var joinJson = await joinResp.Content.ReadAsStringAsync();
|
|
Assert.That(joinResp.IsSuccessStatusCode, Is.True, $"join HTTP failed: {joinJson}");
|
|
|
|
using var joinDoc = JsonDocument.Parse(joinJson);
|
|
// Must be APPLYING (1), NOT JOINING (2) — GuildJoinTask.Parse() reads this value directly.
|
|
Assert.That(GetStringifiedInt(joinDoc.RootElement, "guild_status"), Is.EqualTo(1),
|
|
$"APPROVAL branch must return guild_status=1 (APPLYING), got: {joinJson}");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Approval_idempotent_join_response_has_guild_status_APPLYING()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_027UL, displayName: "IdempotentApprovalLeaderStatus");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "IdempotentApprovalStatus", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_028UL, displayName: "IdempotentApplicantStatus");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
var joinPayload = new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk };
|
|
|
|
// First apply.
|
|
await clientB.PostAsync("/guild/join", JsonContent.Create(joinPayload));
|
|
// Second (idempotent) apply — should still return APPLYING (1).
|
|
var join2 = await clientB.PostAsync("/guild/join", JsonContent.Create(joinPayload));
|
|
var join2Json = await join2.Content.ReadAsStringAsync();
|
|
Assert.That(join2.IsSuccessStatusCode, Is.True, $"Idempotent apply HTTP failed: {join2Json}");
|
|
|
|
using var join2Doc = JsonDocument.Parse(join2Json);
|
|
Assert.That(GetStringifiedInt(join2Doc.RootElement, "guild_status"), Is.EqualTo(1),
|
|
$"Idempotent APPROVAL branch must return guild_status=1 (APPLYING), got: {join2Json}");
|
|
}
|
|
|
|
// ─── ONLY_INVITE branch ──────────────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task OnlyInvite_without_invite_is_rejected()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_041UL, displayName: "InviteOnlyLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "InviteOnlyGuild", joinCondition: 3);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_042UL, displayName: "UninvitedB");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
var joinResp = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var joinJson = await joinResp.Content.ReadAsStringAsync();
|
|
Assert.That(joinResp.IsSuccessStatusCode, Is.True, "HTTP must be 200");
|
|
using var joinDoc = JsonDocument.Parse(joinJson);
|
|
Assert.That(joinDoc.RootElement.TryGetProperty("result_code", out var rc), Is.True,
|
|
$"Expected error result_code, got: {joinJson}");
|
|
Assert.That(rc.GetInt32(), Is.EqualTo(2), $"Must be rejected (result_code=2), got: {joinJson}");
|
|
}
|
|
|
|
[Test]
|
|
public async Task OnlyInvite_with_pending_invite_joins_and_consumes_invite()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_051UL, displayName: "InviteOnlyLeader2");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "InviteOnlyGuild2", joinCondition: 3);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_052UL, displayName: "InvitedB");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// A invites B.
|
|
await clientA.PostAsync("/guild/invite",
|
|
JsonContent.Create(new { invited_viewer_id = (int)viewerB, invite_message = "",
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// B joins via ONLY_INVITE path.
|
|
var joinResp = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = true,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var joinJson = await joinResp.Content.ReadAsStringAsync();
|
|
Assert.That(joinResp.IsSuccessStatusCode, Is.True, $"join HTTP failed: {joinJson}");
|
|
using var joinDoc = JsonDocument.Parse(joinJson);
|
|
if (joinDoc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"ONLY_INVITE join with invite returned error: {joinJson}");
|
|
|
|
// B is now a member.
|
|
var bInfoResp = await clientB.PostAsync("/guild/info",
|
|
JsonContent.Create(new { viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var bInfoJson = await bInfoResp.Content.ReadAsStringAsync();
|
|
using var bInfoDoc = JsonDocument.Parse(bInfoJson);
|
|
Assert.That(GetStringifiedInt(bInfoDoc.RootElement, "guild_status"), Is.EqualTo(2),
|
|
$"B must be a member after ONLY_INVITE join, got: {bInfoJson}");
|
|
|
|
// Invite was consumed — B's invited_guild_list is now empty.
|
|
var invitedList = await clientB.PostAsync("/guild/invited_guild_list",
|
|
JsonContent.Create(new { page = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var ilDoc = JsonDocument.Parse(await invitedList.Content.ReadAsStringAsync());
|
|
Assert.That(ilDoc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(0),
|
|
"Invite must be consumed (Pending→Consumed) after ONLY_INVITE join");
|
|
}
|
|
|
|
// ─── Member cap ──────────────────────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Full_guild_rejects_free_join()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
// Seed a GuildConfig with MaxMemberNum = 1 so the guild fills at the leader.
|
|
using (var scope = factory.Services.CreateScope())
|
|
{
|
|
var db = scope.ServiceProvider.GetRequiredService<SVSim.Database.SVSimDbContext>();
|
|
const string json = "{\"MaxMemberNum\":1,\"MaxSubLeaderNum\":3,\"SearchResultCap\":20,\"UsableStampList\":[1,2,3,4,5]}";
|
|
var existing = db.GameConfigs.FirstOrDefault(s => s.SectionName == "Guild");
|
|
if (existing is null)
|
|
db.GameConfigs.Add(new SVSim.Database.Models.GameConfigSection { SectionName = "Guild", ValueJson = json });
|
|
else
|
|
existing.ValueJson = json;
|
|
db.SaveChanges();
|
|
}
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_061UL, displayName: "CapLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "CapGuild", joinCondition: 1);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_062UL, displayName: "CapJoiner");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
var joinResp = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var joinJson = await joinResp.Content.ReadAsStringAsync();
|
|
Assert.That(joinResp.IsSuccessStatusCode, Is.True, "HTTP must be 200");
|
|
using var joinDoc = JsonDocument.Parse(joinJson);
|
|
Assert.That(joinDoc.RootElement.TryGetProperty("result_code", out var rc), Is.True,
|
|
$"Expected error result_code when guild is full, got: {joinJson}");
|
|
Assert.That(rc.GetInt32(), Is.EqualTo(2), $"Full guild must reject join (result_code=2), got: {joinJson}");
|
|
}
|
|
|
|
// ─── cancel_join_request ─────────────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Cancel_join_request_removes_pending_row()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_071UL, displayName: "CancelReqLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "CancelReqGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_072UL, displayName: "CancelApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// B applies.
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// A sees B in the list.
|
|
var jrl1 = await clientA.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var jrl1Doc = JsonDocument.Parse(await jrl1.Content.ReadAsStringAsync());
|
|
Assert.That(jrl1Doc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(1),
|
|
"Should see 1 pending before cancel");
|
|
|
|
// B cancels (no guild_id in request — server infers from viewer state).
|
|
var cancelResp = await clientB.PostAsync("/guild/cancel_join_request",
|
|
JsonContent.Create(BaseReq()));
|
|
var cancelJson = await cancelResp.Content.ReadAsStringAsync();
|
|
Assert.That(cancelResp.IsSuccessStatusCode, Is.True, $"cancel_join_request HTTP failed: {cancelJson}");
|
|
using var cancelDoc = JsonDocument.Parse(cancelJson);
|
|
if (cancelDoc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"cancel_join_request returned error: {cancelJson}");
|
|
|
|
// A no longer sees any pending applicants.
|
|
var jrl2 = await clientA.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var jrl2Doc = JsonDocument.Parse(await jrl2.Content.ReadAsStringAsync());
|
|
Assert.That(jrl2Doc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(0),
|
|
"After cancel, no pending applicants should be visible");
|
|
}
|
|
|
|
[Test]
|
|
public async Task After_cancel_viewer_can_reapply()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_081UL, displayName: "ReApplyLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "ReApplyGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_082UL, displayName: "ReApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// Apply → cancel → re-apply.
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
await clientB.PostAsync("/guild/cancel_join_request", JsonContent.Create(BaseReq()));
|
|
|
|
var reApply = await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var reApplyJson = await reApply.Content.ReadAsStringAsync();
|
|
Assert.That(reApply.IsSuccessStatusCode, Is.True, $"Re-apply after cancel HTTP failed: {reApplyJson}");
|
|
using var doc = JsonDocument.Parse(reApplyJson);
|
|
if (doc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"Re-apply after cancel must not error: {reApplyJson}");
|
|
|
|
// A should see 1 pending applicant again.
|
|
var jrlResp = await clientA.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var jrlDoc = JsonDocument.Parse(await jrlResp.Content.ReadAsStringAsync());
|
|
Assert.That(jrlDoc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(1),
|
|
"After re-apply, applicant should appear in list again");
|
|
}
|
|
|
|
// ─── join_request_list permission ────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Join_request_list_returns_empty_for_regular_member()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_091UL, displayName: "ListLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "ListGuild", joinCondition: 1);
|
|
|
|
// B joins (FREE) — becomes Regular member.
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_092UL, displayName: "RegularMember");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// Regular member B gets an empty list from join_request_list.
|
|
var jrlResp = await clientB.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var jrlJson = await jrlResp.Content.ReadAsStringAsync();
|
|
Assert.That(jrlResp.IsSuccessStatusCode, Is.True, $"join_request_list HTTP failed: {jrlJson}");
|
|
using var jrlDoc = JsonDocument.Parse(jrlJson);
|
|
Assert.That(jrlDoc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(0),
|
|
"Regular member must see empty list from join_request_list");
|
|
}
|
|
|
|
// ─── join_request_accept ─────────────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Accept_makes_applicant_a_member_and_emits_join_chat_event()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_111UL, displayName: "AcceptLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "AcceptGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_112UL, displayName: "AcceptApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// B applies.
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// A accepts B.
|
|
var acceptResp = await clientA.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var acceptJson = await acceptResp.Content.ReadAsStringAsync();
|
|
Assert.That(acceptResp.IsSuccessStatusCode, Is.True, $"accept HTTP failed: {acceptJson}");
|
|
using var acceptDoc = JsonDocument.Parse(acceptJson);
|
|
if (acceptDoc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"accept returned error: {acceptJson}");
|
|
|
|
// B is now a member.
|
|
var bInfoResp = await clientB.PostAsync("/guild/info",
|
|
JsonContent.Create(new { viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var bInfoJson = await bInfoResp.Content.ReadAsStringAsync();
|
|
using var bInfoDoc = JsonDocument.Parse(bInfoJson);
|
|
Assert.That(GetStringifiedInt(bInfoDoc.RootElement, "guild_status"), Is.EqualTo(2),
|
|
$"B must be a member (guild_status=2) after accept, got: {bInfoJson}");
|
|
|
|
// A's join_request_list is now empty.
|
|
var jrlResp = await clientA.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var jrlDoc = JsonDocument.Parse(await jrlResp.Content.ReadAsStringAsync());
|
|
Assert.That(jrlDoc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(0),
|
|
"join_request_list must be empty after accept");
|
|
|
|
// GuildService.CommitJoinAsync calls IGuildChatService.EmitSystemEventAsync(Join).
|
|
// That service is a no-op stub (T15 will implement it), so we can't assert a DB row here.
|
|
// Confirmed the call path via code inspection; the DB assertion will land with T15.
|
|
}
|
|
|
|
[Test]
|
|
public async Task Accept_consumes_applicant_pending_invites()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_113UL, displayName: "AcceptInvLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "AcceptInvGuild", joinCondition: 2);
|
|
|
|
// Separate guild that invites B (to ensure invites are cleared on accept).
|
|
long viewerC = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_114UL, displayName: "OtherLeader");
|
|
using var clientC = factory.CreateAuthenticatedClient(viewerC);
|
|
await CreateGuildAndGetIdAsync(clientC, "OtherGuild", joinCondition: 1);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_115UL, displayName: "AcceptInvApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// C invites B.
|
|
await clientC.PostAsync("/guild/invite",
|
|
JsonContent.Create(new { invited_viewer_id = (int)viewerB, invite_message = "",
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// B applies to A's guild.
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// A accepts B.
|
|
var acceptResp = await clientA.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
Assert.That(acceptResp.IsSuccessStatusCode, Is.True);
|
|
|
|
// B's invited_guild_list must now be empty (invite consumed by CommitJoinAsync).
|
|
var invitedList = await clientB.PostAsync("/guild/invited_guild_list",
|
|
JsonContent.Create(new { page = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
using var ilDoc = JsonDocument.Parse(await invitedList.Content.ReadAsStringAsync());
|
|
Assert.That(ilDoc.RootElement.GetProperty("list").GetArrayLength(), Is.EqualTo(0),
|
|
"Pending invites must be consumed when accept commits join");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Accept_non_leader_returns_error()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_116UL, displayName: "AcceptPermLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "AcceptPermGuild", joinCondition: 2);
|
|
|
|
// B is a regular member of A's guild (joined via FREE — repurpose guild as mixed joinCondition by seeding directly).
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_117UL, displayName: "RegularMemberAccept");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
// B joins A's guild (change to joinCondition: 1 is needed; create separate FREE guild for B to join and then act as non-leader).
|
|
// Simplest: just have B NOT in any guild → NotInGuild → but we need PermissionDenied specifically.
|
|
// Use a separate FREE guild so B can join it, then try to accept on A's guild (not B's guild → different result).
|
|
// Better: A creates an approval guild, B applies to a 3rd guild, then B (not in A's guild) tries to accept → NotInGuild.
|
|
// For PermissionDenied specifically: need B in A's guild as Regular. Let's create a second client in A's guild.
|
|
long viewerD = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_118UL, displayName: "FreeGuildLeader");
|
|
using var clientD = factory.CreateAuthenticatedClient(viewerD);
|
|
// D creates a FREE guild, B joins it (B becomes Regular in D's guild, not A's approval guild).
|
|
int dGuildId = await CreateGuildAndGetIdAsync(clientD, "FreeGuildForPerm", joinCondition: 1);
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = dGuildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// Now have C apply to A's guild.
|
|
long viewerC = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_119UL, displayName: "ApplicantForPerm");
|
|
using var clientC = factory.CreateAuthenticatedClient(viewerC);
|
|
await clientC.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// B (Regular member of D's guild, NOT in A's guild) tries to accept C's request on A's guild → NotInGuild error.
|
|
var acceptResp = await clientB.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerC,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var acceptJson = await acceptResp.Content.ReadAsStringAsync();
|
|
Assert.That(acceptResp.IsSuccessStatusCode, Is.True, "HTTP must be 200");
|
|
using var acceptDoc = JsonDocument.Parse(acceptJson);
|
|
Assert.That(acceptDoc.RootElement.TryGetProperty("result_code", out var rc), Is.True,
|
|
$"Expected error from non-guild-member accept, got: {acceptJson}");
|
|
Assert.That(rc.GetInt32(), Is.EqualTo(2), $"Non-guild-member accept must return error, got: {acceptJson}");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Accept_full_guild_returns_error()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
// Cap at 2 members so we can fill the guild (leader + 1 member) then try to accept a 3rd.
|
|
using (var scope = factory.Services.CreateScope())
|
|
{
|
|
var db = scope.ServiceProvider.GetRequiredService<SVSim.Database.SVSimDbContext>();
|
|
const string json = "{\"MaxMemberNum\":2,\"MaxSubLeaderNum\":3,\"SearchResultCap\":20,\"UsableStampList\":[1,2,3,4,5]}";
|
|
var existing = db.GameConfigs.FirstOrDefault(s => s.SectionName == "Guild");
|
|
if (existing is null)
|
|
db.GameConfigs.Add(new SVSim.Database.Models.GameConfigSection { SectionName = "Guild", ValueJson = json });
|
|
else
|
|
existing.ValueJson = json;
|
|
db.SaveChanges();
|
|
}
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_121UL, displayName: "CapAcceptLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "CapAcceptGuild", joinCondition: 2);
|
|
|
|
// B applies and gets accepted (fills slot 2/2).
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_122UL, displayName: "CapAcceptMember");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
await clientA.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// C also applies.
|
|
long viewerC = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_123UL, displayName: "CapAcceptApplicant");
|
|
using var clientC = factory.CreateAuthenticatedClient(viewerC);
|
|
await clientC.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// A tries to accept C, but guild is now full.
|
|
var acceptResp = await clientA.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerC,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var acceptJson = await acceptResp.Content.ReadAsStringAsync();
|
|
Assert.That(acceptResp.IsSuccessStatusCode, Is.True, "HTTP must be 200");
|
|
using var acceptDoc = JsonDocument.Parse(acceptJson);
|
|
Assert.That(acceptDoc.RootElement.TryGetProperty("result_code", out var rc), Is.True,
|
|
$"Expected error when guild is full, got: {acceptJson}");
|
|
Assert.That(rc.GetInt32(), Is.EqualTo(2), $"Full guild accept must return error, got: {acceptJson}");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Accept_nonexistent_request_returns_error()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_131UL, displayName: "NotFoundLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
await CreateGuildAndGetIdAsync(clientA, "NotFoundGuild", joinCondition: 2);
|
|
|
|
// No applicant — accept a viewer_id that never applied.
|
|
var acceptResp = await clientA.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = 999_999,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var acceptJson = await acceptResp.Content.ReadAsStringAsync();
|
|
Assert.That(acceptResp.IsSuccessStatusCode, Is.True, "HTTP must be 200");
|
|
using var acceptDoc = JsonDocument.Parse(acceptJson);
|
|
Assert.That(acceptDoc.RootElement.TryGetProperty("result_code", out var rc), Is.True,
|
|
$"Expected error for non-existent request, got: {acceptJson}");
|
|
Assert.That(rc.GetInt32(), Is.EqualTo(2), $"Non-existent accept must return error, got: {acceptJson}");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Accept_already_resolved_request_returns_error()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_141UL, displayName: "AlreadyResolvedLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "AlreadyResolvedGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_142UL, displayName: "AlreadyResolvedApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// B applies and A accepts first time — request is now Accepted.
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var firstAccept = await clientA.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
Assert.That(firstAccept.IsSuccessStatusCode, Is.True, "First accept must succeed");
|
|
|
|
// A tries to accept again — request already resolved.
|
|
var secondAccept = await clientA.PostAsync("/guild/join_request_accept",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var secondAcceptJson = await secondAccept.Content.ReadAsStringAsync();
|
|
Assert.That(secondAccept.IsSuccessStatusCode, Is.True, "HTTP must be 200");
|
|
using var secondDoc = JsonDocument.Parse(secondAcceptJson);
|
|
Assert.That(secondDoc.RootElement.TryGetProperty("result_code", out var rc), Is.True,
|
|
$"Expected error on double-accept, got: {secondAcceptJson}");
|
|
Assert.That(rc.GetInt32(), Is.EqualTo(2), $"Double-accept must return error, got: {secondAcceptJson}");
|
|
}
|
|
|
|
// ─── reject_join_request ─────────────────────────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Reject_flips_status_no_membership_no_chat_event()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_151UL, displayName: "RejectLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "RejectGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_152UL, displayName: "RejectApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// B applies.
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// A rejects B.
|
|
var rejectResp = await clientA.PostAsync("/guild/reject_join_request",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var rejectJson = await rejectResp.Content.ReadAsStringAsync();
|
|
Assert.That(rejectResp.IsSuccessStatusCode, Is.True, $"reject HTTP failed: {rejectJson}");
|
|
using var rejectDoc = JsonDocument.Parse(rejectJson);
|
|
if (rejectDoc.RootElement.TryGetProperty("result_code", out var rc))
|
|
Assert.That(rc.GetInt32(), Is.Not.EqualTo(2), $"reject returned error: {rejectJson}");
|
|
|
|
// B must NOT be a member (guild_status=0).
|
|
var bInfoResp = await clientB.PostAsync("/guild/info",
|
|
JsonContent.Create(new { viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var bInfoJson = await bInfoResp.Content.ReadAsStringAsync();
|
|
using var bInfoDoc = JsonDocument.Parse(bInfoJson);
|
|
Assert.That(GetStringifiedInt(bInfoDoc.RootElement, "guild_status"), Is.EqualTo(0),
|
|
$"B must NOT be a member after reject (guild_status=0), got: {bInfoJson}");
|
|
|
|
// No Join chat event (IGuildChatService.EmitSystemEventAsync is a no-op stub until T15 — no DB row expected).
|
|
using var scope = factory.Services.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<SVSim.Database.SVSimDbContext>();
|
|
var hasJoinEvent = db.GuildChatMessages
|
|
.Any(m => m.GuildId == guildId && m.AuthorViewerId == viewerB
|
|
&& m.MessageType == SVSim.Database.Entities.Guild.GuildChatMessageType.Join);
|
|
Assert.That(hasJoinEvent, Is.False, "No Join chat event should exist after reject");
|
|
}
|
|
|
|
[Test]
|
|
public async Task Reject_already_resolved_request_returns_error()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_161UL, displayName: "RejectDoubleLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "RejectDoubleGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_162UL, displayName: "RejectDoubleApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
|
|
// B applies, A rejects once.
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
await clientA.PostAsync("/guild/reject_join_request",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
// A tries to reject again.
|
|
var secondReject = await clientA.PostAsync("/guild/reject_join_request",
|
|
JsonContent.Create(new { request_viewer_id = (int)viewerB,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var secondRejectJson = await secondReject.Content.ReadAsStringAsync();
|
|
Assert.That(secondReject.IsSuccessStatusCode, Is.True, "HTTP must be 200");
|
|
using var secondDoc = JsonDocument.Parse(secondRejectJson);
|
|
Assert.That(secondDoc.RootElement.TryGetProperty("result_code", out var rc), Is.True,
|
|
$"Expected error on double-reject, got: {secondRejectJson}");
|
|
Assert.That(rc.GetInt32(), Is.EqualTo(2), $"Double-reject must return error, got: {secondRejectJson}");
|
|
}
|
|
|
|
// ─── Wire-shape test for join_request_list ───────────────────────────────────
|
|
|
|
[Test]
|
|
public async Task Join_request_list_response_shape_is_correct()
|
|
{
|
|
using var factory = new SVSimTestFactory();
|
|
|
|
long viewerA = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_101UL, displayName: "ShapeLeader");
|
|
using var clientA = factory.CreateAuthenticatedClient(viewerA);
|
|
int guildId = await CreateGuildAndGetIdAsync(clientA, "ShapeGuild", joinCondition: 2);
|
|
|
|
long viewerB = await factory.SeedViewerAsync(steamId: 76_561_198_400_000_102UL, displayName: "ShapeApplicant");
|
|
using var clientB = factory.CreateAuthenticatedClient(viewerB);
|
|
await clientB.PostAsync("/guild/join",
|
|
JsonContent.Create(new { guild_id = guildId, from_invite = false,
|
|
viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
|
|
var jrlResp = await clientA.PostAsync("/guild/join_request_list",
|
|
JsonContent.Create(new { page = 0, oldest_time = 0, viewer_id = Vid, steam_id = Sid, steam_session_ticket = Stk }));
|
|
var jrlJson = await jrlResp.Content.ReadAsStringAsync();
|
|
Assert.That(jrlResp.IsSuccessStatusCode, Is.True, $"join_request_list failed: {jrlJson}");
|
|
|
|
using var doc = JsonDocument.Parse(jrlJson);
|
|
var list = doc.RootElement.GetProperty("list");
|
|
Assert.That(list.GetArrayLength(), Is.EqualTo(1), $"Expected 1 entry, got: {jrlJson}");
|
|
|
|
var entry = list[0];
|
|
|
|
// GuildUserInfo fields (flat siblings per GuildUserInfo constructor) + request-list extras.
|
|
string[] requiredFields = [
|
|
"viewer_id", "name", "emblem_id", "country_code", "rank", "degree_id",
|
|
"is_official_mark_displayed", "request_time"
|
|
];
|
|
foreach (var field in requiredFields)
|
|
{
|
|
Assert.That(entry.TryGetProperty(field, out _), Is.True,
|
|
$"Field '{field}' must be present in join_request_list entry, got: {jrlJson}");
|
|
}
|
|
|
|
// request_time must be a positive integer (unix seconds, NOT milliseconds).
|
|
Assert.That(entry.GetProperty("request_time").GetInt64(), Is.GreaterThan(0),
|
|
"request_time must be a positive unix seconds timestamp");
|
|
|
|
// viewer_id is stringified — must parse as a valid long.
|
|
Assert.That(long.TryParse(entry.GetProperty("viewer_id").GetString(), out var parsedId), Is.True,
|
|
$"viewer_id must be stringified long, got: {jrlJson}");
|
|
Assert.That(parsedId, Is.EqualTo(viewerB), "viewer_id must match the applicant");
|
|
}
|
|
}
|