knowledge-governance/internal/libraryrelease/release_test.go

package libraryrelease

import (
	"context"
	"errors"
	"strings"
	"testing"
	"time"
)

type fakeTarget struct {
	currentErr error
	applyErr   map[Stage]error
	verifyErr  error
	restoreErr error
	applied    []Stage
	restored   int
	currentN   int
}

func (f *fakeTarget) Current(context.Context) (CurrentState, error) {
	f.currentN++
	if f.currentErr != nil {
		return CurrentState{}, f.currentErr
	}
	return CurrentState{Revision: "prod-r1", Counts: map[string]int64{"documents": 4},
		Digests: map[string]string{"knowledges": "abc"}, CapturedAt: time.Now().UTC()}, nil
}

func (f *fakeTarget) Apply(_ context.Context, stage Stage, _ string) error {
	if err, ok := f.applyErr[stage]; ok && err != nil {
		return err
	}
	f.applied = append(f.applied, stage)
	return nil
}

func (f *fakeTarget) Verify(context.Context, Expectation) error { return f.verifyErr }

func (f *fakeTarget) Restore(context.Context, BackupRef) error {
	f.restored++
	return f.restoreErr
}

type fakeBackups struct {
	err  error
	ref  BackupRef
	seen int
}

func (f *fakeBackups) Prepare(context.Context, string, CurrentState) (BackupRef, error) {
	f.seen++
	if f.err != nil {
		return BackupRef{}, f.err
	}
	ref := f.ref
	if ref.ID == "" {
		ref = BackupRef{ID: "backup-1", Bytes: 1024, CreatedAt: time.Now().UTC()}
	}
	return ref, nil
}

type stageLog struct{ entries []string }

func (s *stageLog) Stage(_ context.Context, stage, state, _ string) {
	s.entries = append(s.entries, stage+":"+state)
}

func (s *stageLog) has(entry string) bool {
	for _, item := range s.entries {
		if item == entry {
			return true
		}
	}
	return false
}

func request(now time.Time) Request {
	return Request{Target: "internal-prod", SnapshotID: "snap-1", ParamsDigest: "digest-1", Now: now,
		Grant: Grant{Target: "internal-prod", SnapshotID: "snap-1", ParamsDigest: "digest-1",
			ExpiresAt: now.Add(30 * time.Minute), AuthorizedBy: "admin"}}
}

func TestRunHappyPathWritesAllStagesThenVerifies(t *testing.T) {
	target := &fakeTarget{}
	backups := &fakeBackups{}
	recorder := &stageLog{}
	now := time.Now()
	outcome := Run(context.Background(), request(now), target, backups, recorder)
	if outcome.State != "succeeded" {
		t.Fatalf("state = %s (%s)", outcome.State, outcome.Error)
	}
	if len(target.applied) != 4 || target.restored != 0 {
		t.Fatalf("applied=%v restored=%d", target.applied, target.restored)
	}
	if !recorder.has("verify:succeeded") || recorder.has("rollback:running") {
		t.Fatalf("stage log = %v", recorder.entries)
	}
}

func TestRunRefusesExpiredOrMismatchedGrantBeforeTouchingTarget(t *testing.T) {
	cases := []struct {
		name   string
		mutate func(*Request)
		want   error
	}{
		{"expired", func(r *Request) { r.Now = r.Grant.ExpiresAt.Add(time.Minute) }, ErrGrantExpired},
		{"other target", func(r *Request) { r.Target = "external-prod" }, ErrGrantTarget},
		{"other snapshot", func(r *Request) { r.SnapshotID = "snap-2" }, ErrGrantSnapshot},
		{"params changed", func(r *Request) { r.ParamsDigest = "digest-2" }, ErrGrantParams},
	}
	for _, testCase := range cases {
		t.Run(testCase.name, func(t *testing.T) {
			req := request(time.Now())
			testCase.mutate(&req)
			target := &fakeTarget{}
			backups := &fakeBackups{}
			outcome := Run(context.Background(), req, target, backups, nil)
			if outcome.State != "failed" {
				t.Fatalf("state = %s, want failed", outcome.State)
			}
			if !errors.Is(errors.New(outcome.Error), testCase.want) && !strings.Contains(outcome.Error, testCase.want.Error()) {
				t.Fatalf("error = %q, want %v", outcome.Error, testCase.want)
			}
			if target.currentN != 0 || len(target.applied) != 0 || backups.seen != 0 {
				t.Fatalf("refused request must not touch production: current=%d applied=%d backups=%d",
					target.currentN, len(target.applied), backups.seen)
			}
		})
	}
}

func TestRunStopsWhenProductionStateUnreadable(t *testing.T) {
	target := &fakeTarget{currentErr: errors.New("生产不可达")}
	backups := &fakeBackups{}
	outcome := Run(context.Background(), request(time.Now()), target, backups, nil)
	if outcome.State != "failed" || !strings.Contains(outcome.Error, "读取生产当前状态失败") {
		t.Fatalf("outcome = %+v", outcome)
	}
	if backups.seen != 0 || len(target.applied) != 0 {
		t.Fatal("must not write when production state is unknown")
	}
}

func TestRunStopsBeforeWritingWhenBackupFails(t *testing.T) {
	target := &fakeTarget{}
	backups := &fakeBackups{err: errors.New("磁盘不足")}
	recorder := &stageLog{}
	outcome := Run(context.Background(), request(time.Now()), target, backups, recorder)
	if outcome.State != "failed" {
		t.Fatalf("state = %s", outcome.State)
	}
	if len(target.applied) != 0 {
		t.Fatalf("must not write production without a verified backup: %v", target.applied)
	}
	if !strings.Contains(outcome.Error, ErrBackupUnavailable.Error()) {
		t.Fatalf("error must name the backup failure: %q", outcome.Error)
	}
	if !recorder.has("prebackup:failed") {
		t.Fatalf("stage log = %v", recorder.entries)
	}
}

func TestRunRollsBackWhenStageFails(t *testing.T) {
	target := &fakeTarget{applyErr: map[Stage]error{StageIndex: errors.New("索引写入失败")}}
	recorder := &stageLog{}
	outcome := Run(context.Background(), request(time.Now()), target, &fakeBackups{}, recorder)
	if outcome.State != "rolled_back" {
		t.Fatalf("state = %s (%s)", outcome.State, outcome.Error)
	}
	if outcome.FailedAt != StageIndex {
		t.Fatalf("failed_at = %s", outcome.FailedAt)
	}
	if target.restored != 1 {
		t.Fatalf("restore calls = %d, want 1", target.restored)
	}
	// wiki 在 index 之后，不应执行
	for _, stage := range target.applied {
		if stage == StageWiki {
			t.Fatal("later stages must not run after a failure")
		}
	}
	if !recorder.has("rollback:succeeded") {
		t.Fatalf("stage log = %v", recorder.entries)
	}
}

func TestRunRollsBackWhenVerificationFails(t *testing.T) {
	target := &fakeTarget{verifyErr: errors.New("生产分块数不一致")}
	outcome := Run(context.Background(), request(time.Now()), target, &fakeBackups{}, nil)
	if outcome.State != "rolled_back" || target.restored != 1 {
		t.Fatalf("outcome = %+v restored=%d", outcome, target.restored)
	}
}

func TestRunReportsRollbackFailureDistinctly(t *testing.T) {
	target := &fakeTarget{applyErr: map[Stage]error{StageDatabase: errors.New("写库失败")},
		restoreErr: errors.New("恢复也失败")}
	recorder := &stageLog{}
	outcome := Run(context.Background(), request(time.Now()), target, &fakeBackups{}, recorder)
	if outcome.State != "rollback_failed" {
		t.Fatalf("state = %s, want rollback_failed", outcome.State)
	}
	if !strings.Contains(outcome.Rollback, "恢复失败") {
		t.Fatalf("rollback message = %q", outcome.Rollback)
	}
	if !recorder.has("rollback:failed") {
		t.Fatalf("stage log = %v", recorder.entries)
	}
}