tiku-backend.net/Tiku.IntegrationTests/Api/ReferralEndpointTests.cs

using System.Net;
using System.Net.Http.Json;
using System.Text.Json;
using Microsoft.Extensions.DependencyInjection;
using Tiku.Api.Contracts;
using Tiku.Application.Auth;
using Tiku.Application.Growth;
using Tiku.Domain.Growth;
using Tiku.Domain.Identity;
using Tiku.Domain.Tenancy;
using Tiku.Infrastructure.Auth;
using Tiku.Infrastructure.Persistence;

namespace Tiku.IntegrationTests.Api;

public sealed class ReferralEndpointTests
{
    [Fact]
    public async Task Anonymous_invite_code_request_returns_401()
    {
        await using var factory = new ApiTestFactory();
        using var client = factory.CreateClient();

        var response = await client.PostAsJsonAsync("/api/referral/invite-code", new ReferralInviteDto());

        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
    }

    [Fact]
    public async Task Member_can_create_invite_code_idempotently()
    {
        await using var factory = new ApiTestFactory();
        var seed = await SeedReferralAsync(factory);
        using var client = factory.CreateClient();
        await LoginAsync(client, seed.Referrer);

        var first = await client.PostAsJsonAsync("/api/referral/invite-code", new ReferralInviteDto { Channel = "h5" });
        var second = await client.PostAsJsonAsync("/api/referral/invite-code", new ReferralInviteDto());
        var firstItem = await first.Content.ReadFromJsonAsync<ReferralInviteItem>();
        var secondItem = await second.Content.ReadFromJsonAsync<ReferralInviteItem>();

        Assert.Equal(HttpStatusCode.OK, first.StatusCode);
        Assert.Equal(HttpStatusCode.OK, second.StatusCode);
        Assert.Equal(firstItem!.InviteCode, secondItem!.InviteCode);
    }

    [Fact]
    public async Task Anonymous_can_resolve_and_track_referral_code()
    {
        await using var factory = new ApiTestFactory();
        var seed = await SeedReferralAsync(factory, includeCode: true);
        using var client = factory.CreateClient();

        var resolve = await client.PostAsJsonAsync(
            "/api/referral/resolve",
            new ResolveReferralDto { TenantCode = seed.TenantCode, Code = seed.ReferralCode });
        var track = await client.PostAsJsonAsync(
            "/api/referral/track-event",
            new TrackReferralEventDto
            {
                TenantCode = seed.TenantCode,
                RefCode = seed.ReferralCode,
                EventType = "enter",
                Source = "qrcode",
                TargetUserId = seed.Student.UserId,
                Metadata = JsonSerializer.SerializeToElement(new { page = "landing" })
            });
        var resolution = await resolve.Content.ReadFromJsonAsync<ReferralResolutionItem>();
        var tracked = await track.Content.ReadFromJsonAsync<ReferralTrackResult>();

        Assert.Equal(HttpStatusCode.OK, resolve.StatusCode);
        Assert.True(resolution!.Valid);
        Assert.Equal(seed.Referrer.UserId, resolution.InviterId);
        Assert.Equal(HttpStatusCode.OK, track.StatusCode);
        Assert.Equal(seed.Referrer.UserId, tracked!.Item.ReferrerUserId);
        Assert.Equal(seed.Student.UserId, tracked.Item.TargetUserId);
        Assert.NotNull(tracked.Lead);
    }

    [Fact]
    public async Task Member_can_bind_referral_and_create_qrcode()
    {
        await using var factory = new ApiTestFactory();
        var seed = await SeedReferralAsync(factory, includeCode: true);
        using var client = factory.CreateClient();
        await LoginAsync(client, seed.Student);

        var bind = await client.PostAsJsonAsync(
            "/api/referral/bind",
            new BindReferralDto { RefCode = seed.ReferralCode, Source = "miniapp" });
        var repeatBind = await client.PostAsJsonAsync(
            "/api/referral/bind",
            new BindReferralDto { RefCode = seed.ReferralCode, Source = "miniapp" });
        var qrcode = await client.PostAsJsonAsync(
            "/api/referral/qrcode",
            new ReferralQrcodeDto { Page = "pages/home/index", Provider = "wechat-miniapp" });
        var bindItem = await bind.Content.ReadFromJsonAsync<ReferralBindResult>();
        var repeatItem = await repeatBind.Content.ReadFromJsonAsync<ReferralBindResult>();
        var qrcodeItem = await qrcode.Content.ReadFromJsonAsync<ReferralQrcodeItem>();

        Assert.Equal(HttpStatusCode.OK, bind.StatusCode);
        Assert.Equal(HttpStatusCode.OK, repeatBind.StatusCode);
        Assert.True(bindItem!.Lead.Changed);
        Assert.False(repeatItem!.Lead.Changed);
        Assert.Equal(seed.Referrer.UserId, bindItem.Lead.ReferrerUserId);
        Assert.Equal(HttpStatusCode.OK, qrcode.StatusCode);
        Assert.Equal("Ready", qrcodeItem!.Status);
        Assert.StartsWith("miniapp://", qrcodeItem.QrcodeUrl, StringComparison.Ordinal);

        using var scope = factory.Services.CreateScope();
        var dbContext = scope.ServiceProvider.GetRequiredService<TikuDbContext>();
        Assert.Contains(dbContext.ReferralLeads, item =>
            item.TenantId == seed.TenantId &&
            item.StudentUserId == seed.Student.UserId &&
            item.ReferrerUserId == seed.Referrer.UserId);
        Assert.Contains(dbContext.ReferralQrcodes, item =>
            item.TenantId == seed.TenantId &&
            item.UserId == seed.Student.UserId);
    }

    [Fact]
    public async Task Anonymous_referral_without_tenant_returns_404()
    {
        await using var factory = new ApiTestFactory();
        using var client = factory.CreateClient();

        var response = await client.PostAsJsonAsync(
            "/api/referral/resolve",
            new ResolveReferralDto { Code = "ABC12345" });

        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
    }

    private static async Task<ReferralSeed> SeedReferralAsync(
        ApiTestFactory factory,
        bool includeCode = false)
    {
        var tenantId = Guid.NewGuid();
        var tenantCode = tenantId.ToString("N");
        var referrer = new LoginSeed(tenantId, Guid.NewGuid(), "13800001001");
        var student = new LoginSeed(tenantId, Guid.NewGuid(), "13800001002");
        const string referralCode = "ABC12345";
        var entities = new List<object>
        {
            new Tenant { Id = tenantId, Slug = tenantCode, Name = "Referral Tenant" },
            User(referrer.UserId, referrer.Phone, "Referral Teacher", "teacher"),
            User(student.UserId, student.Phone, "Referral Student", "student"),
            Identity(referrer),
            Identity(student),
            new TenantMembership
            {
                TenantId = tenantId,
                UserId = referrer.UserId,
                Role = TenantRole.Sales,
                Status = MembershipStatus.Active
            },
            new TenantMembership
            {
                TenantId = tenantId,
                UserId = student.UserId,
                Role = TenantRole.Student,
                Status = MembershipStatus.Active
            }
        };
        if (includeCode)
        {
            entities.Add(new ReferralCode
            {
                TenantId = tenantId,
                UserId = referrer.UserId,
                Code = referralCode,
                Status = ReferralCodeStatus.Active
            });
        }

        await factory.SeedAsync(entities.ToArray());
        return new ReferralSeed(tenantId, tenantCode, referrer, student, referralCode);
    }

    private static User User(Guid userId, string phone, string name, string role)
    {
        return new User
        {
            Id = userId,
            Phone = phone,
            Name = name,
            PrimaryRole = role
        };
    }

    private static UserIdentity Identity(LoginSeed seed)
    {
        return new UserIdentity
        {
            UserId = seed.UserId,
            Provider = "password",
            ProviderSubject = seed.Phone,
            Phone = seed.Phone,
            SecretPayload = CreateSecretPayload(new PasswordHasher().Hash("passw0rd!"))
        };
    }

    private static async Task LoginAsync(HttpClient client, LoginSeed seed)
    {
        var loginResponse = await client.PostAsJsonAsync(
            "/api/auth/login/password",
            new PasswordLoginDto
            {
                TenantId = seed.TenantId,
                Phone = seed.Phone,
                Password = "passw0rd!"
            });
        loginResponse.EnsureSuccessStatusCode();
        using var loginJson = await JsonDocument.ParseAsync(await loginResponse.Content.ReadAsStreamAsync());
        var accessToken = loginJson.RootElement
            .GetProperty("tokens")
            .GetProperty("accessToken")
            .GetString();
        client.DefaultRequestHeaders.Authorization = new("Bearer", accessToken);
    }

    private static JsonElement CreateSecretPayload(string passwordHash)
    {
        using var document = JsonDocument.Parse(
            $$"""{"passwordHash":{{JsonSerializer.Serialize(passwordHash)}}}""");
        return document.RootElement.Clone();
    }

    private sealed record LoginSeed(Guid TenantId, Guid UserId, string Phone);

    private sealed record ReferralSeed(
        Guid TenantId,
        string TenantCode,
        LoginSeed Referrer,
        LoginSeed Student,
        string ReferralCode);
}