root
ed48674ab5
Frontend CI / Frontend (push) Successful in 3m18s
Backend CI / Backend (push) Successful in 16m16s
Desktop Client Build / Publish Client Artifacts to NAS (push) Successful in 26s
Desktop Client Build / Resolve Build Metadata (push) Successful in 26s
Desktop Client Build / Build Desktop Client (push) Successful in 25m45s
439 lines
15 KiB
Go
439 lines
15 KiB
Go
package app
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/geo-platform/tenant-api/internal/shared/response"
|
|
"github.com/geo-platform/tenant-api/internal/tenant/repository"
|
|
)
|
|
|
|
func TestDesktopTaskRecoverySelectQueryMatchesRecoveredLeaseScanOrder(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
query := desktopTaskRecoverySelectQuery(desktopTaskRecoveryModeStartup)
|
|
gotColumns := recoverDesktopTaskSelectColumns(query)
|
|
wantColumns := []string{
|
|
"desktop_id",
|
|
"workspace_id",
|
|
"kind",
|
|
"status",
|
|
"active_attempt_id",
|
|
"attempts",
|
|
"publish_submit_started_at",
|
|
"monitor_task_id",
|
|
}
|
|
|
|
if len(gotColumns) != len(wantColumns) {
|
|
t.Fatalf("recover select columns = %v, want %v", gotColumns, wantColumns)
|
|
}
|
|
for index := range wantColumns {
|
|
if gotColumns[index] != wantColumns[index] {
|
|
t.Fatalf("recover select columns = %v, want %v", gotColumns, wantColumns)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDesktopTaskRecoverySelectQueryLeaseExpiryFiltersExpiredLeases(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
query := desktopTaskRecoverySelectQuery(desktopTaskRecoveryModeLeaseExpiry)
|
|
|
|
for _, fragment := range []string{
|
|
"AND lease_expires_at IS NOT NULL",
|
|
"AND lease_expires_at < NOW()",
|
|
"FOR UPDATE",
|
|
} {
|
|
if !strings.Contains(query, fragment) {
|
|
t.Fatalf("recover lease-expiry query missing %q: %s", fragment, query)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReconcileRetryPublishesTaskAvailableForAllDesktopTaskKinds(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, kind := range []string{"publish", "monitor"} {
|
|
if got := reconcileDesktopTaskEventType(kind, "retry"); got != "task_available" {
|
|
t.Fatalf("reconcileDesktopTaskEventType(%q, retry) = %q, want task_available", kind, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDesktopTaskRecoveryPayloadPublishLeaseExpiryRequeuesInsteadOfUnknown(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
payload, reason, message, err := desktopTaskRecoveryPayload(desktopTaskRecoveryModeLeaseExpiry, "publish")
|
|
if err != nil {
|
|
t.Fatalf("desktopTaskRecoveryPayload returned error: %v", err)
|
|
}
|
|
if reason != "lease_expired" {
|
|
t.Fatalf("reason = %q, want lease_expired", reason)
|
|
}
|
|
if !strings.Contains(message, "re-queued for retry") {
|
|
t.Fatalf("message = %q, want re-queued for retry", message)
|
|
}
|
|
if strings.Contains(message, "unknown") {
|
|
t.Fatalf("message must not move publish recovery to unknown: %q", message)
|
|
}
|
|
if !strings.Contains(string(payload), "desktop_task_lease_expiry") {
|
|
t.Fatalf("payload missing source: %s", payload)
|
|
}
|
|
}
|
|
|
|
func TestDesktopTaskRecoveryPayloadPublishFinalFailsAfterMaxAttempts(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
payload, _, message, err := desktopTaskRecoveryPayload(desktopTaskRecoveryModeLeaseExpiry, "publish_final")
|
|
if err != nil {
|
|
t.Fatalf("desktopTaskRecoveryPayload returned error: %v", err)
|
|
}
|
|
if !strings.Contains(message, "marked failed") {
|
|
t.Fatalf("message = %q, want marked failed", message)
|
|
}
|
|
if !strings.Contains(message, "3 attempts") {
|
|
t.Fatalf("message = %q, want max attempts", message)
|
|
}
|
|
if !strings.Contains(string(payload), "marked failed") {
|
|
t.Fatalf("payload missing final failure message: %s", payload)
|
|
}
|
|
}
|
|
|
|
func TestDesktopTaskRecoveryPayloadMonitorLeaseExpiryRequeues(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
payload, reason, message, err := desktopTaskRecoveryPayload(desktopTaskRecoveryModeLeaseExpiry, "monitor")
|
|
if err != nil {
|
|
t.Fatalf("desktopTaskRecoveryPayload returned error: %v", err)
|
|
}
|
|
if reason != "lease_expired" {
|
|
t.Fatalf("reason = %q, want lease_expired", reason)
|
|
}
|
|
if !strings.Contains(message, "re-queued") {
|
|
t.Fatalf("message = %q, want re-queued", message)
|
|
}
|
|
if strings.Contains(message, "marked failed") {
|
|
t.Fatalf("message must not fail expired monitor tasks: %q", message)
|
|
}
|
|
if !strings.Contains(string(payload), "desktop_task_lease_expiry") {
|
|
t.Fatalf("payload missing source: %s", payload)
|
|
}
|
|
}
|
|
|
|
func TestReconcileNonRetryPublishesTaskReconciled(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
if got := reconcileDesktopTaskEventType("publish", "failed"); got != "task_reconciled" {
|
|
t.Fatalf("reconcileDesktopTaskEventType(publish, failed) = %q, want task_reconciled", got)
|
|
}
|
|
}
|
|
|
|
func TestResolvePublishRecoveryOutcome(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
name string
|
|
submitStarted bool
|
|
attempts int
|
|
wantStatus string
|
|
wantKind string
|
|
}{
|
|
{"pre-submit first attempt requeues", false, 1, "queued", "publish"},
|
|
{"pre-submit just below cap requeues", false, desktopPublishMaxAttempts - 1, "queued", "publish"},
|
|
{"pre-submit at cap fails terminally", false, desktopPublishMaxAttempts, "failed", "publish_final"},
|
|
{"pre-submit above cap fails terminally", false, desktopPublishMaxAttempts + 1, "failed", "publish_final"},
|
|
// Submit may have happened: never auto-requeue or silently fail — route to unknown
|
|
// (manual reconcile) regardless of remaining attempts, to avoid duplicate publishing.
|
|
{"submit started first attempt is uncertain", true, 1, "unknown", "publish_uncertain"},
|
|
{"submit started at cap is still uncertain", true, desktopPublishMaxAttempts, "unknown", "publish_uncertain"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
gotStatus, gotKind := resolvePublishRecoveryOutcome(tc.submitStarted, tc.attempts)
|
|
if gotStatus != tc.wantStatus || gotKind != tc.wantKind {
|
|
t.Fatalf("resolvePublishRecoveryOutcome(%v, %d) = (%q, %q), want (%q, %q)",
|
|
tc.submitStarted, tc.attempts, gotStatus, gotKind, tc.wantStatus, tc.wantKind)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResolveMonitorRecoveryOutcome(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
name string
|
|
mode desktopTaskRecoveryMode
|
|
attempts int
|
|
wantStatus string
|
|
wantKind string
|
|
}{
|
|
{"startup first attempt requeues", desktopTaskRecoveryModeStartup, 1, "queued", "monitor"},
|
|
{"disconnect first attempt requeues", desktopTaskRecoveryModeDisconnect, 1, "queued", "monitor"},
|
|
{"startup repeated recovery fails", desktopTaskRecoveryModeStartup, 2, "failed", "monitor_final"},
|
|
{"disconnect repeated recovery fails", desktopTaskRecoveryModeDisconnect, 2, "failed", "monitor_final"},
|
|
{"lease expiry requeues first attempt", desktopTaskRecoveryModeLeaseExpiry, 1, "queued", "monitor"},
|
|
{"lease expiry requeues repeated attempt", desktopTaskRecoveryModeLeaseExpiry, 2, "queued", "monitor"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
gotStatus, gotKind := resolveMonitorRecoveryOutcome(tc.mode, tc.attempts)
|
|
if gotStatus != tc.wantStatus || gotKind != tc.wantKind {
|
|
t.Fatalf("resolveMonitorRecoveryOutcome(%q, %d) = (%q, %q), want (%q, %q)",
|
|
tc.mode, tc.attempts, gotStatus, gotKind, tc.wantStatus, tc.wantKind)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeDesktopTaskCompletionStatusForKindFailsMonitorUnknown(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
if got := normalizeDesktopTaskCompletionStatusForKind("monitor", "unknown"); got != "failed" {
|
|
t.Fatalf("monitor completion status = %q, want failed", got)
|
|
}
|
|
if got := normalizeDesktopTaskCompletionStatusForKind("publish", "unknown"); got != "unknown" {
|
|
t.Fatalf("publish completion status = %q, want unknown", got)
|
|
}
|
|
}
|
|
|
|
func TestExpiredMonitorDesktopTasksCandidateSQLSelectsOnlyExpiredInProgressMonitorTasks(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
normalized := normalizeSQLForDesktopTaskTest(expiredMonitorDesktopTasksCandidateSQL())
|
|
for _, fragment := range []string{
|
|
"t.kind = 'monitor'",
|
|
"t.status = 'in_progress'",
|
|
"t.monitor_task_id IS NOT NULL",
|
|
"t.lease_expires_at IS NOT NULL",
|
|
"t.lease_expires_at < NOW()",
|
|
"ORDER BY t.lease_expires_at ASC",
|
|
"FOR UPDATE OF t SKIP LOCKED",
|
|
} {
|
|
if !strings.Contains(normalized, fragment) {
|
|
t.Fatalf("expired monitor candidate query missing %q: %s", fragment, normalized)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRequeueExpiredMonitorDesktopTasksSQLReturnsTaskToQueue(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
normalized := normalizeSQLForDesktopTaskTest(requeueExpiredMonitorDesktopTasksSQL())
|
|
for _, fragment := range []string{
|
|
"SET status = 'queued'",
|
|
"active_attempt_id = NULL",
|
|
"lease_token_hash = NULL",
|
|
"lease_expires_at = NULL",
|
|
"interrupt_reason = COALESCE(interrupt_reason, $3)",
|
|
"enqueued_at = NOW()",
|
|
"WHERE desktop_id = ANY($1::uuid[])",
|
|
"AND kind = 'monitor'",
|
|
"AND status = 'in_progress'",
|
|
"RETURNING desktop_id",
|
|
} {
|
|
if !strings.Contains(normalized, fragment) {
|
|
t.Fatalf("expired monitor update query missing %q: %s", fragment, normalized)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestClassifyLeaseErrorDefersQueuedMonitorTask(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
task := &repository.DesktopTask{
|
|
Kind: "monitor",
|
|
Status: "queued",
|
|
}
|
|
if got := classifyDesktopTaskLeaseState(task); !errors.Is(got, errDesktopTaskLeaseDeferred) {
|
|
t.Fatalf("classifyDesktopTaskLeaseState() = %v, want deferred", got)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeDesktopTaskViewStatusMapsMonitorUnknownToFailedButKeepsPublishUnknown(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
if got := normalizeDesktopTaskViewStatus("monitor", "unknown"); got != "failed" {
|
|
t.Fatalf("monitor unknown view status = %q, want failed", got)
|
|
}
|
|
if got := normalizeDesktopTaskViewStatus("publish", "unknown"); got != "unknown" {
|
|
t.Fatalf("publish unknown view status = %q, want unknown", got)
|
|
}
|
|
}
|
|
|
|
func TestIsComplianceInvalidArticleVersionError(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
if !isComplianceInvalidArticleVersionError(response.ErrBadRequest(41005, "invalid_article_version", "article version does not belong to this article")) {
|
|
t.Fatal("invalid article version compliance errors should be treated as stale publish tasks")
|
|
}
|
|
if isComplianceInvalidArticleVersionError(response.ErrServiceUnavailable(41004, "compliance_engine_unavailable", "compliance gate failed closed")) {
|
|
t.Fatal("compliance engine failures should not be treated as stale publish tasks")
|
|
}
|
|
}
|
|
|
|
func TestBuildListPublishTasksByStatusesQueryHidesDeletedPublishRecords(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
query, args := buildListPublishTasksByStatusesQuery(
|
|
publishTaskListOwner{TenantID: 7, WorkspaceID: 11, UserID: 23},
|
|
[]string{"succeeded", "failed"},
|
|
"合肥",
|
|
10,
|
|
20,
|
|
"t.updated_at DESC",
|
|
)
|
|
normalized := normalizeSQLForDesktopTaskTest(query)
|
|
|
|
for _, fragment := range []string{
|
|
"NOT (t.payload ? 'publish_record_id') OR EXISTS",
|
|
"FROM publish_records pr",
|
|
"pr.tenant_id = t.tenant_id",
|
|
"t.payload->>'publish_record_id')::bigint",
|
|
"pr.deleted_at IS NULL",
|
|
"LIMIT $6 OFFSET $7",
|
|
} {
|
|
if !strings.Contains(normalized, fragment) {
|
|
t.Fatalf("list publish tasks query missing %q: %s", fragment, normalized)
|
|
}
|
|
}
|
|
if len(args) != 7 {
|
|
t.Fatalf("args len = %d, want 7", len(args))
|
|
}
|
|
}
|
|
|
|
func TestBuildCountPublishTasksByStatusesQueryHidesDeletedPublishRecords(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
query, args := buildCountPublishTasksByStatusesQuery(
|
|
publishTaskListOwner{TenantID: 7, WorkspaceID: 11, UserID: 23},
|
|
[]string{"succeeded", "failed"},
|
|
"",
|
|
)
|
|
normalized := normalizeSQLForDesktopTaskTest(query)
|
|
|
|
for _, fragment := range []string{
|
|
"NOT (t.payload ? 'publish_record_id') OR EXISTS",
|
|
"FROM publish_records pr",
|
|
"pr.deleted_at IS NULL",
|
|
} {
|
|
if !strings.Contains(normalized, fragment) {
|
|
t.Fatalf("count publish tasks query missing %q: %s", fragment, normalized)
|
|
}
|
|
}
|
|
if len(args) != 5 {
|
|
t.Fatalf("args len = %d, want 5", len(args))
|
|
}
|
|
}
|
|
|
|
func TestLeaseNextQueuedMonitorTaskSQLUsesAccountIdentityAndClientSlots(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
normalized := normalizeSQLForDesktopTaskTest(leaseNextQueuedMonitorTaskSQL())
|
|
for _, fragment := range []string{
|
|
"WITH current_accounts AS",
|
|
"client_id = $3",
|
|
"COALESCE(array_length($7::text[], 1), 0) = 0 OR dt.platform_id = ANY($7::text[])",
|
|
"dt.target_account_id = target_account.desktop_id",
|
|
"target_account.account_fingerprint",
|
|
"target_account.platform_uid",
|
|
"hashtextextended",
|
|
"pg_try_advisory_xact_lock(account_slot_lock_key)",
|
|
"SET target_client_id = $3, target_account_id = candidate.lease_account_id",
|
|
"NOT EXISTS ( SELECT 1 FROM desktop_tasks AS active",
|
|
"active.platform_id = dt.platform_id",
|
|
"active.status = 'in_progress'",
|
|
"active.desktop_id <> dt.desktop_id",
|
|
"COUNT(DISTINCT active_platform.platform_id)",
|
|
"active_platform.target_client_id = $3",
|
|
"< $6::integer",
|
|
"active_client_platform.target_client_id = $3",
|
|
"active_client_platform.platform_id = dt.platform_id",
|
|
"recent.status = 'succeeded'",
|
|
"recent.updated_at >= now() - interval '2 seconds'",
|
|
"recent.status IN ('failed', 'unknown', 'aborted')",
|
|
"recent.updated_at >= now() - interval '30 seconds'",
|
|
"ORDER BY dt.lane_weight DESC, dt.priority DESC, COALESCE(dt.enqueued_at, dt.created_at) ASC",
|
|
} {
|
|
if !strings.Contains(normalized, fragment) {
|
|
t.Fatalf("monitor lease query missing %q: %s", fragment, normalized)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNormalizeDesktopTaskLeasePlatformIDs(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := normalizeDesktopTaskLeasePlatformIDs([]string{" Doubao ", "qwen", "", "DOUBAO"})
|
|
want := []string{"doubao", "qwen"}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("normalizeDesktopTaskLeasePlatformIDs() = %#v, want %#v", got, want)
|
|
}
|
|
if got := normalizeDesktopTaskLeasePlatformIDs([]string{" ", ""}); got != nil {
|
|
t.Fatalf("normalizeDesktopTaskLeasePlatformIDs(blank) = %#v, want nil", got)
|
|
}
|
|
}
|
|
|
|
func TestLeaseQueuedDesktopTaskByIDSQLUsesAccountIdentityAndClientSlots(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
normalized := normalizeSQLForDesktopTaskTest(leaseQueuedDesktopTaskByIDSQL())
|
|
for _, fragment := range []string{
|
|
"WITH current_accounts AS",
|
|
"client_id = $4",
|
|
"dt.kind <> 'monitor' OR ca.desktop_id IS NOT NULL",
|
|
"target_account.account_fingerprint",
|
|
"target_account.platform_uid",
|
|
"SELECT dt.desktop_id, dt.kind, ca.desktop_id AS lease_account_id",
|
|
"locked_candidate AS",
|
|
"pg_try_advisory_xact_lock(account_slot_lock_key)",
|
|
"FROM locked_candidate WHERE t.desktop_id = locked_candidate.desktop_id",
|
|
"target_account_id = CASE WHEN t.kind = 'monitor' THEN locked_candidate.lease_account_id ELSE t.target_account_id END",
|
|
"dt.kind <> 'monitor' OR NOT EXISTS",
|
|
"active.platform_id = dt.platform_id",
|
|
"active.status = 'in_progress'",
|
|
"active.desktop_id <> dt.desktop_id",
|
|
"COUNT(DISTINCT active_platform.platform_id)",
|
|
"active_platform.target_client_id = $4",
|
|
"< $8::integer",
|
|
"active_client_platform.target_client_id = $4",
|
|
"active_client_platform.platform_id = dt.platform_id",
|
|
"recent.status = 'succeeded'",
|
|
"recent.updated_at >= now() - interval '2 seconds'",
|
|
"recent.status IN ('failed', 'unknown', 'aborted')",
|
|
"recent.updated_at >= now() - interval '30 seconds'",
|
|
} {
|
|
if !strings.Contains(normalized, fragment) {
|
|
t.Fatalf("task-specific lease query missing %q: %s", fragment, normalized)
|
|
}
|
|
}
|
|
}
|
|
|
|
func recoverDesktopTaskSelectColumns(query string) []string {
|
|
re := regexp.MustCompile(`(?is)select\s+(.*?)\s+from\s+desktop_tasks`)
|
|
match := re.FindStringSubmatch(query)
|
|
if len(match) != 2 {
|
|
return nil
|
|
}
|
|
|
|
rawColumns := strings.Split(match[1], ",")
|
|
columns := make([]string, 0, len(rawColumns))
|
|
for _, rawColumn := range rawColumns {
|
|
column := strings.TrimSpace(rawColumn)
|
|
column = strings.Fields(column)[0]
|
|
columns = append(columns, column)
|
|
}
|
|
return columns
|
|
}
|
|
|
|
func normalizeSQLForDesktopTaskTest(sql string) string {
|
|
return strings.Join(strings.Fields(sql), " ")
|
|
}
|