310 lines
10 KiB
Go
310 lines
10 KiB
Go
package app
|
|
|
|
import (
|
|
"errors"
|
|
"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",
|
|
}
|
|
|
|
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 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 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 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 TestNormalizeDesktopTaskViewStatusMapsMonitorAndPublishUnknownToFailed(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 != "failed" {
|
|
t.Fatalf("publish unknown view status = %q, want failed", 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 TestLeaseNextQueuedMonitorTaskSQLSerializesPerClientPlatform(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
normalized := normalizeSQLForDesktopTaskTest(leaseNextQueuedMonitorTaskSQL())
|
|
for _, fragment := range []string{
|
|
"NOT EXISTS ( SELECT 1 FROM desktop_tasks AS active",
|
|
"active.target_client_id = $3",
|
|
"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",
|
|
"< $8::integer",
|
|
"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("monitor lease query missing %q: %s", fragment, normalized)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLeaseQueuedDesktopTaskByIDSQLSerializesMonitorPerClientPlatform(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
normalized := normalizeSQLForDesktopTaskTest(leaseQueuedDesktopTaskByIDSQL())
|
|
for _, fragment := range []string{
|
|
"dt.kind <> 'monitor' OR NOT EXISTS",
|
|
"active.target_client_id = $4",
|
|
"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",
|
|
"< $10::integer",
|
|
"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), " ")
|
|
}
|