1787 lines
64 KiB
Go
1787 lines
64 KiB
Go
package host_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"hyapp/pkg/xerr"
|
|
hostdomain "hyapp/services/user-service/internal/domain/host"
|
|
userdomain "hyapp/services/user-service/internal/domain/user"
|
|
hostservice "hyapp/services/user-service/internal/service/host"
|
|
"hyapp/services/user-service/internal/testutil/mysqltest"
|
|
)
|
|
|
|
type sequenceIDGenerator struct {
|
|
next int64
|
|
}
|
|
|
|
func (g *sequenceIDGenerator) NewInt64() int64 {
|
|
id := g.next
|
|
g.next++
|
|
return id
|
|
}
|
|
|
|
func newHostService(repository *mysqltest.Repository, firstID int64, nowMs int64) *hostservice.Service {
|
|
return hostservice.New(repository.HostRepository(),
|
|
hostservice.WithIDGenerator(&sequenceIDGenerator{next: firstID}),
|
|
hostservice.WithClock(func() time.Time { return time.UnixMilli(nowMs) }),
|
|
)
|
|
}
|
|
|
|
func seedActiveUser(t *testing.T, repository *mysqltest.Repository, userID int64, regionID int64) {
|
|
t.Helper()
|
|
seedActiveUserInCountry(t, repository, userID, regionID, "CN", "")
|
|
}
|
|
|
|
func seedActiveUserInCountry(t *testing.T, repository *mysqltest.Repository, userID int64, regionID int64, country string, avatar string) {
|
|
t.Helper()
|
|
repository.PutUser(userdomain.User{
|
|
UserID: userID,
|
|
DefaultDisplayUserID: displayID(userID),
|
|
CurrentDisplayUserID: displayID(userID),
|
|
Country: country,
|
|
RegionID: regionID,
|
|
Avatar: avatar,
|
|
ProfileCompleted: true,
|
|
ProfileCompletedAtMs: 1,
|
|
OnboardingStatus: userdomain.OnboardingStatusCompleted,
|
|
Status: userdomain.StatusActive,
|
|
})
|
|
}
|
|
|
|
func seedActiveMembership(t *testing.T, repository *mysqltest.Repository, membershipID int64, agencyID int64, hostUserID int64, membershipType string) {
|
|
t.Helper()
|
|
if membershipType == "" {
|
|
membershipType = hostdomain.MembershipTypeMember
|
|
}
|
|
_, err := repository.RawDB().Exec(`
|
|
INSERT INTO agency_memberships (
|
|
membership_id, agency_id, host_user_id, membership_type, status,
|
|
joined_at_ms, created_at_ms, updated_at_ms
|
|
) VALUES (?, ?, ?, ?, ?, 1, 1, 1)
|
|
`, membershipID, agencyID, hostUserID, membershipType, hostdomain.MembershipStatusActive)
|
|
if err != nil {
|
|
t.Fatalf("seed active membership %d failed: %v", membershipID, err)
|
|
}
|
|
}
|
|
|
|
func displayID(userID int64) string {
|
|
return fmt.Sprintf("%06d", 900000+userID%100000)
|
|
}
|
|
|
|
func assertNoHostOrgRegionSnapshotColumns(t *testing.T, repository *mysqltest.Repository) {
|
|
t.Helper()
|
|
var count int64
|
|
err := repository.RawDB().QueryRow(`
|
|
SELECT COUNT(*)
|
|
FROM information_schema.COLUMNS
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND COLUMN_NAME = 'region_id'
|
|
AND TABLE_NAME IN (
|
|
'host_profiles',
|
|
'manager_profiles',
|
|
'bd_profiles',
|
|
'bd_leader_profiles',
|
|
'agencies',
|
|
'agency_memberships',
|
|
'agency_applications',
|
|
'role_invitations'
|
|
)
|
|
`).Scan(&count)
|
|
if err != nil {
|
|
t.Fatalf("check host org region snapshot columns failed: %v", err)
|
|
}
|
|
if count != 0 {
|
|
t.Fatalf("host org identity tables must not keep region_id snapshot columns: count=%d", count)
|
|
}
|
|
}
|
|
|
|
func TestCheckBusinessCapabilityRequiresActiveManagerProfile(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 101, 10)
|
|
seedActiveUser(t, repository, 202, 10)
|
|
seedActiveUser(t, repository, 303, 10)
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 301,
|
|
OwnerUserID: 202,
|
|
RegionID: 10,
|
|
Name: "Agency Owner Is Not Manager",
|
|
Status: hostdomain.AgencyStatusActive,
|
|
})
|
|
repository.PutManagerProfile(hostdomain.ManagerProfile{
|
|
UserID: 101,
|
|
Status: hostdomain.ManagerStatusActive,
|
|
})
|
|
repository.PutManagerProfile(hostdomain.ManagerProfile{
|
|
UserID: 303,
|
|
Status: hostdomain.ManagerStatusDisabled,
|
|
})
|
|
svc := newHostService(repository, 1000, 2000)
|
|
|
|
allowed, reason, err := svc.CheckBusinessCapability(ctx, 101, hostservice.CapabilityManagerResourceGrant)
|
|
if err != nil {
|
|
t.Fatalf("CheckBusinessCapability for manager failed: %v", err)
|
|
}
|
|
if !allowed || reason != "" {
|
|
t.Fatalf("active manager should be allowed: allowed=%v reason=%q", allowed, reason)
|
|
}
|
|
|
|
repository.SetManagerGrantVIP(101, false)
|
|
allowed, reason, err = svc.CheckBusinessCapability(ctx, 101, hostservice.CapabilityManagerGrantVIP)
|
|
if err != nil {
|
|
t.Fatalf("CheckBusinessCapability for vip grant failed: %v", err)
|
|
}
|
|
if allowed || reason != "manager_capability_required" {
|
|
t.Fatalf("manager without vip grant should be denied: allowed=%v reason=%q", allowed, reason)
|
|
}
|
|
|
|
allowed, reason, err = svc.CheckBusinessCapability(ctx, 202, hostservice.CapabilityManagerResourceGrant)
|
|
if err != nil {
|
|
t.Fatalf("CheckBusinessCapability for agency owner failed: %v", err)
|
|
}
|
|
if allowed || reason != "active_manager_required" {
|
|
t.Fatalf("agency owner without manager profile should be denied: allowed=%v reason=%q", allowed, reason)
|
|
}
|
|
|
|
allowed, reason, err = svc.CheckBusinessCapability(ctx, 303, hostservice.CapabilityManagerCenter)
|
|
if err != nil {
|
|
t.Fatalf("CheckBusinessCapability for disabled manager failed: %v", err)
|
|
}
|
|
if allowed || reason != "active_manager_required" {
|
|
t.Fatalf("disabled manager should be denied: allowed=%v reason=%q", allowed, reason)
|
|
}
|
|
|
|
allowed, _, err = svc.CheckBusinessCapability(ctx, 101, "unknown_capability")
|
|
if !xerr.IsCode(err, xerr.InvalidArgument) || allowed {
|
|
t.Fatalf("unknown capability must fail closed: allowed=%v err=%v", allowed, err)
|
|
}
|
|
}
|
|
|
|
func TestApplyReviewApproveCreatesHostMembershipIdempotently(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 101, 10)
|
|
seedActiveUser(t, repository, 202, 10)
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 301,
|
|
OwnerUserID: 101,
|
|
RegionID: 10,
|
|
ParentBDUserID: 501,
|
|
Name: "Phase One Agency",
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
CreatedAtMs: 100,
|
|
UpdatedAtMs: 100,
|
|
})
|
|
svc := newHostService(repository, 1000, 2000)
|
|
|
|
application, err := svc.ApplyToAgency(ctx, hostservice.ApplyToAgencyInput{
|
|
CommandID: "apply-202-301",
|
|
UserID: 202,
|
|
AgencyID: 301,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ApplyToAgency failed: %v", err)
|
|
}
|
|
if application.Status != hostdomain.ApplicationStatusPending || application.RegionID != 10 {
|
|
t.Fatalf("application mismatch: %+v", application)
|
|
}
|
|
|
|
retriedApplication, err := svc.ApplyToAgency(ctx, hostservice.ApplyToAgencyInput{
|
|
CommandID: "apply-202-301",
|
|
UserID: 202,
|
|
AgencyID: 301,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("retry ApplyToAgency failed: %v", err)
|
|
}
|
|
if retriedApplication.ApplicationID != application.ApplicationID {
|
|
t.Fatalf("apply retry must return same application: got %d want %d", retriedApplication.ApplicationID, application.ApplicationID)
|
|
}
|
|
|
|
result, err := svc.ReviewAgencyApplication(ctx, hostservice.ReviewAgencyApplicationInput{
|
|
CommandID: "review-approve-202-301",
|
|
ReviewerUserID: 101,
|
|
ApplicationID: application.ApplicationID,
|
|
Decision: hostdomain.ApplicationDecisionApprove,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ReviewAgencyApplication approve failed: %v", err)
|
|
}
|
|
if result.Application.Status != hostdomain.ApplicationStatusApproved {
|
|
t.Fatalf("approved application mismatch: %+v", result.Application)
|
|
}
|
|
if result.HostProfile.UserID != 202 || result.HostProfile.CurrentAgencyID != 301 || result.Membership.Status != hostdomain.MembershipStatusActive {
|
|
t.Fatalf("host membership facts mismatch: profile=%+v membership=%+v", result.HostProfile, result.Membership)
|
|
}
|
|
|
|
retriedReview, err := svc.ReviewAgencyApplication(ctx, hostservice.ReviewAgencyApplicationInput{
|
|
CommandID: "review-approve-202-301",
|
|
ReviewerUserID: 101,
|
|
ApplicationID: application.ApplicationID,
|
|
Decision: hostdomain.ApplicationDecisionApprove,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("retry ReviewAgencyApplication failed: %v", err)
|
|
}
|
|
if retriedReview.Membership.MembershipID != result.Membership.MembershipID {
|
|
t.Fatalf("review retry must return same membership: got %d want %d", retriedReview.Membership.MembershipID, result.Membership.MembershipID)
|
|
}
|
|
|
|
_, err = svc.ApplyToAgency(ctx, hostservice.ApplyToAgencyInput{
|
|
CommandID: "apply-second-active-member",
|
|
UserID: 202,
|
|
AgencyID: 301,
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.Conflict {
|
|
t.Fatalf("active member must not create another application: got %s err=%v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestAcceptAgencyInvitationCreatesOwnerHostAndPreservesExistingHostBinding(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 501, 10)
|
|
seedActiveUser(t, repository, 601, 10)
|
|
seedActiveUser(t, repository, 602, 10)
|
|
seedActiveUser(t, repository, 603, 10)
|
|
seedActiveUser(t, repository, 604, 10)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 501,
|
|
Role: hostdomain.BDRoleBD,
|
|
RegionID: 10,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 650,
|
|
OwnerUserID: 604,
|
|
RegionID: 10,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
svc := newHostService(repository, 2000, 3000)
|
|
|
|
invitation, err := svc.InviteAgency(ctx, hostservice.InviteAgencyInput{
|
|
CommandID: "invite-agency-601",
|
|
InviterUserID: 501,
|
|
TargetUserID: 601,
|
|
AgencyName: "Owner Agency",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("InviteAgency failed: %v", err)
|
|
}
|
|
if invitation.Status != hostdomain.InvitationStatusPending {
|
|
t.Fatalf("agency invitation should wait for target accept: %+v", invitation)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-agency-601",
|
|
ActorUserID: 601,
|
|
InvitationID: invitation.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("ProcessRoleInvitation accept agency failed: %v", err)
|
|
}
|
|
summary, err := svc.GetUserRoleSummary(ctx, 601)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary failed: %v", err)
|
|
}
|
|
agency, err := svc.GetAgency(ctx, summary.AgencyID)
|
|
if err != nil {
|
|
t.Fatalf("GetAgency failed: %v", err)
|
|
}
|
|
hostProfile, err := svc.GetHostProfile(ctx, 601)
|
|
if err != nil {
|
|
t.Fatalf("GetHostProfile failed: %v", err)
|
|
}
|
|
if !summary.IsAgency || !summary.IsHost || agency.OwnerUserID != 601 || hostProfile.CurrentAgencyID != agency.AgencyID {
|
|
t.Fatalf("owner agency facts mismatch: summary=%+v agency=%+v host=%+v", summary, agency, hostProfile)
|
|
}
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 602,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 10,
|
|
Source: "test",
|
|
})
|
|
secondInvitation, err := svc.InviteAgency(ctx, hostservice.InviteAgencyInput{
|
|
CommandID: "invite-agency-602",
|
|
InviterUserID: 501,
|
|
TargetUserID: 602,
|
|
AgencyName: "Reused Host Agency",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("detached active host should become agency owner: %v", err)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-agency-602",
|
|
ActorUserID: 602,
|
|
InvitationID: secondInvitation.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("ProcessRoleInvitation accept detached host agency failed: %v", err)
|
|
}
|
|
secondSummary, err := svc.GetUserRoleSummary(ctx, 602)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary for reused host failed: %v", err)
|
|
}
|
|
secondHostProfile, err := svc.GetHostProfile(ctx, 602)
|
|
if err != nil {
|
|
t.Fatalf("GetHostProfile for reused host failed: %v", err)
|
|
}
|
|
if !secondSummary.IsAgency || !secondSummary.IsHost || secondHostProfile.CurrentAgencyID <= 0 || secondHostProfile.Source != "test" || secondInvitation.Status != hostdomain.InvitationStatusPending {
|
|
t.Fatalf("detached host reuse mismatch: summary=%+v host=%+v invitation=%+v", secondSummary, secondHostProfile, secondInvitation)
|
|
}
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 603,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 10,
|
|
CurrentAgencyID: 650,
|
|
CurrentMembershipID: 660,
|
|
Source: "existing-membership",
|
|
})
|
|
seedActiveMembership(t, repository, 660, 650, 603, hostdomain.MembershipTypeMember)
|
|
boundHostInvitation, err := svc.InviteAgency(ctx, hostservice.InviteAgencyInput{
|
|
CommandID: "invite-agency-603-bound-host",
|
|
InviterUserID: 501,
|
|
TargetUserID: 603,
|
|
AgencyName: "Bound Host Agency",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("active bound host should still be invitable as agency owner: %v", err)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-agency-603-bound-host",
|
|
ActorUserID: 603,
|
|
InvitationID: boundHostInvitation.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("ProcessRoleInvitation accept bound host agency failed: %v", err)
|
|
}
|
|
boundHostProfile, err := svc.GetHostProfile(ctx, 603)
|
|
if err != nil {
|
|
t.Fatalf("GetHostProfile for bound host failed: %v", err)
|
|
}
|
|
boundSummary, err := svc.GetUserRoleSummary(ctx, 603)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary for bound host failed: %v", err)
|
|
}
|
|
if !boundSummary.IsAgency || !boundSummary.IsHost || boundHostProfile.CurrentAgencyID != 650 || boundHostProfile.CurrentMembershipID != 660 {
|
|
t.Fatalf("agency owner must not overwrite existing host binding: summary=%+v host=%+v", boundSummary, boundHostProfile)
|
|
}
|
|
}
|
|
|
|
func TestAcceptHostInvitationDoesNotGrantAgencyIdentity(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 611, 10)
|
|
seedActiveUser(t, repository, 612, 10)
|
|
seedActiveUser(t, repository, 613, 10)
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 620,
|
|
OwnerUserID: 611,
|
|
RegionID: 10,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 611,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 10,
|
|
CurrentAgencyID: 620,
|
|
CurrentMembershipID: 621,
|
|
Source: hostdomain.HostSourceAgencyInvitation,
|
|
})
|
|
svc := newHostService(repository, 630, 640)
|
|
|
|
invitation, err := svc.InviteHost(ctx, hostservice.InviteHostInput{
|
|
CommandID: "invite-host-612",
|
|
InviterUserID: 611,
|
|
TargetUserID: 612,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("InviteHost failed: %v", err)
|
|
}
|
|
result, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-host-612",
|
|
ActorUserID: 612,
|
|
InvitationID: invitation.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ProcessRoleInvitation accept host failed: %v", err)
|
|
}
|
|
if result.Membership.MembershipType != hostdomain.MembershipTypeMember || result.HostProfile.Source != hostdomain.HostSourceHostInvitation {
|
|
t.Fatalf("host invitation should create member-only host facts: result=%+v", result)
|
|
}
|
|
summary, err := svc.GetUserRoleSummary(ctx, 612)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary host member failed: %v", err)
|
|
}
|
|
if !summary.IsHost || summary.IsAgency || summary.AgencyID != 0 {
|
|
t.Fatalf("ordinary host member must not expose agency identity: %+v", summary)
|
|
}
|
|
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 613,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 10,
|
|
CurrentAgencyID: 620,
|
|
CurrentMembershipID: 622,
|
|
Source: hostdomain.HostSourceAgencyInvitation,
|
|
})
|
|
legacySummary, err := svc.GetUserRoleSummary(ctx, 613)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary legacy host member failed: %v", err)
|
|
}
|
|
if !legacySummary.IsHost || legacySummary.IsAgency || legacySummary.AgencyID != 0 {
|
|
t.Fatalf("legacy host member source must not imply agency identity: %+v", legacySummary)
|
|
}
|
|
|
|
ownerSummary, err := svc.GetUserRoleSummary(ctx, 611)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary owner failed: %v", err)
|
|
}
|
|
if !ownerSummary.IsHost || !ownerSummary.IsAgency || ownerSummary.AgencyID != 620 {
|
|
t.Fatalf("agency owner should keep agency identity: %+v", ownerSummary)
|
|
}
|
|
}
|
|
|
|
func TestKickAgencyHostDisablesOrdinaryHostIdentity(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 621, 10)
|
|
seedActiveUser(t, repository, 622, 10)
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 623,
|
|
OwnerUserID: 621,
|
|
RegionID: 10,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 622,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 10,
|
|
CurrentAgencyID: 623,
|
|
CurrentMembershipID: 624,
|
|
Source: hostdomain.HostSourceHostInvitation,
|
|
})
|
|
seedActiveMembership(t, repository, 624, 623, 622, hostdomain.MembershipTypeMember)
|
|
svc := newHostService(repository, 625, 640)
|
|
|
|
result, err := svc.KickAgencyHost(ctx, hostservice.KickAgencyHostInput{
|
|
CommandID: "kick-host-622",
|
|
OperatorUserID: 621,
|
|
AgencyID: 623,
|
|
HostUserID: 622,
|
|
Reason: "agency_remove",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("KickAgencyHost failed: %v", err)
|
|
}
|
|
if result.Membership.Status != hostdomain.MembershipStatusEnded || result.Membership.EndedAtMs != 640 || result.Membership.EndedByUserID != 621 || result.Membership.EndedReason != "agency_remove" {
|
|
t.Fatalf("membership should be ended by agency owner: %+v", result.Membership)
|
|
}
|
|
if result.HostProfile.Status != hostdomain.HostStatusDisabled || result.HostProfile.CurrentAgencyID != 0 || result.HostProfile.CurrentMembershipID != 0 {
|
|
t.Fatalf("removed ordinary host should lose host identity: %+v", result.HostProfile)
|
|
}
|
|
summary, err := svc.GetUserRoleSummary(ctx, 622)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary after kick failed: %v", err)
|
|
}
|
|
if summary.IsHost || summary.HostStatus != hostdomain.HostStatusDisabled || summary.IsAgency {
|
|
t.Fatalf("removed host should no longer expose host entry: %+v", summary)
|
|
}
|
|
replayed, err := svc.KickAgencyHost(ctx, hostservice.KickAgencyHostInput{
|
|
CommandID: "kick-host-622",
|
|
OperatorUserID: 621,
|
|
AgencyID: 623,
|
|
HostUserID: 622,
|
|
Reason: "agency_remove",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("KickAgencyHost idempotent replay failed: %v", err)
|
|
}
|
|
if replayed.HostProfile.Status != hostdomain.HostStatusDisabled || replayed.HostProfile.CurrentMembershipID != 0 || replayed.Membership.Status != hostdomain.MembershipStatusEnded {
|
|
t.Fatalf("idempotent replay should return disabled host fact: %+v", replayed)
|
|
}
|
|
}
|
|
|
|
func TestKickAgencyHostKeepsHostIdentityForActiveAgencyOwner(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 631, 10)
|
|
seedActiveUser(t, repository, 632, 10)
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 633,
|
|
OwnerUserID: 631,
|
|
RegionID: 10,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 635,
|
|
OwnerUserID: 632,
|
|
RegionID: 10,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 632,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 10,
|
|
CurrentAgencyID: 633,
|
|
CurrentMembershipID: 634,
|
|
Source: hostdomain.HostSourceHostInvitation,
|
|
})
|
|
seedActiveMembership(t, repository, 634, 633, 632, hostdomain.MembershipTypeMember)
|
|
svc := newHostService(repository, 636, 650)
|
|
|
|
result, err := svc.KickAgencyHost(ctx, hostservice.KickAgencyHostInput{
|
|
CommandID: "kick-host-owner-632",
|
|
OperatorUserID: 631,
|
|
AgencyID: 633,
|
|
HostUserID: 632,
|
|
Reason: "agency_remove",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("KickAgencyHost for active agency owner failed: %v", err)
|
|
}
|
|
if result.HostProfile.Status != hostdomain.HostStatusActive || result.HostProfile.CurrentAgencyID != 0 || result.HostProfile.CurrentMembershipID != 0 {
|
|
t.Fatalf("active agency owner should keep host identity but drop removed membership pointer: %+v", result.HostProfile)
|
|
}
|
|
summary, err := svc.GetUserRoleSummary(ctx, 632)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary for active agency owner failed: %v", err)
|
|
}
|
|
if !summary.IsHost || !summary.IsAgency || summary.AgencyID != 635 {
|
|
t.Fatalf("active agency owner should still expose host and agency entries: %+v", summary)
|
|
}
|
|
}
|
|
|
|
func TestAcceptBDInvitationDoesNotCreateHostProfile(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 701, 10)
|
|
seedActiveUser(t, repository, 702, 10)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 701,
|
|
Role: hostdomain.BDRoleLeader,
|
|
RegionID: 10,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
svc := newHostService(repository, 3000, 4000)
|
|
|
|
invitation, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-bd-702",
|
|
InviterUserID: 701,
|
|
TargetUserID: 702,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("InviteBD failed: %v", err)
|
|
}
|
|
if invitation.Status != hostdomain.InvitationStatusPending {
|
|
t.Fatalf("bd invitation should wait for target accept: %+v", invitation)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-bd-702",
|
|
ActorUserID: 702,
|
|
InvitationID: invitation.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("ProcessRoleInvitation accept bd failed: %v", err)
|
|
}
|
|
bdProfile, err := svc.GetBDProfile(ctx, 702, hostdomain.BDRoleBD)
|
|
if err != nil {
|
|
t.Fatalf("GetBDProfile failed: %v", err)
|
|
}
|
|
if bdProfile.UserID != 702 || bdProfile.Role != hostdomain.BDRoleBD || bdProfile.ParentLeaderUserID != 701 {
|
|
t.Fatalf("bd profile mismatch: %+v", bdProfile)
|
|
}
|
|
if _, err := svc.GetHostProfile(ctx, 702); xerr.CodeOf(err) != xerr.NotFound {
|
|
t.Fatalf("becoming bd must not create host profile: err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestRoleInvitationCreateRejectsCrossRegionWithRegionMismatch(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 711, 10)
|
|
seedActiveUser(t, repository, 712, 20)
|
|
seedActiveUser(t, repository, 721, 10)
|
|
seedActiveUser(t, repository, 722, 20)
|
|
seedActiveUser(t, repository, 731, 10)
|
|
seedActiveUser(t, repository, 732, 20)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 711,
|
|
Role: hostdomain.BDRoleBD,
|
|
RegionID: 10,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 721,
|
|
Role: hostdomain.BDRoleLeader,
|
|
RegionID: 10,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 733,
|
|
OwnerUserID: 731,
|
|
RegionID: 10,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
svc := newHostService(repository, 5000, 6000)
|
|
|
|
// 三类 H5 邀请共用 RoleInvitation 事实；跨区属于明确业务边界，不应该退化成泛化权限拒绝。
|
|
if _, err := svc.InviteAgency(ctx, hostservice.InviteAgencyInput{
|
|
CommandID: "invite-agency-cross-region",
|
|
InviterUserID: 711,
|
|
TargetUserID: 712,
|
|
AgencyName: "Cross Region Agency",
|
|
}); xerr.CodeOf(err) != xerr.RegionMismatch {
|
|
t.Fatalf("cross-region agency invite should return REGION_MISMATCH: %v", err)
|
|
}
|
|
if _, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-bd-cross-region",
|
|
InviterUserID: 721,
|
|
TargetUserID: 722,
|
|
}); xerr.CodeOf(err) != xerr.RegionMismatch {
|
|
t.Fatalf("cross-region bd invite should return REGION_MISMATCH: %v", err)
|
|
}
|
|
if _, err := svc.InviteHost(ctx, hostservice.InviteHostInput{
|
|
CommandID: "invite-host-cross-region",
|
|
InviterUserID: 731,
|
|
TargetUserID: 732,
|
|
}); xerr.CodeOf(err) != xerr.RegionMismatch {
|
|
t.Fatalf("cross-region host invite should return REGION_MISMATCH: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRoleInvitationAcceptRejectsRegionDriftWithRegionMismatch(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 741, 10)
|
|
seedActiveUser(t, repository, 742, 10)
|
|
seedActiveUser(t, repository, 751, 10)
|
|
seedActiveUser(t, repository, 752, 10)
|
|
seedActiveUser(t, repository, 761, 10)
|
|
seedActiveUser(t, repository, 762, 10)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 741,
|
|
Role: hostdomain.BDRoleBD,
|
|
RegionID: 10,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 751,
|
|
Role: hostdomain.BDRoleLeader,
|
|
RegionID: 10,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 763,
|
|
OwnerUserID: 761,
|
|
RegionID: 10,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
svc := newHostService(repository, 5100, 6100)
|
|
|
|
agencyInvite, err := svc.InviteAgency(ctx, hostservice.InviteAgencyInput{
|
|
CommandID: "invite-agency-before-drift",
|
|
InviterUserID: 741,
|
|
TargetUserID: 742,
|
|
AgencyName: "Drift Agency",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("InviteAgency before region drift failed: %v", err)
|
|
}
|
|
bdInvite, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-bd-before-drift",
|
|
InviterUserID: 751,
|
|
TargetUserID: 752,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("InviteBD before region drift failed: %v", err)
|
|
}
|
|
hostInvite, err := svc.InviteHost(ctx, hostservice.InviteHostInput{
|
|
CommandID: "invite-host-before-drift",
|
|
InviterUserID: 761,
|
|
TargetUserID: 762,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("InviteHost before region drift failed: %v", err)
|
|
}
|
|
|
|
// 邀请发出后用户可能被后台迁区；接受时必须重新读 users 当前区域，并给 H5 可解释的跨区错误。
|
|
seedActiveUser(t, repository, 742, 20)
|
|
seedActiveUser(t, repository, 752, 20)
|
|
seedActiveUser(t, repository, 762, 20)
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-agency-after-drift",
|
|
ActorUserID: 742,
|
|
InvitationID: agencyInvite.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); xerr.CodeOf(err) != xerr.RegionMismatch {
|
|
t.Fatalf("agency accept after region drift should return REGION_MISMATCH: %v", err)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-bd-after-drift",
|
|
ActorUserID: 752,
|
|
InvitationID: bdInvite.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); xerr.CodeOf(err) != xerr.RegionMismatch {
|
|
t.Fatalf("bd accept after region drift should return REGION_MISMATCH: %v", err)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-host-after-drift",
|
|
ActorUserID: 762,
|
|
InvitationID: hostInvite.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); xerr.CodeOf(err) != xerr.RegionMismatch {
|
|
t.Fatalf("host accept after region drift should return REGION_MISMATCH: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestBatchGetHostProfilesReturnsExistingProfilesOnly(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 801, 10)
|
|
seedActiveUser(t, repository, 802, 20)
|
|
seedActiveUser(t, repository, 803, 30)
|
|
repository.PutHostProfile(hostdomain.HostProfile{UserID: 801, Status: hostdomain.HostStatusActive, Source: "batch-test"})
|
|
repository.PutHostProfile(hostdomain.HostProfile{UserID: 802, Status: hostdomain.HostStatusDisabled, Source: "batch-test"})
|
|
svc := newHostService(repository, 4000, 5000)
|
|
|
|
profiles, err := svc.BatchGetHostProfiles(ctx, []int64{801, 802, 803, 801})
|
|
if err != nil {
|
|
t.Fatalf("BatchGetHostProfiles failed: %v", err)
|
|
}
|
|
if len(profiles) != 2 {
|
|
t.Fatalf("batch host profiles should only include existing rows, got %+v", profiles)
|
|
}
|
|
if profiles[801].UserID != 801 || profiles[801].Status != hostdomain.HostStatusActive || profiles[801].RegionID != 10 {
|
|
t.Fatalf("active host profile mismatch: %+v", profiles[801])
|
|
}
|
|
if profiles[802].UserID != 802 || profiles[802].Status != hostdomain.HostStatusDisabled || profiles[802].RegionID != 20 {
|
|
t.Fatalf("disabled host profile should still be returned for gateway-side filtering: %+v", profiles[802])
|
|
}
|
|
if _, ok := profiles[803]; ok {
|
|
t.Fatalf("missing host profile must not be returned as placeholder: %+v", profiles[803])
|
|
}
|
|
}
|
|
|
|
func TestBatchGetHostProfilesRejectsInvalidUserID(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
svc := newHostService(repository, 4000, 5000)
|
|
|
|
_, err := svc.BatchGetHostProfiles(ctx, []int64{801, 0})
|
|
if xerr.CodeOf(err) != xerr.InvalidArgument {
|
|
t.Fatalf("invalid batch user id should fail with INVALID_ARGUMENT: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestInviteBDAcceptsSelfInviteForLeader(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 703, 10)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 703,
|
|
Role: hostdomain.BDRoleLeader,
|
|
RegionID: 10,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
svc := newHostService(repository, 3100, 4100)
|
|
|
|
invitation, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-bd-self-703",
|
|
InviterUserID: 703,
|
|
TargetUserID: 703,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("bd leader self invite must be created: %v", err)
|
|
}
|
|
if invitation.Status != hostdomain.InvitationStatusPending || invitation.InviterUserID != 703 || invitation.TargetUserID != 703 || invitation.ParentLeaderUserID != 703 {
|
|
t.Fatalf("self invite invitation mismatch: %+v", invitation)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-bd-self-703",
|
|
ActorUserID: 703,
|
|
InvitationID: invitation.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("self invite accept must create ordinary bd profile: %v", err)
|
|
}
|
|
ordinaryBD, err := svc.GetBDProfile(ctx, 703, hostdomain.BDRoleBD)
|
|
if err != nil {
|
|
t.Fatalf("self invite must create ordinary bd profile: %v", err)
|
|
}
|
|
if ordinaryBD.Role != hostdomain.BDRoleBD || ordinaryBD.ParentLeaderUserID != 703 {
|
|
t.Fatalf("self invite ordinary bd mismatch: %+v", ordinaryBD)
|
|
}
|
|
leaderProfile, err := svc.GetBDProfile(ctx, 703, hostdomain.BDRoleLeader)
|
|
if err != nil {
|
|
t.Fatalf("self invite must keep existing leader profile unchanged: %v", err)
|
|
}
|
|
if leaderProfile.Role != hostdomain.BDRoleLeader || leaderProfile.Status != hostdomain.BDStatusActive {
|
|
t.Fatalf("self invite leader profile mismatch: %+v", leaderProfile)
|
|
}
|
|
retried, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-bd-self-703",
|
|
InviterUserID: 703,
|
|
TargetUserID: 703,
|
|
})
|
|
if err != nil || retried.InvitationID != invitation.InvitationID {
|
|
t.Fatalf("self invite retry must replay existing invitation: retried=%+v err=%v", retried, err)
|
|
}
|
|
}
|
|
|
|
func TestAdminCreateBDLeaderAndBDIdempotently(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
assertNoHostOrgRegionSnapshotColumns(t, repository)
|
|
repository.PutRegion(userdomain.Region{RegionID: 20, RegionCode: "R20", Name: "Region 20"})
|
|
seedActiveUser(t, repository, 801, 20)
|
|
seedActiveUser(t, repository, 802, 20)
|
|
seedActiveUser(t, repository, 804, 20)
|
|
svc := newHostService(repository, 4000, 5000)
|
|
|
|
leader, err := svc.CreateBDLeader(ctx, hostservice.CreateBDLeaderInput{
|
|
CommandID: "admin-create-leader-801",
|
|
AdminUserID: 1,
|
|
TargetUserID: 801,
|
|
Reason: "seed leader",
|
|
RequestID: "req-leader-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateBDLeader failed: %v", err)
|
|
}
|
|
if leader.Role != hostdomain.BDRoleLeader || leader.Status != hostdomain.BDStatusActive || leader.RegionID != 20 {
|
|
t.Fatalf("leader mismatch: %+v", leader)
|
|
}
|
|
updatedUser, err := repository.GetUser(ctx, 801)
|
|
if err != nil {
|
|
t.Fatalf("GetUser after CreateBDLeader failed: %v", err)
|
|
}
|
|
if updatedUser.RegionID != 20 {
|
|
t.Fatalf("CreateBDLeader must keep target user region as profile region: %+v", updatedUser)
|
|
}
|
|
retriedLeader, err := svc.CreateBDLeader(ctx, hostservice.CreateBDLeaderInput{
|
|
CommandID: "admin-create-leader-801",
|
|
AdminUserID: 1,
|
|
TargetUserID: 801,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("retry CreateBDLeader failed: %v", err)
|
|
}
|
|
if retriedLeader.UserID != leader.UserID || retriedLeader.RegionID != 20 {
|
|
t.Fatalf("leader retry must replay existing result: %+v", retriedLeader)
|
|
}
|
|
|
|
sameUserBD, err := svc.GetBDProfile(ctx, 801, hostdomain.BDRoleBD)
|
|
if err != nil {
|
|
t.Fatalf("CreateBDLeader must create self ordinary bd: %v", err)
|
|
}
|
|
if sameUserBD.Role != hostdomain.BDRoleBD || sameUserBD.ParentLeaderUserID != 801 {
|
|
t.Fatalf("self ordinary bd mismatch: %+v", sameUserBD)
|
|
}
|
|
_, err = svc.CreateBD(ctx, hostservice.CreateBDInput{
|
|
CommandID: "admin-create-bd-801-same-user",
|
|
AdminUserID: 1,
|
|
TargetUserID: 801,
|
|
ParentLeaderUserID: 801,
|
|
Reason: "same user already has bd",
|
|
RequestID: "req-bd-same-user-1",
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.Conflict {
|
|
t.Fatalf("CreateBDLeader already creates ordinary bd: got %s err=%v", got, err)
|
|
}
|
|
leaderAfterBD, err := svc.GetBDProfile(ctx, 801, hostdomain.BDRoleLeader)
|
|
if err != nil || leaderAfterBD.Role != hostdomain.BDRoleLeader || leaderAfterBD.Status != hostdomain.BDStatusActive {
|
|
t.Fatalf("ordinary bd creation must not rewrite leader row: leader=%+v err=%v", leaderAfterBD, err)
|
|
}
|
|
|
|
bd, err := svc.CreateBD(ctx, hostservice.CreateBDInput{
|
|
CommandID: "admin-create-bd-802",
|
|
AdminUserID: 1,
|
|
TargetUserID: 802,
|
|
ParentLeaderUserID: 801,
|
|
Reason: "seed bd",
|
|
RequestID: "req-bd-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateBD failed: %v", err)
|
|
}
|
|
if bd.Role != hostdomain.BDRoleBD || bd.ParentLeaderUserID != 801 || bd.RegionID != 20 {
|
|
t.Fatalf("bd mismatch: %+v", bd)
|
|
}
|
|
bdAfterSnapshotDrift, err := svc.GetBDProfile(ctx, 802, hostdomain.BDRoleBD)
|
|
if err != nil || bdAfterSnapshotDrift.RegionID != 20 {
|
|
t.Fatalf("bd profile must read region from users table: bd=%+v err=%v", bdAfterSnapshotDrift, err)
|
|
}
|
|
|
|
independentBD, err := svc.CreateBD(ctx, hostservice.CreateBDInput{
|
|
CommandID: "admin-create-bd-804-independent",
|
|
AdminUserID: 1,
|
|
TargetUserID: 804,
|
|
Reason: "seed independent bd",
|
|
RequestID: "req-bd-independent-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateBD without parent leader failed: %v", err)
|
|
}
|
|
if independentBD.Role != hostdomain.BDRoleBD || independentBD.ParentLeaderUserID != 0 || independentBD.RegionID != 20 {
|
|
t.Fatalf("independent bd mismatch: %+v", independentBD)
|
|
}
|
|
|
|
disabled, err := svc.SetBDStatus(ctx, hostservice.SetBDStatusInput{
|
|
CommandID: "admin-disable-bd-802",
|
|
AdminUserID: 1,
|
|
TargetUserID: 802,
|
|
Role: hostdomain.BDRoleBD,
|
|
Status: hostdomain.BDStatusDisabled,
|
|
Reason: "stop bd",
|
|
RequestID: "req-bd-stop-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetBDStatus disabled failed: %v", err)
|
|
}
|
|
if disabled.Status != hostdomain.BDStatusDisabled {
|
|
t.Fatalf("disabled bd mismatch: %+v", disabled)
|
|
}
|
|
disabledInvite, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-disabled-bd-802-again",
|
|
InviterUserID: 801,
|
|
TargetUserID: 802,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("disabled ordinary bd should be invitable again: %v", err)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-disabled-bd-802-again",
|
|
ActorUserID: 802,
|
|
InvitationID: disabledInvite.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("accept disabled bd invite should restore profile: %v", err)
|
|
}
|
|
restoredBD, err := svc.GetBDProfile(ctx, 802, hostdomain.BDRoleBD)
|
|
if err != nil {
|
|
t.Fatalf("GetBDProfile restored disabled bd failed: %v", err)
|
|
}
|
|
if restoredBD.Status != hostdomain.BDStatusActive || restoredBD.ParentLeaderUserID != 801 {
|
|
t.Fatalf("disabled bd invite should restore active under inviter leader: %+v", restoredBD)
|
|
}
|
|
seedActiveUser(t, repository, 805, 20)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 805,
|
|
Role: hostdomain.BDRoleBD,
|
|
RegionID: 20,
|
|
ParentLeaderUserID: 801,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
if _, err := svc.CreateBDLeader(ctx, hostservice.CreateBDLeaderInput{
|
|
CommandID: "admin-create-leader-existing-bd-805",
|
|
AdminUserID: 1,
|
|
TargetUserID: 805,
|
|
Reason: "promote existing bd",
|
|
RequestID: "req-leader-existing-bd-1",
|
|
}); err != nil {
|
|
t.Fatalf("CreateBDLeader for existing bd failed: %v", err)
|
|
}
|
|
existingBD, err := svc.GetBDProfile(ctx, 805, hostdomain.BDRoleBD)
|
|
if err != nil {
|
|
t.Fatalf("GetBDProfile existing bd after leader create failed: %v", err)
|
|
}
|
|
if existingBD.ParentLeaderUserID != 801 {
|
|
t.Fatalf("CreateBDLeader must not overwrite active bd parent: %+v", existingBD)
|
|
}
|
|
disabledSameUserBD, err := svc.SetBDStatus(ctx, hostservice.SetBDStatusInput{
|
|
CommandID: "admin-disable-bd-801",
|
|
AdminUserID: 1,
|
|
TargetUserID: 801,
|
|
Role: hostdomain.BDRoleBD,
|
|
Status: hostdomain.BDStatusDisabled,
|
|
Reason: "stop ordinary bd only",
|
|
RequestID: "req-bd-stop-801",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetBDStatus ordinary bd for same user failed: %v", err)
|
|
}
|
|
if disabledSameUserBD.Role != hostdomain.BDRoleBD || disabledSameUserBD.Status != hostdomain.BDStatusDisabled {
|
|
t.Fatalf("disabled same user bd mismatch: %+v", disabledSameUserBD)
|
|
}
|
|
stillLeader, err := svc.GetBDProfile(ctx, 801, hostdomain.BDRoleLeader)
|
|
if err != nil || stillLeader.Status != hostdomain.BDStatusActive {
|
|
t.Fatalf("disabling ordinary bd must not affect leader: leader=%+v err=%v", stillLeader, err)
|
|
}
|
|
disabledLeader, err := svc.SetBDStatus(ctx, hostservice.SetBDStatusInput{
|
|
CommandID: "admin-disable-leader-801",
|
|
AdminUserID: 1,
|
|
TargetUserID: 801,
|
|
Role: hostdomain.BDRoleLeader,
|
|
Status: hostdomain.BDStatusDisabled,
|
|
Reason: "stop leader only",
|
|
RequestID: "req-leader-stop-801",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetBDStatus leader failed: %v", err)
|
|
}
|
|
if disabledLeader.Role != hostdomain.BDRoleLeader || disabledLeader.Status != hostdomain.BDStatusDisabled {
|
|
t.Fatalf("disabled leader mismatch: %+v", disabledLeader)
|
|
}
|
|
ordinaryStillDisabled, err := svc.GetBDProfile(ctx, 801, hostdomain.BDRoleBD)
|
|
if err != nil || ordinaryStillDisabled.Status != hostdomain.BDStatusDisabled {
|
|
t.Fatalf("disabling leader must not rewrite ordinary bd: bd=%+v err=%v", ordinaryStillDisabled, err)
|
|
}
|
|
}
|
|
|
|
func TestAdminCreateBDLeaderRejectsDisabledRegion(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
repository.PutRegion(userdomain.Region{RegionID: 21, RegionCode: "R21", Name: "Region 21", Status: userdomain.RegionStatusDisabled})
|
|
seedActiveUser(t, repository, 803, 21)
|
|
svc := newHostService(repository, 4100, 5100)
|
|
|
|
_, err := svc.CreateBDLeader(ctx, hostservice.CreateBDLeaderInput{
|
|
CommandID: "admin-create-leader-disabled-region",
|
|
AdminUserID: 1,
|
|
TargetUserID: 803,
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.RegionDisabled {
|
|
t.Fatalf("disabled region must be rejected: got %s err=%v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestAdminCreateAgencyControlsAppSearch(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUserInCountry(t, repository, 901, 30, "CN", "https://cdn.example/owner-901.png")
|
|
seedActiveUser(t, repository, 902, 30)
|
|
seedActiveUserInCountry(t, repository, 903, 30, "US", "")
|
|
seedActiveUser(t, repository, 900, 30)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 900,
|
|
Role: hostdomain.BDRoleLeader,
|
|
RegionID: 999,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
svc := newHostService(repository, 5000, 6000)
|
|
|
|
created, err := svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-901",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 901,
|
|
ParentBDUserID: 900,
|
|
Name: "Admin Seed Agency",
|
|
JoinEnabled: true,
|
|
Reason: "seed agency",
|
|
RequestID: "req-agency-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateAgency failed: %v", err)
|
|
}
|
|
if created.Agency.OwnerUserID != 901 || created.Agency.ParentBDUserID != 900 || !created.Agency.JoinEnabled {
|
|
t.Fatalf("agency mismatch: %+v", created.Agency)
|
|
}
|
|
if created.HostProfile.CurrentAgencyID != created.Agency.AgencyID || created.HostProfile.Source != hostdomain.HostSourceAdminCreateAgency {
|
|
t.Fatalf("owner host profile mismatch: %+v", created.HostProfile)
|
|
}
|
|
if created.Membership.MembershipType != hostdomain.MembershipTypeOwner || created.Membership.Status != hostdomain.MembershipStatusActive {
|
|
t.Fatalf("owner membership mismatch: %+v", created.Membership)
|
|
}
|
|
if _, err := svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-903",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 903,
|
|
ParentBDUserID: 900,
|
|
Name: "Other Country Agency",
|
|
JoinEnabled: true,
|
|
Reason: "seed agency",
|
|
RequestID: "req-agency-2",
|
|
}); err != nil {
|
|
t.Fatalf("CreateAgency in other country failed: %v", err)
|
|
}
|
|
agencies, err := svc.SearchAgencies(ctx, 902, "", 20)
|
|
if err != nil {
|
|
t.Fatalf("SearchAgencies list failed: %v", err)
|
|
}
|
|
if len(agencies) != 1 || agencies[0].AgencyID != created.Agency.AgencyID || agencies[0].Avatar != "https://cdn.example/owner-901.png" || agencies[0].ActiveHostCount != 1 {
|
|
t.Fatalf("created agency list should be scoped by country with display fields: %+v", agencies)
|
|
}
|
|
if agencies[0].RegionID != 30 {
|
|
t.Fatalf("agency search must read region from owner users table: %+v", agencies[0])
|
|
}
|
|
agencies, err = svc.SearchAgencies(ctx, 902, "Admin Seed", 20)
|
|
if err != nil {
|
|
t.Fatalf("SearchAgencies failed: %v", err)
|
|
}
|
|
if len(agencies) != 1 || agencies[0].AgencyID != created.Agency.AgencyID {
|
|
t.Fatalf("created agency should be searchable: %+v", agencies)
|
|
}
|
|
agencies, err = svc.SearchAgencies(ctx, 902, displayID(901), 20)
|
|
if err != nil {
|
|
t.Fatalf("SearchAgencies by owner display id failed: %v", err)
|
|
}
|
|
if len(agencies) != 1 || agencies[0].AgencyID != created.Agency.AgencyID {
|
|
t.Fatalf("created agency should be searchable by owner display id: %+v", agencies)
|
|
}
|
|
agencies, err = svc.SearchAgencies(ctx, 902, displayID(900), 20)
|
|
if err != nil {
|
|
t.Fatalf("SearchAgencies by non-owner parent BD display id failed: %v", err)
|
|
}
|
|
if len(agencies) != 0 {
|
|
t.Fatalf("parent BD display id must not expand to child agencies: %+v", agencies)
|
|
}
|
|
|
|
disabledJoin, err := svc.SetAgencyJoinEnabled(ctx, hostservice.SetAgencyJoinEnabledInput{
|
|
CommandID: "admin-disable-agency-join-901",
|
|
AdminUserID: 1,
|
|
AgencyID: created.Agency.AgencyID,
|
|
JoinEnabled: false,
|
|
Reason: "pause join",
|
|
RequestID: "req-agency-join-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetAgencyJoinEnabled failed: %v", err)
|
|
}
|
|
if disabledJoin.JoinEnabled {
|
|
t.Fatalf("agency join should be disabled: %+v", disabledJoin)
|
|
}
|
|
agencies, err = svc.SearchAgencies(ctx, 902, "Admin Seed", 20)
|
|
if err != nil {
|
|
t.Fatalf("SearchAgencies after join disabled failed: %v", err)
|
|
}
|
|
if len(agencies) != 0 {
|
|
t.Fatalf("join-disabled agency must not be searchable: %+v", agencies)
|
|
}
|
|
|
|
closed, err := svc.CloseAgency(ctx, hostservice.CloseAgencyInput{
|
|
CommandID: "admin-close-agency-901",
|
|
AdminUserID: 1,
|
|
AgencyID: created.Agency.AgencyID,
|
|
Reason: "close agency",
|
|
RequestID: "req-agency-close-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CloseAgency failed: %v", err)
|
|
}
|
|
if closed.Status != hostdomain.AgencyStatusClosed || closed.JoinEnabled {
|
|
t.Fatalf("closed agency mismatch: %+v", closed)
|
|
}
|
|
|
|
reopened, err := svc.SetAgencyStatus(ctx, hostservice.SetAgencyStatusInput{
|
|
CommandID: "admin-reopen-agency-901",
|
|
AdminUserID: 1,
|
|
AgencyID: created.Agency.AgencyID,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
Reason: "reopen agency",
|
|
RequestID: "req-agency-status-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetAgencyStatus active failed: %v", err)
|
|
}
|
|
if reopened.Status != hostdomain.AgencyStatusActive || reopened.JoinEnabled {
|
|
t.Fatalf("reopened agency should keep join disabled until admin explicitly opens it: %+v", reopened)
|
|
}
|
|
|
|
enabledJoin, err := svc.SetAgencyJoinEnabled(ctx, hostservice.SetAgencyJoinEnabledInput{
|
|
CommandID: "admin-enable-agency-join-901",
|
|
AdminUserID: 1,
|
|
AgencyID: created.Agency.AgencyID,
|
|
JoinEnabled: true,
|
|
Reason: "resume join",
|
|
RequestID: "req-agency-join-2",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetAgencyJoinEnabled after reopen failed: %v", err)
|
|
}
|
|
if !enabledJoin.JoinEnabled {
|
|
t.Fatalf("agency join should be enabled after explicit open: %+v", enabledJoin)
|
|
}
|
|
|
|
deleted, err := svc.DeleteAgency(ctx, hostservice.DeleteAgencyInput{
|
|
CommandID: "admin-delete-agency-901",
|
|
AdminUserID: 1,
|
|
AgencyID: created.Agency.AgencyID,
|
|
Reason: "delete agency",
|
|
RequestID: "req-agency-delete-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("DeleteAgency failed: %v", err)
|
|
}
|
|
if deleted.Status != hostdomain.AgencyStatusDeleted || deleted.JoinEnabled {
|
|
t.Fatalf("deleted agency mismatch: %+v", deleted)
|
|
}
|
|
hostProfile, err := svc.GetHostProfile(ctx, 901)
|
|
if err != nil {
|
|
t.Fatalf("GetHostProfile after delete failed: %v", err)
|
|
}
|
|
if hostProfile.CurrentAgencyID != 0 || hostProfile.CurrentMembershipID != 0 || hostProfile.Status != hostdomain.HostStatusActive {
|
|
t.Fatalf("delete agency should detach but keep host profile: %+v", hostProfile)
|
|
}
|
|
recreated, err := svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-901-after-delete",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 901,
|
|
ParentBDUserID: 900,
|
|
Name: "Recreated Agency",
|
|
JoinEnabled: true,
|
|
Reason: "recreate agency",
|
|
RequestID: "req-agency-recreate-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("detached owner host should be reusable after delete: %v", err)
|
|
}
|
|
if recreated.HostProfile.CurrentAgencyID != recreated.Agency.AgencyID || recreated.HostProfile.FirstBecameHostAtMs != hostProfile.FirstBecameHostAtMs {
|
|
t.Fatalf("recreated agency should reuse host identity: host=%+v agency=%+v oldHost=%+v", recreated.HostProfile, recreated.Agency, hostProfile)
|
|
}
|
|
}
|
|
|
|
func TestAgencyProfileDefaultsAndStaysIndependent(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
repository.PutUser(userdomain.User{
|
|
UserID: 921,
|
|
DefaultDisplayUserID: displayID(921),
|
|
CurrentDisplayUserID: displayID(921),
|
|
Username: "Owner Nick",
|
|
Avatar: "https://cdn.example/owner-old.png",
|
|
Country: "CN",
|
|
RegionID: 30,
|
|
ProfileCompleted: true,
|
|
ProfileCompletedAtMs: 1,
|
|
OnboardingStatus: userdomain.OnboardingStatusCompleted,
|
|
Status: userdomain.StatusActive,
|
|
})
|
|
seedActiveUser(t, repository, 922, 30)
|
|
svc := newHostService(repository, 5200, 6200)
|
|
|
|
created, err := svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-default-profile",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 921,
|
|
JoinEnabled: true,
|
|
RequestID: "req-agency-default-profile",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateAgency with default profile failed: %v", err)
|
|
}
|
|
if created.Agency.Name != "Owner Nick" || created.Agency.Avatar != "https://cdn.example/owner-old.png" {
|
|
t.Fatalf("agency must copy owner profile once on create: %+v", created.Agency)
|
|
}
|
|
|
|
newName := "Agency New"
|
|
newAvatar := "https://cdn.example/agency-new.png"
|
|
updated, err := svc.UpdateAgencyProfile(ctx, hostservice.UpdateAgencyProfileInput{
|
|
CommandID: "agency-profile-update-owner",
|
|
OperatorUserID: 921,
|
|
AgencyID: created.Agency.AgencyID,
|
|
Name: &newName,
|
|
Avatar: &newAvatar,
|
|
RequestID: "req-agency-profile-update-owner",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("UpdateAgencyProfile by owner failed: %v", err)
|
|
}
|
|
if updated.Name != newName || updated.Avatar != newAvatar {
|
|
t.Fatalf("agency profile update mismatch: %+v", updated)
|
|
}
|
|
owner, err := repository.GetUser(ctx, 921)
|
|
if err != nil {
|
|
t.Fatalf("GetUser after agency update failed: %v", err)
|
|
}
|
|
if owner.Username != "Owner Nick" || owner.Avatar != "https://cdn.example/owner-old.png" {
|
|
t.Fatalf("agency profile update must not modify owner user: %+v", owner)
|
|
}
|
|
|
|
repository.PutUser(userdomain.User{
|
|
UserID: 921,
|
|
DefaultDisplayUserID: displayID(921),
|
|
CurrentDisplayUserID: displayID(921),
|
|
Username: "Owner New",
|
|
Avatar: "https://cdn.example/owner-new.png",
|
|
Country: "CN",
|
|
RegionID: 30,
|
|
ProfileCompleted: true,
|
|
ProfileCompletedAtMs: 1,
|
|
OnboardingStatus: userdomain.OnboardingStatusCompleted,
|
|
Status: userdomain.StatusActive,
|
|
})
|
|
afterUserChange, err := svc.GetAgency(ctx, created.Agency.AgencyID)
|
|
if err != nil {
|
|
t.Fatalf("GetAgency after owner profile change failed: %v", err)
|
|
}
|
|
if afterUserChange.Name != newName || afterUserChange.Avatar != newAvatar {
|
|
t.Fatalf("owner profile change must not sync back to agency: %+v", afterUserChange)
|
|
}
|
|
|
|
_, err = svc.UpdateAgencyProfile(ctx, hostservice.UpdateAgencyProfileInput{
|
|
CommandID: "agency-profile-update-non-owner",
|
|
OperatorUserID: 922,
|
|
AgencyID: created.Agency.AgencyID,
|
|
Name: &newName,
|
|
RequestID: "req-agency-profile-update-non-owner",
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.PermissionDenied {
|
|
t.Fatalf("non owner agency update must be denied: got %s err=%v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestAdminCreateAgencyWithoutParentBD(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 904, 31)
|
|
svc := newHostService(repository, 5600, 6600)
|
|
|
|
created, err := svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-904-independent",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 904,
|
|
Name: "Independent Agency",
|
|
JoinEnabled: true,
|
|
Reason: "seed independent agency",
|
|
RequestID: "req-agency-independent-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateAgency without parent bd failed: %v", err)
|
|
}
|
|
if created.Agency.OwnerUserID != 904 || created.Agency.ParentBDUserID != 0 || created.Agency.RegionID != 31 || !created.Agency.JoinEnabled {
|
|
t.Fatalf("independent agency mismatch: %+v", created.Agency)
|
|
}
|
|
if created.HostProfile.CurrentAgencyID != created.Agency.AgencyID || created.Membership.MembershipType != hostdomain.MembershipTypeOwner {
|
|
t.Fatalf("independent agency owner facts mismatch: host=%+v membership=%+v", created.HostProfile, created.Membership)
|
|
}
|
|
}
|
|
|
|
func TestAdminCreateAgencyReusesDetachedHost(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 911, 40)
|
|
seedActiveUser(t, repository, 910, 40)
|
|
seedActiveUser(t, repository, 912, 40)
|
|
seedActiveUser(t, repository, 913, 40)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 910,
|
|
Role: hostdomain.BDRoleBD,
|
|
RegionID: 999,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 911,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 40,
|
|
Source: "test",
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 914,
|
|
OwnerUserID: 913,
|
|
RegionID: 40,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 912,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 40,
|
|
CurrentAgencyID: 914,
|
|
CurrentMembershipID: 915,
|
|
Source: "existing-membership",
|
|
})
|
|
seedActiveMembership(t, repository, 915, 914, 912, hostdomain.MembershipTypeMember)
|
|
svc := newHostService(repository, 6000, 7000)
|
|
|
|
created, err := svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-existing-host",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 911,
|
|
ParentBDUserID: 910,
|
|
Name: "Reused Host Agency",
|
|
JoinEnabled: true,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("detached host should become agency owner: %v", err)
|
|
}
|
|
if created.HostProfile.CurrentAgencyID != created.Agency.AgencyID || created.HostProfile.Source != "test" {
|
|
t.Fatalf("existing host identity should be reused without rewriting source: %+v", created.HostProfile)
|
|
}
|
|
boundOwner, err := svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-bound-host",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 912,
|
|
ParentBDUserID: 910,
|
|
Name: "Bound Host Agency",
|
|
JoinEnabled: true,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("bound host should become agency owner without rebinding host: %v", err)
|
|
}
|
|
if boundOwner.HostProfile.CurrentAgencyID != 914 || boundOwner.HostProfile.CurrentMembershipID != 915 || boundOwner.Membership.AgencyID != 914 {
|
|
t.Fatalf("admin agency create must preserve existing host binding: %+v", boundOwner)
|
|
}
|
|
boundSummary, err := svc.GetUserRoleSummary(ctx, 912)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary for bound agency owner failed: %v", err)
|
|
}
|
|
if !boundSummary.IsAgency || !boundSummary.IsHost || boundSummary.AgencyID != boundOwner.Agency.AgencyID {
|
|
t.Fatalf("bound host agency owner summary mismatch: %+v agency=%+v", boundSummary, boundOwner.Agency)
|
|
}
|
|
_, err = svc.CreateAgency(ctx, hostservice.CreateAgencyInput{
|
|
CommandID: "admin-create-agency-existing-host-again",
|
|
AdminUserID: 1,
|
|
OwnerUserID: 911,
|
|
ParentBDUserID: 910,
|
|
Name: "Blocked Agency",
|
|
JoinEnabled: true,
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.Conflict {
|
|
t.Fatalf("host with active membership must not become another agency owner: got %s err=%v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestAdminAddAgencyHostCreatesMembershipWithoutInvite(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 916, 41)
|
|
seedActiveUser(t, repository, 917, 41)
|
|
seedActiveUser(t, repository, 918, 42)
|
|
seedActiveUser(t, repository, 919, 41)
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 920,
|
|
OwnerUserID: 916,
|
|
RegionID: 41,
|
|
Name: "Admin Add Host Agency",
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: false,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 921,
|
|
OwnerUserID: 918,
|
|
RegionID: 42,
|
|
Name: "Other Region Agency",
|
|
Status: hostdomain.AgencyStatusActive,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 922,
|
|
OwnerUserID: 919,
|
|
RegionID: 41,
|
|
Name: "Closed Agency",
|
|
Status: hostdomain.AgencyStatusClosed,
|
|
})
|
|
svc := newHostService(repository, 6500, 7500)
|
|
|
|
added, err := svc.AdminAddAgencyHost(ctx, hostservice.AdminAddAgencyHostInput{
|
|
CommandID: "admin-add-host-917",
|
|
AdminUserID: 1,
|
|
AgencyID: 920,
|
|
TargetUserID: 917,
|
|
Reason: "manual add",
|
|
RequestID: "req-admin-add-host-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("AdminAddAgencyHost failed: %v", err)
|
|
}
|
|
if added.Agency.AgencyID != 920 || added.Membership.AgencyID != 920 || added.Membership.HostUserID != 917 || added.Membership.MembershipType != hostdomain.MembershipTypeMember {
|
|
t.Fatalf("added host membership mismatch: %+v", added)
|
|
}
|
|
if added.HostProfile.CurrentAgencyID != 920 || added.HostProfile.CurrentMembershipID != added.Membership.MembershipID || added.HostProfile.Source != hostdomain.HostSourceAdminAddHost {
|
|
t.Fatalf("admin-added host profile mismatch: %+v", added.HostProfile)
|
|
}
|
|
replayed, err := svc.AdminAddAgencyHost(ctx, hostservice.AdminAddAgencyHostInput{
|
|
CommandID: "admin-add-host-917",
|
|
AdminUserID: 1,
|
|
AgencyID: 920,
|
|
TargetUserID: 917,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("AdminAddAgencyHost replay failed: %v", err)
|
|
}
|
|
if replayed.Membership.MembershipID != added.Membership.MembershipID || replayed.HostProfile.CurrentMembershipID != added.Membership.MembershipID {
|
|
t.Fatalf("admin add replay should return original facts: replay=%+v added=%+v", replayed, added)
|
|
}
|
|
|
|
_, err = svc.AdminAddAgencyHost(ctx, hostservice.AdminAddAgencyHostInput{
|
|
CommandID: "admin-add-host-917-again",
|
|
AdminUserID: 1,
|
|
AgencyID: 921,
|
|
TargetUserID: 917,
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.RegionMismatch && got != xerr.Conflict {
|
|
t.Fatalf("bound host must not be silently moved: got %s err=%v", got, err)
|
|
}
|
|
_, err = svc.AdminAddAgencyHost(ctx, hostservice.AdminAddAgencyHostInput{
|
|
CommandID: "admin-add-host-cross-region",
|
|
AdminUserID: 1,
|
|
AgencyID: 920,
|
|
TargetUserID: 918,
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.RegionMismatch {
|
|
t.Fatalf("cross-region add must be rejected: got %s err=%v", got, err)
|
|
}
|
|
_, err = svc.AdminAddAgencyHost(ctx, hostservice.AdminAddAgencyHostInput{
|
|
CommandID: "admin-add-host-closed-agency",
|
|
AdminUserID: 1,
|
|
AgencyID: 922,
|
|
TargetUserID: 919,
|
|
})
|
|
if got := xerr.CodeOf(err); got != xerr.Conflict {
|
|
t.Fatalf("closed agency must be rejected: got %s err=%v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestAdminCreateCoinSellerCanCoexistWithBDAndAgency(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 921, 50)
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 921,
|
|
Role: hostdomain.BDRoleLeader,
|
|
RegionID: 50,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 922,
|
|
OwnerUserID: 921,
|
|
RegionID: 50,
|
|
ParentBDUserID: 921,
|
|
Name: "Seller Agency",
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
CreatedAtMs: 100,
|
|
UpdatedAtMs: 100,
|
|
})
|
|
svc := newHostService(repository, 7000, 8000)
|
|
|
|
profile, err := svc.CreateCoinSeller(ctx, hostservice.CreateCoinSellerInput{
|
|
CommandID: "admin-create-coin-seller-921",
|
|
AdminUserID: 1,
|
|
TargetUserID: 921,
|
|
Reason: "seed coin seller",
|
|
RequestID: "req-coin-seller-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateCoinSeller failed: %v", err)
|
|
}
|
|
if profile.Status != hostdomain.CoinSellerStatusActive || profile.MerchantAssetType != hostdomain.CoinSellerMerchantAssetType {
|
|
t.Fatalf("coin seller profile mismatch: %+v", profile)
|
|
}
|
|
retried, err := svc.CreateCoinSeller(ctx, hostservice.CreateCoinSellerInput{
|
|
CommandID: "admin-create-coin-seller-921",
|
|
AdminUserID: 1,
|
|
TargetUserID: 921,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("retry CreateCoinSeller failed: %v", err)
|
|
}
|
|
if retried.UserID != profile.UserID {
|
|
t.Fatalf("coin seller retry must replay existing result: %+v", retried)
|
|
}
|
|
|
|
disabled, err := svc.SetCoinSellerStatus(ctx, hostservice.SetCoinSellerStatusInput{
|
|
CommandID: "admin-disable-coin-seller-921",
|
|
AdminUserID: 1,
|
|
TargetUserID: 921,
|
|
Status: hostdomain.CoinSellerStatusDisabled,
|
|
Reason: "pause seller",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetCoinSellerStatus failed: %v", err)
|
|
}
|
|
if disabled.Status != hostdomain.CoinSellerStatusDisabled {
|
|
t.Fatalf("disabled coin seller mismatch: %+v", disabled)
|
|
}
|
|
}
|
|
|
|
func TestListActiveCoinSellersInMyRegionFiltersByCurrentUserRegion(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
repository.PutCountry(userdomain.Country{
|
|
CountryID: 86,
|
|
CountryCode: "CN",
|
|
CountryName: "China",
|
|
CountryDisplayName: "中国",
|
|
Enabled: true,
|
|
})
|
|
repository.PutRegion(userdomain.Region{
|
|
RegionID: 70,
|
|
RegionCode: "east-asia",
|
|
Name: "East Asia",
|
|
Status: userdomain.RegionStatusActive,
|
|
Countries: []string{"CN"},
|
|
})
|
|
repository.PutRegion(userdomain.Region{
|
|
RegionID: 71,
|
|
RegionCode: "west-asia",
|
|
Name: "West Asia",
|
|
Status: userdomain.RegionStatusActive,
|
|
Countries: []string{"CN"},
|
|
})
|
|
seedActiveUser(t, repository, 940, 70)
|
|
repository.PutUser(userdomain.User{
|
|
UserID: 941,
|
|
DefaultDisplayUserID: displayID(941),
|
|
CurrentDisplayUserID: displayID(941),
|
|
Username: "Seller One",
|
|
Avatar: "https://cdn.example/seller-one.png",
|
|
Country: "CN",
|
|
RegionID: 70,
|
|
ProfileCompleted: true,
|
|
ProfileCompletedAtMs: 1,
|
|
OnboardingStatus: userdomain.OnboardingStatusCompleted,
|
|
Status: userdomain.StatusActive,
|
|
})
|
|
repository.PutUser(userdomain.User{
|
|
UserID: 942,
|
|
DefaultDisplayUserID: displayID(942),
|
|
CurrentDisplayUserID: displayID(942),
|
|
Username: "Disabled Seller",
|
|
Country: "CN",
|
|
RegionID: 70,
|
|
ProfileCompleted: true,
|
|
ProfileCompletedAtMs: 1,
|
|
OnboardingStatus: userdomain.OnboardingStatusCompleted,
|
|
Status: userdomain.StatusActive,
|
|
})
|
|
repository.PutUser(userdomain.User{
|
|
UserID: 943,
|
|
DefaultDisplayUserID: displayID(943),
|
|
CurrentDisplayUserID: displayID(943),
|
|
Username: "Other Region Seller",
|
|
Country: "CN",
|
|
RegionID: 71,
|
|
ProfileCompleted: true,
|
|
ProfileCompletedAtMs: 1,
|
|
OnboardingStatus: userdomain.OnboardingStatusCompleted,
|
|
Status: userdomain.StatusActive,
|
|
})
|
|
svc := newHostService(repository, 9000, 10000)
|
|
for _, userID := range []int64{941, 942, 943} {
|
|
if _, err := svc.CreateCoinSeller(ctx, hostservice.CreateCoinSellerInput{
|
|
CommandID: fmt.Sprintf("admin-create-coin-seller-%d", userID),
|
|
AdminUserID: 1,
|
|
TargetUserID: userID,
|
|
}); err != nil {
|
|
t.Fatalf("CreateCoinSeller(%d) failed: %v", userID, err)
|
|
}
|
|
}
|
|
if _, err := svc.SetCoinSellerStatus(ctx, hostservice.SetCoinSellerStatusInput{
|
|
CommandID: "admin-disable-coin-seller-942",
|
|
AdminUserID: 1,
|
|
TargetUserID: 942,
|
|
Status: hostdomain.CoinSellerStatusDisabled,
|
|
}); err != nil {
|
|
t.Fatalf("SetCoinSellerStatus failed: %v", err)
|
|
}
|
|
|
|
items, err := svc.ListActiveCoinSellersInMyRegion(ctx, 940)
|
|
if err != nil {
|
|
t.Fatalf("ListActiveCoinSellersInMyRegion failed: %v", err)
|
|
}
|
|
if len(items) != 1 {
|
|
t.Fatalf("only same-region active sellers should be returned: %+v", items)
|
|
}
|
|
item := items[0]
|
|
if item.UserID != 941 || item.Username != "Seller One" || item.Avatar == "" || item.CountryID != 86 || item.CountryCode != "CN" || item.RegionID != 70 || item.RegionCode != "east-asia" || item.Status != hostdomain.CoinSellerStatusActive {
|
|
t.Fatalf("coin seller item mismatch: %+v", item)
|
|
}
|
|
}
|
|
|
|
func TestGetUserRoleSummaryAggregatesRolesAndPendingInvitations(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
seedActiveUser(t, repository, 931, 60)
|
|
seedActiveUser(t, repository, 932, 60)
|
|
repository.PutHostProfile(hostdomain.HostProfile{
|
|
UserID: 931,
|
|
Status: hostdomain.HostStatusActive,
|
|
RegionID: 60,
|
|
CurrentAgencyID: 933,
|
|
Source: hostdomain.HostSourceAdminCreateAgency,
|
|
})
|
|
repository.PutAgency(hostdomain.Agency{
|
|
AgencyID: 933,
|
|
OwnerUserID: 931,
|
|
RegionID: 60,
|
|
ParentBDUserID: 931,
|
|
Status: hostdomain.AgencyStatusActive,
|
|
JoinEnabled: true,
|
|
})
|
|
repository.PutBDProfile(hostdomain.BDProfile{
|
|
UserID: 931,
|
|
Role: hostdomain.BDRoleLeader,
|
|
RegionID: 60,
|
|
Status: hostdomain.BDStatusActive,
|
|
})
|
|
repository.PutManagerProfile(hostdomain.ManagerProfile{
|
|
UserID: 931,
|
|
Status: hostdomain.ManagerStatusActive,
|
|
})
|
|
svc := newHostService(repository, 8000, 9000)
|
|
if _, err := svc.CreateCoinSeller(ctx, hostservice.CreateCoinSellerInput{
|
|
CommandID: "admin-create-coin-seller-931",
|
|
AdminUserID: 1,
|
|
TargetUserID: 931,
|
|
Reason: "summary test",
|
|
}); err != nil {
|
|
t.Fatalf("CreateCoinSeller failed: %v", err)
|
|
}
|
|
invite932, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-bd-932",
|
|
InviterUserID: 931,
|
|
TargetUserID: 932,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("InviteBD failed: %v", err)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-bd-932",
|
|
ActorUserID: 932,
|
|
InvitationID: invite932.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("accept InviteBD for summary failed: %v", err)
|
|
}
|
|
|
|
summary, err := svc.GetUserRoleSummary(ctx, 931)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary failed: %v", err)
|
|
}
|
|
if !summary.IsHost || !summary.IsAgency || !summary.IsManager || summary.IsBD || !summary.IsBDLeader || !summary.IsCoinSeller || summary.AgencyID != 933 || summary.BDID != 931 {
|
|
t.Fatalf("leader-only role summary mismatch: %+v", summary)
|
|
}
|
|
selfInvite, err := svc.InviteBD(ctx, hostservice.InviteBDInput{
|
|
CommandID: "invite-bd-self-931",
|
|
InviterUserID: 931,
|
|
TargetUserID: 931,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("self InviteBD for summary failed: %v", err)
|
|
}
|
|
if _, err := svc.ProcessRoleInvitation(ctx, hostservice.ProcessRoleInvitationInput{
|
|
CommandID: "accept-bd-self-931-summary",
|
|
ActorUserID: 931,
|
|
InvitationID: selfInvite.InvitationID,
|
|
Action: hostdomain.InvitationActionAccept,
|
|
}); err != nil {
|
|
t.Fatalf("accept self InviteBD for summary failed: %v", err)
|
|
}
|
|
combinedSummary, err := svc.GetUserRoleSummary(ctx, 931)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary combined failed: %v", err)
|
|
}
|
|
if !combinedSummary.IsBD || !combinedSummary.IsBDLeader || combinedSummary.BDID != 931 {
|
|
t.Fatalf("bd plus leader role summary mismatch: %+v", combinedSummary)
|
|
}
|
|
directBD, err := svc.GetUserRoleSummary(ctx, 932)
|
|
if err != nil {
|
|
t.Fatalf("GetUserRoleSummary direct bd failed: %v", err)
|
|
}
|
|
if directBD.PendingRoleInvitations != 0 || directBD.IsHost || !directBD.IsBD || directBD.BDID != 932 {
|
|
t.Fatalf("direct bd role summary mismatch: %+v", directBD)
|
|
}
|
|
}
|