517 lines
17 KiB
Go
517 lines
17 KiB
Go
package managercenter
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"chatapp3-golang/internal/integration"
|
|
"chatapp3-golang/internal/model"
|
|
|
|
"gorm.io/driver/sqlite"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type fakeManagerGateway struct {
|
|
recharges map[int64][]integration.UserTotalRecharge
|
|
rechargeErr error
|
|
abilities map[int64]integration.PropsNobleVIPAbility
|
|
maxAbility integration.PropsNobleVIPAbility
|
|
giveRequests []integration.GivePropsBackpackRequest
|
|
punishRequests []integration.PunishAccountRequest
|
|
unblockRequests []integration.UnblockAccountRequest
|
|
switchIDs []int64
|
|
cacheCleared []int64
|
|
badgeIDs []int64
|
|
}
|
|
|
|
func (f *fakeManagerGateway) GetUserProfile(context.Context, int64) (integration.UserProfile, error) {
|
|
return integration.UserProfile{}, nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) GetUserProfileByAccountOne(context.Context, string) (integration.UserProfile, error) {
|
|
return integration.UserProfile{}, nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) MapUserTotalRecharge(_ context.Context, userIDs []int64) (map[int64][]integration.UserTotalRecharge, error) {
|
|
if f.rechargeErr != nil {
|
|
return nil, f.rechargeErr
|
|
}
|
|
result := make(map[int64][]integration.UserTotalRecharge, len(userIDs))
|
|
for _, userID := range userIDs {
|
|
result[userID] = f.recharges[userID]
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) GivePropsBackpack(_ context.Context, req integration.GivePropsBackpackRequest) error {
|
|
f.giveRequests = append(f.giveRequests, req)
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) GetNobleVIPAbility(_ context.Context, sourceID int64) (integration.PropsNobleVIPAbility, error) {
|
|
return f.abilities[sourceID], nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) GetUserMaxNobleVIPAbility(context.Context, int64) (integration.PropsNobleVIPAbility, error) {
|
|
return f.maxAbility, nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) SwitchUseProps(_ context.Context, _ int64, propsID int64) error {
|
|
f.switchIDs = append(f.switchIDs, propsID)
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) ActivateTemporaryBadge(_ context.Context, _ int64, badgeID int64, _ int) error {
|
|
f.badgeIDs = append(f.badgeIDs, badgeID)
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) RemoveUserProfileCacheAll(_ context.Context, userID int64) error {
|
|
f.cacheCleared = append(f.cacheCleared, userID)
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) PunishAccount(_ context.Context, req integration.PunishAccountRequest) error {
|
|
f.punishRequests = append(f.punishRequests, req)
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeManagerGateway) UnblockAccount(_ context.Context, req integration.UnblockAccountRequest) error {
|
|
f.unblockRequests = append(f.unblockRequests, req)
|
|
return nil
|
|
}
|
|
|
|
func TestListPropsRequiresAdminFreeAndFiltersVIPLevels(t *testing.T) {
|
|
service, _ := newManagerCenterTestService(t)
|
|
seedManager(t, service.db.(*gorm.DB), 1)
|
|
seedProps(t, service.db.(*gorm.DB),
|
|
propsSourceRecordRow{ID: 101, Type: propsTypeRide, Name: "Giftable ride", AdminFree: true},
|
|
propsSourceRecordRow{ID: 102, Type: propsTypeRide, Name: "Paid ride", AdminFree: false},
|
|
propsSourceRecordRow{ID: 201, Type: propsTypeNobleVIP, Name: "VIP 3", AdminFree: true},
|
|
propsSourceRecordRow{ID: 204, Type: propsTypeNobleVIP, Name: "VIP 4", AdminFree: true},
|
|
)
|
|
seedAbilities(t, service.db.(*gorm.DB),
|
|
propsNobleVIPAbilityRow{ID: 201, VIPLevel: 3},
|
|
propsNobleVIPAbilityRow{ID: 204, VIPLevel: 4},
|
|
)
|
|
|
|
resp, err := service.ListProps(context.Background(), AuthUser{UserID: 1}, "")
|
|
if err != nil {
|
|
t.Fatalf("ListProps() error = %v", err)
|
|
}
|
|
|
|
got := map[int64]PropsView{}
|
|
for _, item := range resp.Records {
|
|
got[item.ID.Int64()] = item
|
|
}
|
|
if _, ok := got[101]; !ok {
|
|
t.Fatalf("records = %+v, want giftable ride", resp.Records)
|
|
}
|
|
if _, ok := got[102]; ok {
|
|
t.Fatalf("records = %+v, non-admin-free props must be hidden", resp.Records)
|
|
}
|
|
if item, ok := got[201]; !ok || item.Days != defaultVIPGiftDays || item.VIPLevel != 3 {
|
|
t.Fatalf("vip 201 = %+v, want level 3 with 3 days", item)
|
|
}
|
|
if _, ok := got[204]; ok {
|
|
t.Fatalf("records = %+v, VIP level 4 must be hidden", resp.Records)
|
|
}
|
|
}
|
|
|
|
func TestListPropsReturnsVIPLevelConfigs(t *testing.T) {
|
|
service, _ := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedVIPConfigs(t, db,
|
|
model.VipLevelConfig{ID: 301, SysOrigin: "LIKEI", Level: 1, LevelCode: "VIP1", DisplayName: "VIP 1", Enabled: true, DurationDays: 30},
|
|
model.VipLevelConfig{ID: 302, SysOrigin: "LIKEI", Level: 2, LevelCode: "VIP2", DisplayName: "VIP 2", Enabled: false, DurationDays: 30},
|
|
model.VipLevelConfig{ID: 303, SysOrigin: "ATYOU", Level: 1, LevelCode: "VIP1", DisplayName: "ATYOU VIP 1", Enabled: true, DurationDays: 30},
|
|
)
|
|
|
|
resp, err := service.ListProps(context.Background(), AuthUser{UserID: 1, SysOrigin: "LIKEI"}, propsTypeNobleVIP)
|
|
if err != nil {
|
|
t.Fatalf("ListProps() error = %v", err)
|
|
}
|
|
if len(resp.Records) != 1 {
|
|
t.Fatalf("records = %+v, want only one enabled LIKEI vip config", resp.Records)
|
|
}
|
|
got := resp.Records[0]
|
|
if got.ID.Int64() != 301 || got.Type != propsTypeNobleVIP || got.VIPLevel != 1 || got.Days != 30 {
|
|
t.Fatalf("vip props = %+v, want config 301 level 1", got)
|
|
}
|
|
}
|
|
|
|
func TestGetProfileToleratesRechargeQueryFailure(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 1, Account: "1"})
|
|
fake.rechargeErr = errors.New("order service unavailable")
|
|
|
|
resp, err := service.GetProfile(context.Background(), AuthUser{UserID: 1})
|
|
if err != nil {
|
|
t.Fatalf("GetProfile() error = %v", err)
|
|
}
|
|
if resp.Manager.HasRecharge || resp.Manager.CanBan {
|
|
t.Fatalf("manager = %+v, want unknown recharge state and ban disabled", resp.Manager)
|
|
}
|
|
}
|
|
|
|
func TestSendPropsRejectsNonAdminFree(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2"})
|
|
seedProps(t, db, propsSourceRecordRow{ID: 102, Type: propsTypeRide, Name: "Paid ride", AdminFree: false})
|
|
|
|
_, err := service.SendProps(context.Background(), AuthUser{UserID: 1}, SendPropsRequest{
|
|
AcceptUserID: ID(2),
|
|
PropsID: ID(102),
|
|
})
|
|
assertAppErrorCode(t, err, "prop_not_giftable")
|
|
if len(fake.giveRequests) != 0 {
|
|
t.Fatalf("give requests = %+v, want none", fake.giveRequests)
|
|
}
|
|
}
|
|
|
|
func TestSendNobleVIPGivesAccessoriesAndSwitchesMax(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2"})
|
|
seedProps(t, db, propsSourceRecordRow{ID: 201, Type: propsTypeNobleVIP, Name: "VIP 3", AdminFree: true})
|
|
seedAbilities(t, db, propsNobleVIPAbilityRow{ID: 201, VIPLevel: 3})
|
|
fake.abilities[201] = integration.PropsNobleVIPAbility{
|
|
ID: integration.Int64Value(201),
|
|
AvatarFrameID: integration.Int64Value(302),
|
|
CarID: integration.Int64Value(301),
|
|
ChatBubbleID: integration.Int64Value(303),
|
|
DataCardID: integration.Int64Value(304),
|
|
}
|
|
fake.maxAbility = fake.abilities[201]
|
|
|
|
resp, err := service.SendProps(context.Background(), AuthUser{UserID: 1}, SendPropsRequest{
|
|
AcceptUserID: ID(2),
|
|
PropsID: ID(201),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SendProps() error = %v", err)
|
|
}
|
|
if !resp.Success || resp.Days != defaultVIPGiftDays {
|
|
t.Fatalf("resp = %+v, want success and VIP days", resp)
|
|
}
|
|
if len(fake.giveRequests) != 5 {
|
|
t.Fatalf("give requests = %+v, want main VIP plus 4 accessories", fake.giveRequests)
|
|
}
|
|
for _, req := range fake.giveRequests {
|
|
if req.AcceptUserID != 2 || req.Origin != adminFreeOrigin || req.OpUser != 1 || !req.UseProps || req.AllowGive {
|
|
t.Fatalf("give request = %+v, want admin-free grant to target", req)
|
|
}
|
|
}
|
|
wantSwitch := []int64{201, 302, 304, 301, 303}
|
|
if !equalInt64Slice(fake.switchIDs, wantSwitch) {
|
|
t.Fatalf("switch ids = %+v, want %+v", fake.switchIDs, wantSwitch)
|
|
}
|
|
if !equalInt64Slice(fake.cacheCleared, []int64{2}) {
|
|
t.Fatalf("cacheCleared = %+v, want [2]", fake.cacheCleared)
|
|
}
|
|
}
|
|
|
|
func TestSendVIPUsesVIPLevelConfig(t *testing.T) {
|
|
service, _ := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db,
|
|
userBaseInfoRow{ID: 1, Account: "1", UserNickname: "manager", OriginSys: "LIKEI"},
|
|
userBaseInfoRow{ID: 2, Account: "2", OriginSys: "LIKEI"},
|
|
)
|
|
seedVIPConfigs(t, db, model.VipLevelConfig{
|
|
ID: 301,
|
|
SysOrigin: "LIKEI",
|
|
Level: 3,
|
|
LevelCode: "VIP3",
|
|
DisplayName: "VIP 3",
|
|
Enabled: true,
|
|
DurationDays: 30,
|
|
PriceGold: 3000,
|
|
})
|
|
|
|
resp, err := service.SendProps(context.Background(), AuthUser{UserID: 1, SysOrigin: "LIKEI"}, SendPropsRequest{
|
|
AcceptUserID: ID(2),
|
|
PropsID: ID(301),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SendProps() error = %v", err)
|
|
}
|
|
if !resp.Success || resp.Type != propsTypeNobleVIP || resp.VIPLevel != 3 || resp.Days != 30 {
|
|
t.Fatalf("resp = %+v, want vip gift success", resp)
|
|
}
|
|
|
|
var state model.UserVipState
|
|
if err := db.Where("sys_origin = ? AND user_id = ?", "LIKEI", int64(2)).First(&state).Error; err != nil {
|
|
t.Fatalf("load state: %v", err)
|
|
}
|
|
if state.Level != 3 || state.Status != vipStatusActive {
|
|
t.Fatalf("state = %+v, want vip3 active", state)
|
|
}
|
|
var orders int64
|
|
if err := db.Model(&model.VipOrderRecord{}).Where("user_id = ? AND order_type = ?", int64(2), vipOrderTypeGMGift).Count(&orders).Error; err != nil {
|
|
t.Fatalf("count orders: %v", err)
|
|
}
|
|
if orders != 1 {
|
|
t.Fatalf("orders = %d, want 1", orders)
|
|
}
|
|
var records int64
|
|
if err := db.Model(&gmVIPGiftRecordRow{}).Where("user_id = ? AND vip_level = ?", int64(2), 3).Count(&records).Error; err != nil {
|
|
t.Fatalf("count gift records: %v", err)
|
|
}
|
|
if records != 1 {
|
|
t.Fatalf("gift records = %d, want 1", records)
|
|
}
|
|
}
|
|
|
|
func TestBanUserRejectsRechargedUser(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2"})
|
|
fake.recharges[2] = []integration.UserTotalRecharge{{Amount: integration.DecimalString("1.00")}}
|
|
|
|
_, err := service.BanUser(context.Background(), AuthUser{UserID: 1}, BanUserRequest{UserID: ID(2)})
|
|
assertAppErrorCode(t, err, "user_recharged")
|
|
if len(fake.punishRequests) != 0 {
|
|
t.Fatalf("punish requests = %+v, want none", fake.punishRequests)
|
|
}
|
|
}
|
|
|
|
func TestBanUserFailsWhenRechargeQueryUnavailable(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2"})
|
|
fake.rechargeErr = errors.New("order service unavailable")
|
|
|
|
_, err := service.BanUser(context.Background(), AuthUser{UserID: 1}, BanUserRequest{UserID: ID(2)})
|
|
assertAppErrorCode(t, err, "recharge_query_failed")
|
|
if len(fake.punishRequests) != 0 {
|
|
t.Fatalf("punish requests = %+v, want none", fake.punishRequests)
|
|
}
|
|
}
|
|
|
|
func TestBanUserRejectsArchivedUser(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2", AccountStatus: accountStatusArchive})
|
|
|
|
_, err := service.BanUser(context.Background(), AuthUser{UserID: 1}, BanUserRequest{UserID: ID(2)})
|
|
assertAppErrorCode(t, err, "user_already_banned")
|
|
if len(fake.punishRequests) != 0 {
|
|
t.Fatalf("punish requests = %+v, want none", fake.punishRequests)
|
|
}
|
|
}
|
|
|
|
func TestBanUserRejectsFrozenUser(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2", AccountStatus: accountStatusFreeze})
|
|
|
|
_, err := service.BanUser(context.Background(), AuthUser{UserID: 1}, BanUserRequest{UserID: ID(2)})
|
|
assertAppErrorCode(t, err, "user_already_banned")
|
|
if len(fake.punishRequests) != 0 {
|
|
t.Fatalf("punish requests = %+v, want none", fake.punishRequests)
|
|
}
|
|
}
|
|
|
|
func TestBanUserWithoutRechargeCallsPunishment(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2"})
|
|
|
|
resp, err := service.BanUser(context.Background(), AuthUser{UserID: 1}, BanUserRequest{
|
|
UserID: ID(2),
|
|
Reason: "spam",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("BanUser() error = %v", err)
|
|
}
|
|
if !resp.Success || resp.AccountStatus != accountStatusArchive {
|
|
t.Fatalf("resp = %+v, want archived success", resp)
|
|
}
|
|
if len(fake.punishRequests) != 1 {
|
|
t.Fatalf("punish requests = %+v, want one", fake.punishRequests)
|
|
}
|
|
got := fake.punishRequests[0]
|
|
if got.BeOptUserID != 2 || got.OptUserID != 1 || got.Status != accountStatusArchive {
|
|
t.Fatalf("punish request = %+v, want target 2 manager 1 archive", got)
|
|
}
|
|
}
|
|
|
|
func TestUnbanUserRejectsNormalUser(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2", AccountStatus: accountStatusNormal})
|
|
|
|
_, err := service.UnbanUser(context.Background(), AuthUser{UserID: 1}, UnbanUserRequest{UserID: ID(2)})
|
|
assertAppErrorCode(t, err, "user_not_banned")
|
|
if len(fake.unblockRequests) != 0 {
|
|
t.Fatalf("unblock requests = %+v, want none", fake.unblockRequests)
|
|
}
|
|
}
|
|
|
|
func TestUnbanUserCallsUnblockAccount(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2", AccountStatus: accountStatusArchive})
|
|
|
|
resp, err := service.UnbanUser(context.Background(), AuthUser{UserID: 1}, UnbanUserRequest{
|
|
UserID: ID(2),
|
|
Reason: "appeal passed",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("UnbanUser() error = %v", err)
|
|
}
|
|
if !resp.Success || resp.AccountStatus != accountStatusNormal {
|
|
t.Fatalf("resp = %+v, want normal success", resp)
|
|
}
|
|
if len(fake.unblockRequests) != 1 {
|
|
t.Fatalf("unblock requests = %+v, want one", fake.unblockRequests)
|
|
}
|
|
got := fake.unblockRequests[0]
|
|
if got.BeOptUserID != 2 || got.OptUserID != 1 {
|
|
t.Fatalf("unblock request = %+v, want target 2 manager 1", got)
|
|
}
|
|
if got.Description == "" || !strings.Contains(got.Description, "appeal passed") {
|
|
t.Fatalf("description = %q, want reason included", got.Description)
|
|
}
|
|
}
|
|
|
|
func TestUnbanUserAllowsFrozenUser(t *testing.T) {
|
|
service, fake := newManagerCenterTestService(t)
|
|
db := service.db.(*gorm.DB)
|
|
seedManager(t, db, 1)
|
|
seedUsers(t, db, userBaseInfoRow{ID: 2, Account: "2", AccountStatus: accountStatusFreeze})
|
|
|
|
resp, err := service.UnbanUser(context.Background(), AuthUser{UserID: 1}, UnbanUserRequest{UserID: ID(2)})
|
|
if err != nil {
|
|
t.Fatalf("UnbanUser() error = %v", err)
|
|
}
|
|
if !resp.Success || resp.AccountStatus != accountStatusNormal {
|
|
t.Fatalf("resp = %+v, want normal success", resp)
|
|
}
|
|
if len(fake.unblockRequests) != 1 {
|
|
t.Fatalf("unblock requests = %+v, want one", fake.unblockRequests)
|
|
}
|
|
}
|
|
|
|
func newManagerCenterTestService(t *testing.T) (*Service, *fakeManagerGateway) {
|
|
t.Helper()
|
|
db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
|
|
if err != nil {
|
|
t.Fatalf("open sqlite: %v", err)
|
|
}
|
|
if err := db.AutoMigrate(
|
|
&administratorRow{},
|
|
&userBaseInfoRow{},
|
|
&propsSourceRecordRow{},
|
|
&propsNobleVIPAbilityRow{},
|
|
&model.VipLevelConfig{},
|
|
&model.UserVipState{},
|
|
&model.VipOrderRecord{},
|
|
&gmVIPGiftRecordRow{},
|
|
); err != nil {
|
|
t.Fatalf("auto migrate: %v", err)
|
|
}
|
|
fake := &fakeManagerGateway{
|
|
recharges: map[int64][]integration.UserTotalRecharge{},
|
|
abilities: map[int64]integration.PropsNobleVIPAbility{},
|
|
}
|
|
return NewService(db, fake), fake
|
|
}
|
|
|
|
func seedManager(t *testing.T, db *gorm.DB, userID int64) {
|
|
t.Helper()
|
|
if err := db.Create(&administratorRow{ID: userID, UserID: userID, Status: true}).Error; err != nil {
|
|
t.Fatalf("seed manager: %v", err)
|
|
}
|
|
}
|
|
|
|
func seedUsers(t *testing.T, db *gorm.DB, rows ...userBaseInfoRow) {
|
|
t.Helper()
|
|
for _, row := range rows {
|
|
if row.AccountStatus == "" {
|
|
row.AccountStatus = "ACTIVE"
|
|
}
|
|
if err := db.Create(&row).Error; err != nil {
|
|
t.Fatalf("seed user: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func seedProps(t *testing.T, db *gorm.DB, rows ...propsSourceRecordRow) {
|
|
t.Helper()
|
|
for _, row := range rows {
|
|
if err := db.Create(&row).Error; err != nil {
|
|
t.Fatalf("seed props: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func seedAbilities(t *testing.T, db *gorm.DB, rows ...propsNobleVIPAbilityRow) {
|
|
t.Helper()
|
|
for _, row := range rows {
|
|
if err := db.Create(&row).Error; err != nil {
|
|
t.Fatalf("seed ability: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func seedVIPConfigs(t *testing.T, db *gorm.DB, rows ...model.VipLevelConfig) {
|
|
t.Helper()
|
|
now := time.Now()
|
|
for _, row := range rows {
|
|
if row.CreateTime.IsZero() {
|
|
row.CreateTime = now
|
|
}
|
|
if row.UpdateTime.IsZero() {
|
|
row.UpdateTime = now
|
|
}
|
|
if err := db.Create(&row).Error; err != nil {
|
|
t.Fatalf("seed vip config: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func assertAppErrorCode(t *testing.T, err error, code string) {
|
|
t.Helper()
|
|
if err == nil {
|
|
t.Fatalf("error is nil, want code %s", code)
|
|
}
|
|
var appErr *AppError
|
|
if !errors.As(err, &appErr) {
|
|
t.Fatalf("error = %T %v, want AppError", err, err)
|
|
}
|
|
if appErr.Code != code {
|
|
t.Fatalf("error code = %s, want %s", appErr.Code, code)
|
|
}
|
|
}
|
|
|
|
func equalInt64Slice(a, b []int64) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := range a {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|