229 lines
8.8 KiB
Go
229 lines
8.8 KiB
Go
package mysql
|
||
|
||
import (
|
||
"context"
|
||
"crypto/sha256"
|
||
"database/sql"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"os"
|
||
"strings"
|
||
"testing"
|
||
"time"
|
||
|
||
"git.yuntuo.hk/k2safe/orbit/internal/fault"
|
||
"git.yuntuo.hk/k2safe/orbit/internal/retention"
|
||
"git.yuntuo.hk/k2safe/orbit/platform/auth"
|
||
pulse "git.yuntuo.hk/k2safe/orbit/pulse/model"
|
||
"git.yuntuo.hk/k2safe/orbit/pulse/service"
|
||
)
|
||
|
||
func TestIntegrationRetentionPolicyIsSharedAuditedAndIdempotent(t *testing.T) {
|
||
dsn := os.Getenv("ORBIT_TEST_MYSQL_DSN")
|
||
if dsn == "" {
|
||
t.Skip("set ORBIT_TEST_MYSQL_DSN to a disposable database, or run make integration")
|
||
}
|
||
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
|
||
defer cancel()
|
||
db, err := Open(ctx, dsn, 8, 2)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer db.Close()
|
||
if err := Migrate(ctx, db); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
|
||
var boot BootstrapResult
|
||
app := testID(t)
|
||
if err := Bootstrap(ctx, db, BootstrapInput{
|
||
Application: string(app), Namespace: "default", Environment: "test", Queue: "admin",
|
||
ConsoleUsername: "admin-" + string(app), ConsolePassword: "a-strong-password-123",
|
||
}, func(v BootstrapResult) error {
|
||
boot = v
|
||
return nil
|
||
}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
|
||
login, err := NewConsoleAuthStore(db).Login(ctx, "admin-"+string(app), "a-strong-password-123", "retention-test", "127.0.0.1")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
token, err := auth.Parse(login.Token)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defaults := retention.Defaults(boot.NamespaceID)
|
||
store := NewRetentionPolicyStore(db, defaults)
|
||
got, err := store.GetRetentionPolicy(ctx, boot.NamespaceID)
|
||
if err != nil || got.Source != "default" || got.Revision != 0 || got.TaskHistoryDays != 365 {
|
||
t.Fatalf("default policy: %+v %v", got, err)
|
||
}
|
||
|
||
in := retention.UpdateInput{
|
||
ExpectedRevision: 0, Enabled: true, IdempotencyDays: 120,
|
||
TaskHistoryDays: 730, WorkflowHistoryDays: 730, EventLogDays: 365,
|
||
DeliveryHistoryDays: 120, InboxHistoryDays: 120, AuditLogDays: 2555,
|
||
Reason: "production retention policy review",
|
||
}
|
||
updated, err := store.UpdateRetentionPolicy(ctx, token, "retention-change-1", in)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if updated.Source != "database" || updated.Revision != 1 || !updated.Enabled || updated.TaskHistoryDays != 730 {
|
||
t.Fatalf("updated policy: %+v", updated)
|
||
}
|
||
// A second store represents another Orbit node; it must read the same MySQL policy.
|
||
other := NewRetentionPolicyStore(db, retention.Defaults(boot.NamespaceID))
|
||
shared, err := other.GetRetentionPolicy(ctx, boot.NamespaceID)
|
||
if err != nil || shared.Revision != 1 || shared.TaskHistoryDays != 730 || !shared.Enabled {
|
||
t.Fatalf("cross-node policy read: %+v %v", shared, err)
|
||
}
|
||
replayed, err := store.UpdateRetentionPolicy(ctx, token, "retention-change-1", in)
|
||
if err != nil || replayed.Revision != updated.Revision || replayed.TaskHistoryDays != updated.TaskHistoryDays {
|
||
t.Fatalf("idempotent replay: %+v %v", replayed, err)
|
||
}
|
||
conflict := in
|
||
conflict.ExpectedRevision = 0
|
||
conflict.TaskHistoryDays = 900
|
||
if _, err := store.UpdateRetentionPolicy(ctx, token, "retention-change-2", conflict); faultCode(err) != "STATE_CONFLICT" {
|
||
t.Fatalf("stale revision accepted: %v", err)
|
||
}
|
||
var audits int
|
||
if err := db.QueryRowContext(ctx, `SELECT COUNT(*) FROM orbit_audit_events WHERE namespace_id=? AND action='retention.policy.update' AND resource_kind='retention_policy'`, boot.NamespaceID).Scan(&audits); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if audits != 1 {
|
||
t.Fatalf("audit rows=%d want 1 after idempotent replay", audits)
|
||
}
|
||
var actor, reason string
|
||
if err := db.QueryRowContext(ctx, "SELECT actor_id,reason FROM orbit_audit_events WHERE namespace_id=? AND action='retention.policy.update'", boot.NamespaceID).Scan(&actor, &reason); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if actor == "" || reason != in.Reason || actor == "mysql:database" {
|
||
t.Fatalf("unexpected retention audit identity: actor=%q reason=%q", actor, reason)
|
||
}
|
||
t.Logf("retention policy revision %d is shared across stores, audited once, and safe on replay", updated.Revision)
|
||
}
|
||
|
||
func faultCode(err error) string {
|
||
if err == nil {
|
||
return ""
|
||
}
|
||
return fault.Code(err)
|
||
}
|
||
|
||
func TestIntegrationRetentionDiskGrowthAndPreview(t *testing.T) {
|
||
dsn := os.Getenv("ORBIT_TEST_MYSQL_DSN")
|
||
if dsn == "" {
|
||
t.Skip("set ORBIT_TEST_MYSQL_DSN to a disposable database, or run make integration")
|
||
}
|
||
ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
|
||
defer cancel()
|
||
db, err := Open(ctx, dsn, 12, 4)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer db.Close()
|
||
if err := Migrate(ctx, db); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
var boot BootstrapResult
|
||
app := testID(t)
|
||
if err := Bootstrap(ctx, db, BootstrapInput{
|
||
Application: string(app), Namespace: "growth", Environment: "test", Queue: "growth",
|
||
ConsoleUsername: "growth-admin-" + string(app), ConsolePassword: "a-strong-password-123",
|
||
}, func(v BootstrapResult) error { boot = v; return nil }); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
apiToken, err := auth.Parse(boot.Token)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
login, err := NewConsoleAuthStore(db).Login(ctx, "growth-admin-"+string(app), "a-strong-password-123", "retention-growth-test", "127.0.0.1")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
consoleToken, err := auth.Parse(login.Token)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := db.ExecContext(ctx, "ANALYZE TABLE pulse_tasks, orbit_events, orbit_audit_events"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
before := retentionTableBytes(t, ctx, db)
|
||
serviceStore := service.New(NewTaskStore(db))
|
||
// 256 rows × 32 KiB is deliberately larger than one InnoDB allocation page,
|
||
// so the information_schema sample must observe physical table growth.
|
||
payload := json.RawMessage(`{"blob":"` + strings.Repeat("x", 32768) + `"}`)
|
||
ids := make([]string, 0, 256)
|
||
for i := 0; i < 256; i++ {
|
||
out, err := serviceStore.Submit(ctx, apiToken, "growth-"+string(app)+"-"+string(rune('a'+i%26))+"-"+string(testID(t)), service.SubmitInput{
|
||
QueueID: boot.QueueID, Handler: "retention.growth", HandlerVersion: "v1", PayloadVersion: "v1", Payload: payload,
|
||
TaskTimeoutMS: 60000, RecoverySafety: pulse.RecoveryReconcileOnly, Retry: pulse.RetryPolicy{MaxAttempts: 1, AttemptTimeoutMS: 30000},
|
||
})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
ids = append(ids, string(out.Task.ID))
|
||
}
|
||
for _, id := range ids {
|
||
if _, err := db.ExecContext(ctx, `UPDATE pulse_tasks SET state='FAILED',completed_at=UTC_TIMESTAMP(6)-INTERVAL 2 DAY,updated_at=UTC_TIMESTAMP(6) WHERE namespace_id=? AND id=UNHEX(?)`, boot.NamespaceID, id); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
if _, err := db.ExecContext(ctx, "ANALYZE TABLE pulse_tasks, orbit_events, orbit_audit_events"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
after := retentionTableBytes(t, ctx, db)
|
||
if after <= before {
|
||
t.Fatalf("retention table bytes did not grow during bounded growth sample: before=%d after=%d", before, after)
|
||
}
|
||
store := NewRetentionPolicyStore(db, retention.Defaults(boot.NamespaceID))
|
||
_, err = store.UpdateRetentionPolicy(ctx, consoleToken, "growth-retention-policy", retention.UpdateInput{
|
||
ExpectedRevision: 0, Enabled: true, IdempotencyDays: 90, TaskHistoryDays: 1,
|
||
WorkflowHistoryDays: 30, EventLogDays: 30, DeliveryHistoryDays: 30, InboxHistoryDays: 30,
|
||
AuditLogDays: 365, Reason: "bounded disk growth rehearsal",
|
||
})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
preview, err := store.PreviewRetention(ctx, consoleToken)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
var taskSample retention.CandidatePage
|
||
for _, item := range preview.Items {
|
||
if item.Kind == "tasks" {
|
||
taskSample = item
|
||
}
|
||
}
|
||
if taskSample.Count == 0 {
|
||
t.Fatalf("backdated terminal tasks were not visible as retention candidates: %+v", preview.Items)
|
||
}
|
||
snapshot, err := store.ExportRetention(ctx, consoleToken, retention.ArchiveInput{Kind: "tasks", Limit: 1, ExpectedRevision: 1})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if snapshot.FormatVersion != 1 || snapshot.Content == "" {
|
||
t.Fatalf("invalid retention snapshot envelope: %+v", snapshot)
|
||
}
|
||
sum := sha256.Sum256([]byte(snapshot.Content))
|
||
if snapshot.SHA256 != hex.EncodeToString(sum[:]) || !json.Valid([]byte(snapshot.Content)) || !strings.Contains(snapshot.Content, `"source_retained":true`) {
|
||
t.Fatalf("retention snapshot integrity/source marker failed: sha=%s content=%s", snapshot.SHA256, snapshot.Content[:min(len(snapshot.Content), 200)])
|
||
}
|
||
t.Logf("bounded retention growth sample inserted %d terminal tasks; bytes before=%d after=%d delta=%d; preview tasks=%d more=%v", len(ids), before, after, after-before, taskSample.Count, taskSample.More)
|
||
}
|
||
|
||
func retentionTableBytes(t *testing.T, ctx context.Context, db interface {
|
||
QueryRowContext(context.Context, string, ...any) *sql.Row
|
||
}) int64 {
|
||
t.Helper()
|
||
var bytes int64
|
||
if err := db.QueryRowContext(ctx, `SELECT COALESCE(SUM(data_length+index_length),0) FROM information_schema.TABLES WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME IN ('pulse_tasks','orbit_events','orbit_audit_events')`).Scan(&bytes); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
return bytes
|
||
}
|