sub2api-cn-relay-manager/internal/provision/import_service_test.go

package provision

import (
	"context"
	"errors"
	"fmt"
	"reflect"
	"strings"
	"testing"

	"sub2api-cn-relay-manager/internal/host/sub2api"
	"sub2api-cn-relay-manager/internal/pack"
)

func TestImportServiceImportSubscriptionFlow(t *testing.T) {
	host := &fakeHostAdapter{
		batchAccounts: []sub2api.AccountRef{{ID: "account_1"}, {ID: "account_2"}},
		testResults: map[string]sub2api.ProbeResult{
			"account_1": {OK: true, Status: "passed"},
			"account_2": {OK: true, Status: "passed"},
		},
		models: map[string][]sub2api.AccountModel{
			"account_1": {{ID: "deepseek-chat"}},
			"account_2": {{ID: "deepseek-chat"}},
		},
		gatewayResult: sub2api.GatewayAccessResult{OK: true, StatusCode: 200, HasExpectedModel: true, Models: []string{"deepseek-chat"}},
	}

	svc := NewImportService(host)
	report, err := svc.Import(context.Background(), ImportRequest{
		Provider: sampleProviderManifest(),
		Mode:     ImportModePartial,
		Access: AccessRequest{
			Mode:          AccessModeSubscription,
			ProbeAPIKey:   "user-key",
			Subscriptions: []SubscriptionTarget{{UserID: "user_1", DurationDays: 30}},
		},
		Keys: []string{" key-1 ", "key-2", "key-1"},
	})
	if err != nil {
		t.Fatalf("Import() error = %v", err)
	}

	if report.BatchStatus != BatchStatusSucceeded {
		t.Fatalf("BatchStatus = %q, want %q", report.BatchStatus, BatchStatusSucceeded)
	}
	if report.ProviderStatus != ProviderStatusActive {
		t.Fatalf("ProviderStatus = %q, want %q", report.ProviderStatus, ProviderStatusActive)
	}
	if report.AccessStatus != AccessStatusSubscriptionReady {
		t.Fatalf("AccessStatus = %q, want %q", report.AccessStatus, AccessStatusSubscriptionReady)
	}
	if !reflect.DeepEqual(report.AcceptedKeys, []string{"key-1", "key-2"}) {
		t.Fatalf("AcceptedKeys = %#v, want deduped normalized keys", report.AcceptedKeys)
	}
	if len(host.assignedSubscriptions) != 1 {
		t.Fatalf("assigned subscriptions = %d, want 1", len(host.assignedSubscriptions))
	}
	if host.gatewayProbe.ExpectedModel != "deepseek-chat" {
		t.Fatalf("gateway probe model = %q, want %q", host.gatewayProbe.ExpectedModel, "deepseek-chat")
	}
}

func TestImportServiceStrictModeFailsWhenAnyAccountProbeFails(t *testing.T) {
	host := &fakeHostAdapter{
		batchAccounts: []sub2api.AccountRef{{ID: "account_1"}, {ID: "account_2"}},
		testResults: map[string]sub2api.ProbeResult{
			"account_1": {OK: true, Status: "passed"},
			"account_2": {OK: false, Status: "failed", Message: "bad key"},
		},
		models: map[string][]sub2api.AccountModel{
			"account_1": {{ID: "deepseek-chat"}},
			"account_2": {{ID: "deepseek-chat"}},
		},
	}

	svc := NewImportService(host)
	report, err := svc.Import(context.Background(), ImportRequest{
		Provider: sampleProviderManifest(),
		Mode:     ImportModeStrict,
		Access:   AccessRequest{Mode: AccessModeSelfService, ProbeAPIKey: "user-key"},
		Keys:     []string{"key-1", "key-2"},
	})
	if err == nil {
		t.Fatal("Import() error = nil, want strict mode failure")
	}
	if report.BatchStatus != BatchStatusFailed {
		t.Fatalf("BatchStatus = %q, want %q", report.BatchStatus, BatchStatusFailed)
	}
	if report.ProviderStatus != ProviderStatusFailed {
		t.Fatalf("ProviderStatus = %q, want %q", report.ProviderStatus, ProviderStatusFailed)
	}
}

func TestImportServiceRejectsUnknownMode(t *testing.T) {
	svc := NewImportService(&fakeHostAdapter{})
	_, err := svc.Import(context.Background(), ImportRequest{
		Provider: sampleProviderManifest(),
		Mode:     "unknown",
		Access:   AccessRequest{Mode: AccessModeSelfService},
		Keys:     []string{"key-1"},
	})
	if err == nil {
		t.Fatal("Import() error = nil, want mode validation error")
	}
}

func TestImportServiceStrictModeRollsBackCreatedResources(t *testing.T) {
	host := &fakeHostAdapter{
		batchAccounts: []sub2api.AccountRef{{ID: "account_1"}, {ID: "account_2"}},
		testResults: map[string]sub2api.ProbeResult{
			"account_1": {OK: true, Status: "passed"},
			"account_2": {OK: false, Status: "failed", Message: "bad key"},
		},
		models: map[string][]sub2api.AccountModel{
			"account_1": {{ID: "deepseek-chat"}},
			"account_2": {{ID: "deepseek-chat"}},
		},
	}

	svc := NewImportService(host)
	_, err := svc.Import(context.Background(), ImportRequest{
		Provider: sampleProviderManifest(),
		Mode:     ImportModeStrict,
		Access:   AccessRequest{Mode: AccessModeSelfService, ProbeAPIKey: "user-key"},
		Keys:     []string{"key-1", "key-2"},
	})
	if err == nil {
		t.Fatal("Import() error = nil, want strict mode failure")
	}

	want := []string{"account:account_2", "account:account_1", "channel:channel_1", "group:group_1"}
	if !reflect.DeepEqual(host.deletedResources, want) {
		t.Fatalf("deleted resources = %#v, want %#v", host.deletedResources, want)
	}
}

func sampleProviderManifest() pack.ProviderManifest {
	return pack.ProviderManifest{
		ProviderID:      "deepseek",
		DisplayName:     "DeepSeek OpenAI Compatible",
		BaseURL:         "https://api.deepseek.com",
		Platform:        "openai",
		AccountType:     "api",
		DefaultModels:   []string{"deepseek-chat", "deepseek-reasoner"},
		SmokeTestModel:  "deepseek-chat",
		GroupTemplate:   pack.GroupTemplate{Name: "DeepSeek 默认分组", RateMultiplier: 1},
		ChannelTemplate: pack.ChannelTemplate{Name: "DeepSeek 默认渠道", ModelMapping: map[string]string{"deepseek-chat": "deepseek-chat"}},
		PlanTemplate:    pack.PlanTemplate{Name: "DeepSeek 默认套餐", Price: 19.9, ValidityDays: 30, ValidityUnit: "day"},
	}
}

type fakeHostAdapter struct {
	batchAccounts         []sub2api.AccountRef
	testResults           map[string]sub2api.ProbeResult
	models                map[string][]sub2api.AccountModel
	gatewayResult         sub2api.GatewayAccessResult
	batchCreateErr        error
	assignErr             error
	gatewayErr            error
	hostVersion           string
	assignedSubscriptions []sub2api.AssignSubscriptionRequest
	gatewayProbe          sub2api.GatewayAccessCheckRequest
	deletedResources      []string
	managedSnapshot       sub2api.ManagedResourceSnapshot
}

func (f *fakeHostAdapter) GetHostVersion(context.Context) (string, error) {
	if strings.TrimSpace(f.hostVersion) == "" {
		return "0.1.126", nil
	}
	return f.hostVersion, nil
}
func (f *fakeHostAdapter) ProbeCapabilities(context.Context) (sub2api.HostCapabilities, error) {
	return sub2api.HostCapabilities{}, nil
}
func (f *fakeHostAdapter) CreateGroup(context.Context, sub2api.CreateGroupRequest) (sub2api.GroupRef, error) {
	return sub2api.GroupRef{ID: "group_1", Name: "g"}, nil
}
func (f *fakeHostAdapter) DeleteGroup(_ context.Context, groupID string) error {
	f.deletedResources = append(f.deletedResources, "group:"+groupID)
	return nil
}
func (f *fakeHostAdapter) CreateChannel(context.Context, sub2api.CreateChannelRequest) (sub2api.ChannelRef, error) {
	return sub2api.ChannelRef{ID: "channel_1", Name: "c"}, nil
}
func (f *fakeHostAdapter) DeleteChannel(_ context.Context, channelID string) error {
	f.deletedResources = append(f.deletedResources, "channel:"+channelID)
	return nil
}
func (f *fakeHostAdapter) CreatePlan(context.Context, sub2api.CreatePlanRequest) (sub2api.PlanRef, error) {
	return sub2api.PlanRef{ID: "plan_1", Name: "p"}, nil
}
func (f *fakeHostAdapter) DeletePlan(_ context.Context, planID string) error {
	f.deletedResources = append(f.deletedResources, "plan:"+planID)
	return nil
}
func (f *fakeHostAdapter) CreateAccount(context.Context, sub2api.CreateAccountRequest) (sub2api.AccountRef, error) {
	return sub2api.AccountRef{}, errors.New("unused")
}
func (f *fakeHostAdapter) BatchCreateAccounts(_ context.Context, _ sub2api.BatchCreateAccountsRequest) ([]sub2api.AccountRef, error) {
	if f.batchCreateErr != nil {
		return nil, f.batchCreateErr
	}
	return f.batchAccounts, nil
}
func (f *fakeHostAdapter) DeleteAccount(_ context.Context, accountID string) error {
	f.deletedResources = append(f.deletedResources, "account:"+accountID)
	return nil
}
func (f *fakeHostAdapter) TestAccount(_ context.Context, accountID string) (sub2api.ProbeResult, error) {
	result, ok := f.testResults[accountID]
	if !ok {
		return sub2api.ProbeResult{}, fmt.Errorf("missing test result for %s", accountID)
	}
	return result, nil
}
func (f *fakeHostAdapter) GetAccountModels(_ context.Context, accountID string) ([]sub2api.AccountModel, error) {
	models, ok := f.models[accountID]
	if !ok {
		return nil, fmt.Errorf("missing models for %s", accountID)
	}
	return models, nil
}
func (f *fakeHostAdapter) AssignSubscription(_ context.Context, req sub2api.AssignSubscriptionRequest) (sub2api.SubscriptionRef, error) {
	if f.assignErr != nil {
		return sub2api.SubscriptionRef{}, f.assignErr
	}
	f.assignedSubscriptions = append(f.assignedSubscriptions, req)
	return sub2api.SubscriptionRef{ID: "subscription_1"}, nil
}
func (f *fakeHostAdapter) CheckGatewayAccess(_ context.Context, req sub2api.GatewayAccessCheckRequest) (sub2api.GatewayAccessResult, error) {
	f.gatewayProbe = req
	if f.gatewayErr != nil {
		return sub2api.GatewayAccessResult{}, f.gatewayErr
	}
	return f.gatewayResult, nil
}
func (f *fakeHostAdapter) ListManagedResources(context.Context, sub2api.ListManagedResourcesRequest) (sub2api.ManagedResourceSnapshot, error) {
	return f.managedSnapshot, nil
}