Files
knowledge-governance/internal/objectgateway/create_test.go
T
姚章浩 a55319d972
build / build (push) Failing after 2m29s
fix(objectgateway): 取消整桶独占前置并按维护停写更新
现象:共享桶部署下网关启动即报 gateway_auditor_key_required,残留过期
审计文件则每次 Execute 报 gateway_exclusive_writer_evidence_unverified;
用户已改为“停目标写入容器→更新→启动”的维护式更新。

根因:Gateway.Ready 强制 Isolation.Verify,main 强制 Ed25519 公钥,等于
把整桶独占证明当作发布前置;这与共享桶、沿用原 AK 的实际部署矛盾。

取舍:删除审计校验与相关 env 依赖,保留 journal、治理 PG 只读 authority、
plan/owner/attempt/epoch 绑定、intent-before-send、单次写与精确版本回滚。
create 仅在精确版本读回且仍为 current 时提交;发现外部 latest 只返回冲突,
不在 confirm 阶段删除(journal create intent 已提交,删除会变成无 delete
intent/receipt 的未记账副作用并让 intent 永久 held)。同 key 不自动合并。

证据:真实二进制无审计/残留审计两环境通过;kg-pgtest-writeset 一次性库 +
随机 MinIO 桶跑 14 个网关用例(含共享桶共存写者、同 key 既有对象拒绝、
精确回滚)全过;umask 022 下 make verify 本地必需项全 success。
2026-11-04 09:45:47 +08:00

154 lines
5.5 KiB
Go

package objectgateway
import (
"context"
"errors"
"testing"
)
type fakeBackend struct {
byID map[string]Version
latest Version
latestExists bool
latestErr error
putVersion Version
putErr error
putCalls int
deletes []string
deleteErr error
}
func (f *fakeBackend) Ready(context.Context) error { return nil }
func (f *fakeBackend) Observe(_ context.Context, _ string, id string) (Version, bool, error) {
if id == "" {
if f.latestErr != nil {
return Version{}, false, f.latestErr
}
return f.latest, f.latestExists, nil
}
v, ok := f.byID[id]
return v, ok, nil
}
func (f *fakeBackend) List(context.Context, string) ([]Version, error) { return nil, nil }
func (f *fakeBackend) Put(context.Context, string, []byte, string) (Version, error) {
f.putCalls++
if f.putErr != nil {
return Version{}, f.putErr
}
return f.putVersion, nil
}
func (f *fakeBackend) Delete(_ context.Context, _ string, v Version) error {
if f.deleteErr != nil {
return f.deleteErr
}
f.deletes = append(f.deletes, v.ID)
delete(f.byID, v.ID)
return nil
}
func createFixture(t *testing.T) (Request, Version) {
t.Helper()
body := []byte("shared bucket object")
grant := Grant{Epoch: 1, Owner: Digest([]byte("owner")), Plan: Digest([]byte("plan"))}
r := Request{Grant: grant, Operation: Digest([]byte("operation")), Key: "kb/bound/object-1", Action: "create", SHA256: Digest(body), Bytes: int64(len(body))}
v := Version{ID: "version-own", Owner: r.token(), SHA256: r.SHA256, Bytes: r.Bytes, ETag: `"etag-own"`}
return r, v
}
func TestCreateConfirmationDetectsNewerForeignVersionWithoutSideEffects(t *testing.T) {
r, own := createFixture(t)
foreign := Version{ID: "version-foreign", Owner: Digest([]byte("foreign-owner")), SHA256: Digest([]byte("foreign")), Bytes: 7, ETag: `"etag-foreign"`}
f := &fakeBackend{byID: map[string]Version{own.ID: own, foreign.ID: foreign}, latest: foreign, latestExists: true, putVersion: own}
if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrConflict) {
t.Fatalf("concurrent newer version accepted as committed: %v", err)
}
// Confirmation runs after the journal intent exists. Deleting here would be
// an unrecorded mutation with no delete intent/receipt and would strand the
// create intent in held forever, so confirmation must be read-only.
if len(f.deletes) != 0 {
t.Fatalf("confirmation deleted without a delete intent/receipt: %v", f.deletes)
}
if _, ok := f.byID[own.ID]; !ok {
t.Fatal("own version removed without a recorded delete")
}
if _, ok := f.byID[foreign.ID]; !ok {
t.Fatal("foreign version was deleted")
}
}
func TestCreateConfirmationCommitsOnlyWhenOwnVersionIsCurrent(t *testing.T) {
r, own := createFixture(t)
f := &fakeBackend{byID: map[string]Version{own.ID: own}, latest: own, latestExists: true, putVersion: own}
got, err := confirmCreate(context.Background(), f, r, own)
if err != nil || got != own {
t.Fatalf("own current version not committed: %v %v", got, err)
}
if len(f.deletes) != 0 {
t.Fatalf("unexpected rollback %v", f.deletes)
}
}
func TestCreateConfirmationHoldsWithoutDeletingWhenCurrentVersionUnreadable(t *testing.T) {
r, own := createFixture(t)
f := &fakeBackend{byID: map[string]Version{own.ID: own}, putVersion: own, latestErr: errors.New("read failed")}
if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrHeld) {
t.Fatalf("unreadable current version treated as terminal: %v", err)
}
if len(f.deletes) != 0 {
t.Fatalf("deleted on an unknown observation: %v", f.deletes)
}
}
func TestCreateConfirmationHoldsOnExactReadbackMismatch(t *testing.T) {
r, own := createFixture(t)
other := own
other.ETag = `"different"`
f := &fakeBackend{byID: map[string]Version{own.ID: other}, latest: other, latestExists: true, putVersion: own}
if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrHeld) {
t.Fatalf("mismatched readback treated as committed: %v", err)
}
if len(f.deletes) != 0 {
t.Fatalf("deleted on mismatch: %v", f.deletes)
}
}
func TestCreateSendIsSingleAttemptAndNeverDeletesUnknownPut(t *testing.T) {
r, _ := createFixture(t)
f := &fakeBackend{putErr: errors.New("transport lost")}
if _, err := sendCreate(context.Background(), f, r, []byte("shared bucket object")); !errors.Is(err, ErrHeld) {
t.Fatalf("unknown PUT treated as terminal: %v", err)
}
if f.putCalls != 1 {
t.Fatalf("PUT retried: calls=%d", f.putCalls)
}
if len(f.deletes) != 0 {
t.Fatalf("deleted without a confirmed version: %v", f.deletes)
}
}
func TestPlanAuthorizesOnlyFrozenObjectList(t *testing.T) {
body := []byte("planned")
owner, digest := Digest([]byte("owner")), Digest([]byte("plan-digest"))
p := Plan{Digest: digest, Owner: owner, Objects: []ObjectBinding{{Operation: Digest([]byte("op-1")), Key: "kb/allowed/1", SHA256: Digest(body), Bytes: int64(len(body))}}}
allowed := Request{Grant: Grant{1, owner, digest}, Operation: Digest([]byte("op-1")), Key: "kb/allowed/1", Action: "create", SHA256: Digest(body), Bytes: int64(len(body))}
if !p.allows(allowed) {
t.Fatal("frozen object rejected")
}
for name, mutate := range map[string]func(*Request){
"other_kb_key": func(r *Request) { r.Key = "kb/other-kb/1" },
"other_object": func(r *Request) { r.Key = "kb/allowed/2" },
"other_operation": func(r *Request) { r.Operation = Digest([]byte("op-2")) },
} {
got := allowed
mutate(&got)
if p.allows(got) {
t.Fatalf("%s authorized outside the frozen write set", name)
}
}
dup := p
dup.Objects = append(dup.Objects, p.Objects[0])
if dup.valid() {
t.Fatal("duplicate key accepted in plan")
}
}