173 lines
6.8 KiB
Go
173 lines
6.8 KiB
Go
package tasks
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.118im.com/im_team/olons_server/internal/store"
|
|
)
|
|
|
|
type fakeRepository struct {
|
|
config json.RawMessage
|
|
eligibility *store.TaskEligibility
|
|
order *store.TaskOrder
|
|
claimed store.ClaimTaskInput
|
|
submitted store.TaskSubmissionInput
|
|
}
|
|
|
|
func (f *fakeRepository) CurrentSiteConfig(context.Context, int64) (json.RawMessage, error) {
|
|
return f.config, nil
|
|
}
|
|
func (f *fakeRepository) TaskHalls(context.Context, int64, int64) ([]store.TaskHall, error) {
|
|
return []store.TaskHall{{ID: 1, Code: "DEFAULT", Name: "任务大厅"}}, nil
|
|
}
|
|
func (f *fakeRepository) TaskEligibility(context.Context, int64, int64, int64) (*store.TaskEligibility, error) {
|
|
return f.eligibility, nil
|
|
}
|
|
func (f *fakeRepository) ClaimTask(_ context.Context, input store.ClaimTaskInput) (*store.TaskOrder, error) {
|
|
f.claimed = input
|
|
return &store.TaskOrder{ID: 9, OrderNo: input.OrderNo, OrderStatus: 1, Currency: "CNY",
|
|
DeadlineAt: input.DeadlineAt.Format(time.RFC3339)}, nil
|
|
}
|
|
func (f *fakeRepository) AutoMatchTaskOrder(context.Context, int64, int64, int64, int, int64, int64) error {
|
|
if f.order != nil && f.order.OrderStatus == 1 {
|
|
f.order.OrderStatus = 2
|
|
f.order.ProductID = 7
|
|
f.order.ProductName = "自动匹配商品"
|
|
f.order.Quantity = 1
|
|
f.order.TotalAmount = 10000
|
|
f.order.CommissionAmount = 100
|
|
}
|
|
return nil
|
|
}
|
|
func (f *fakeRepository) TaskOrders(context.Context, int64, int64, int, int, int) (*store.TaskOrderPage, error) {
|
|
return &store.TaskOrderPage{Items: []store.TaskOrder{*f.order}, Total: 1}, nil
|
|
}
|
|
func (f *fakeRepository) TaskOrder(context.Context, int64, int64, int64) (*store.TaskOrder, error) {
|
|
return f.order, nil
|
|
}
|
|
func (f *fakeRepository) TaskStats(context.Context, int64, int64) (*store.TaskStats, error) {
|
|
return &store.TaskStats{AvailableAmount: 100, FrozenAmount: 25}, nil
|
|
}
|
|
func (f *fakeRepository) SubmitTask(_ context.Context, input store.TaskSubmissionInput) (*store.TaskSubmissionResult, error) {
|
|
f.submitted = input
|
|
return &store.TaskSubmissionResult{SubmissionNo: input.SubmissionNo, OrderStatus: 4,
|
|
SubmittedAt: time.Date(2026, 10, 9, 2, 0, 0, 0, time.UTC)}, nil
|
|
}
|
|
func (f *fakeRepository) OrderLedgers(context.Context, int64, int64, []string) ([]map[string]any, error) {
|
|
return []map[string]any{}, nil
|
|
}
|
|
|
|
func TestEligibilityRequiresFixedMinimumBalance(t *testing.T) {
|
|
repository := &fakeRepository{config: json.RawMessage(`{"features":{"task_enabled":true},"task_minimum_amount":0}`),
|
|
eligibility: &store.TaskEligibility{MemberStatus: 1, AutoDispatch: 1, HallEligible: true, AvailableAmount: 29899, WalletStatus: 1, DailyLimit: 5, TodayCount: 2}}
|
|
service := New(repository)
|
|
|
|
result, err := service.Eligibility(context.Background(), 0, 10, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Eligible || result.Reason != "INSUFFICIENT_BALANCE" || result.MinimumAmount != 29900 {
|
|
t.Fatalf("unexpected eligibility: %#v", result)
|
|
}
|
|
}
|
|
|
|
func TestEligibilityAlsoRequiresMinimumForManualDispatch(t *testing.T) {
|
|
repository := &fakeRepository{config: json.RawMessage(`{"features":{"task_enabled":true}}`),
|
|
eligibility: &store.TaskEligibility{MemberStatus: 1, AutoDispatch: 2, HallEligible: true, AvailableAmount: 29899, WalletStatus: 1, DailyLimit: 5}}
|
|
service := New(repository)
|
|
|
|
result, err := service.Eligibility(context.Background(), 0, 10, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Eligible || result.Reason != "INSUFFICIENT_BALANCE" {
|
|
t.Fatalf("manual dispatch must use the same minimum balance gate: %#v", result)
|
|
}
|
|
}
|
|
|
|
func TestEligibilityDoesNotEnforceDisplayedBusinessHours(t *testing.T) {
|
|
repository := &fakeRepository{config: json.RawMessage(`{"features":{"task_enabled":true},"task_business_start_at":"09:00","task_business_end_at":"21:00"}`),
|
|
eligibility: &store.TaskEligibility{MemberStatus: 1, AutoDispatch: 1, HallEligible: true, AvailableAmount: 29900, WalletStatus: 1, DailyLimit: 5}}
|
|
service := New(repository)
|
|
service.now = func() time.Time { return time.Date(2026, 10, 9, 23, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*60*60)) }
|
|
|
|
result, err := service.Eligibility(context.Background(), 0, 10, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !result.Eligible || result.BusinessStartAt != "09:00:00+08:00" || result.BusinessEndAt != "21:00:00+08:00" {
|
|
t.Fatalf("business hours are display-only: %#v", result)
|
|
}
|
|
}
|
|
|
|
func TestClaimDefaultsToEnabledWithoutTaskSwitch(t *testing.T) {
|
|
repository := &fakeRepository{config: json.RawMessage(`{}`)}
|
|
service := New(repository)
|
|
service.now = func() time.Time { return time.Date(2026, 10, 9, 2, 0, 0, 0, time.UTC) }
|
|
|
|
if _, err := service.Claim(context.Background(), 0, 10, 1); err != nil {
|
|
t.Fatalf("missing switch should default to enabled, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestClaimHonorsExplicitDisabledTaskSwitch(t *testing.T) {
|
|
repository := &fakeRepository{config: json.RawMessage(`{"features":{"task_enabled":false}}`)}
|
|
service := New(repository)
|
|
|
|
_, err := service.Claim(context.Background(), 0, 10, 1)
|
|
if !errors.Is(err, ErrTaskDisabled) {
|
|
t.Fatalf("expected explicitly disabled task, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestClaimBuildsMatchingOrder(t *testing.T) {
|
|
repository := &fakeRepository{config: json.RawMessage(`{"task_enabled":true,"task_deadline_minutes":20}`)}
|
|
service := New(repository)
|
|
now := time.Date(2026, 10, 9, 2, 0, 0, 0, time.UTC)
|
|
service.now = func() time.Time { return now }
|
|
|
|
result, err := service.Claim(context.Background(), 0, 10, 2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Status != "matching" || repository.claimed.HallID != 2 ||
|
|
repository.claimed.MinimumAmount != 29900 || !repository.claimed.DeadlineAt.Equal(now.Add(20*time.Minute)) {
|
|
t.Fatalf("unexpected claim: result=%#v input=%#v", result, repository.claimed)
|
|
}
|
|
}
|
|
|
|
func TestSubmitAutomaticallySettlesWithoutEvidence(t *testing.T) {
|
|
repository := &fakeRepository{}
|
|
service := New(repository)
|
|
service.now = func() time.Time { return time.Date(2026, 10, 9, 2, 0, 0, 0, time.UTC) }
|
|
|
|
result, err := service.Submit(context.Background(), 0, 10, 9, SubmitInput{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Status != "settled" || result.OrderStatus != "completed" || repository.submitted.IdempotencyKey != "task:9:auto-settle" || repository.submitted.LedgerNo == "" {
|
|
t.Fatalf("unexpected submission: result=%#v input=%#v", result, repository.submitted)
|
|
}
|
|
}
|
|
|
|
func TestSubmitStillValidatesOptionalEvidence(t *testing.T) {
|
|
service := New(&fakeRepository{})
|
|
tooLong := strings.Repeat("字", 2001)
|
|
if _, err := service.Submit(context.Background(), 0, 10, 9, SubmitInput{EvidenceText: tooLong}); !errors.Is(err, ErrEvidenceInvalid) {
|
|
t.Fatalf("expected evidence error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestOrdersRejectsUnknownStatus(t *testing.T) {
|
|
service := New(&fakeRepository{})
|
|
_, err := service.Orders(context.Background(), 0, 10, 1, 20, "not-a-status")
|
|
if !errors.Is(err, ErrStatusInvalid) {
|
|
t.Fatalf("expected status error, got %v", err)
|
|
}
|
|
}
|