@johnnyboy11234/esg-idea-contest 0.3.0 → 0.3.2

package/backend/internal/storage/pending_integration_test.go

@@ -0,0 +1,324 @@
+//go:build integration
+
+package storage_test
+
+import (
+	"bytes"
+	"context"
+	"database/sql"
+	"errors"
+	"io"
+	"log/slog"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/db"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/dbtest"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/storage"
+)
+
+// fakeStore records Delete calls; deleteErr makes them fail (MinIO down).
+type fakeStore struct {
+	mu        sync.Mutex
+	deleteErr error
+	deleted   []string
+	ctxErr    []error // ctx.Err() seen by each Delete
+}
+
+func (f *fakeStore) Put(context.Context, string, io.Reader, int64, string) error { return nil }
+func (f *fakeStore) Get(context.Context, string) (io.ReadCloser, int64, error) {
+	return nil, 0, storage.ErrObjectNotFound
+}
+
+func (f *fakeStore) Delete(ctx context.Context, key string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.ctxErr = append(f.ctxErr, ctx.Err())
+	if f.deleteErr != nil {
+		return f.deleteErr
+	}
+	f.deleted = append(f.deleted, key)
+	return nil
+}
+
+type pendingRow struct {
+	Reason   string
+	DueInSec float64 // next_attempt_at - NOW(6), database time
+	Attempts int
+}
+
+func pendingRows(t *testing.T, d *sql.DB, key string) []pendingRow {
+	t.Helper()
+	rows, err := d.Query(`SELECT reason, TIMESTAMPDIFF(MICROSECOND, NOW(6), next_attempt_at) / 1e6, attempts
+	                        FROM pending_file_deletion WHERE object_key = ? ORDER BY id`, key)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = rows.Close() }()
+	var out []pendingRow
+	for rows.Next() {
+		var r pendingRow
+		if err := rows.Scan(&r.Reason, &r.DueInSec, &r.Attempts); err != nil {
+			t.Fatal(err)
+		}
+		out = append(out, r)
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+	return out
+}
+
+func newLogger() (*slog.Logger, *bytes.Buffer) {
+	var buf bytes.Buffer
+	return slog.New(slog.NewJSONHandler(&buf, nil)), &buf
+}
+
+func TestPendingDeletion(t *testing.T) {
+	dsn := dbtest.Start(t)
+	d := dbtest.Open(t, dsn)
+	ctx := context.Background()
+
+	recordInTx := func(t *testing.T, p *storage.PendingDeletion, key string, r storage.Reason) storage.PendingID {
+		t.Helper()
+		var id storage.PendingID
+		out, err := db.InTx(ctx, d, func(ctx context.Context, tx *sql.Tx) error {
+			var err error
+			id, err = p.RecordInTx(ctx, tx, key, r)
+			return err
+		})
+		if out != db.Committed || err != nil {
+			t.Fatalf("InTx = %v, %v", out, err)
+		}
+		return id
+	}
+
+	t.Run("RecordInTx writes REPLACED / DELETED due now, only when the tx commits", func(t *testing.T) {
+		p := storage.NewPendingDeletion(d, &fakeStore{}, nil)
+		for _, r := range []storage.Reason{storage.ReasonReplaced, storage.ReasonDeleted} {
+			key := "slides/in-tx/" + string(r) + ".pdf"
+			if id := recordInTx(t, p, key, r); id <= 0 {
+				t.Errorf("%s: id = %d", r, id)
+			}
+			got := pendingRows(t, d, key)
+			if len(got) != 1 || got[0].Reason != string(r) || got[0].DueInSec > 0 || got[0].Attempts != 0 {
+				t.Errorf("%s: rows = %+v, want one due row", r, got)
+			}
+		}
+
+		key := "slides/in-tx/rolled-back.pdf"
+		out, _ := db.InTx(ctx, d, func(ctx context.Context, tx *sql.Tx) error {
+			if _, err := p.RecordInTx(ctx, tx, key, storage.ReasonReplaced); err != nil {
+				return err
+			}
+			return errors.New("later step fails")
+		})
+		if out != db.RolledBack {
+			t.Fatalf("outcome = %v", out)
+		}
+		if got := pendingRows(t, d, key); len(got) != 0 {
+			t.Errorf("rolled-back tx left %+v", got)
+		}
+	})
+
+	t.Run("RecordUploadAborted: known rollback due now, unknown after the grace period", func(t *testing.T) {
+		p := storage.NewPendingDeletion(d, &fakeStore{}, nil)
+		if err := p.RecordUploadAborted(ctx, "slides/aborted/rb.pdf", db.RolledBack); err != nil {
+			t.Fatal(err)
+		}
+		if got := pendingRows(t, d, "slides/aborted/rb.pdf"); len(got) != 1 ||
+			got[0].Reason != "UPLOAD_ABORTED" || got[0].DueInSec > 0 {
+			t.Errorf("rows = %+v", got)
+		}
+
+		if err := p.RecordUploadAborted(ctx, "slides/aborted/unknown.pdf", db.Unknown); err != nil {
+			t.Fatal(err)
+		}
+		got := pendingRows(t, d, "slides/aborted/unknown.pdf")
+		grace := storage.UploadAbortedGrace.Seconds()
+		if len(got) != 1 || got[0].Reason != "UPLOAD_ABORTED" || got[0].DueInSec > grace || got[0].DueInSec < grace-60 {
+			t.Errorf("rows = %+v, want due in about %v s", got, grace)
+		}
+	})
+
+	t.Run("RecordUploadAborted survives a cancelled request context", func(t *testing.T) {
+		p := storage.NewPendingDeletion(d, &fakeStore{}, nil)
+		cctx, cancel := context.WithCancel(ctx)
+		cancel()
+		if err := p.RecordUploadAborted(cctx, "slides/aborted/cancelled.pdf", db.Unknown); err != nil {
+			t.Fatal(err)
+		}
+		if got := pendingRows(t, d, "slides/aborted/cancelled.pdf"); len(got) != 1 {
+			t.Errorf("rows = %+v", got)
+		}
+	})
+
+	t.Run("a key may be recorded more than once", func(t *testing.T) {
+		p := storage.NewPendingDeletion(d, &fakeStore{}, nil)
+		key := "slides/twice/k.pdf"
+		if err := p.RecordUploadAborted(ctx, key, db.Unknown); err != nil {
+			t.Fatal(err)
+		}
+		recordInTx(t, p, key, storage.ReasonReplaced)
+		if got := pendingRows(t, d, key); len(got) != 2 {
+			t.Errorf("rows = %+v, want 2", got)
+		}
+	})
+
+	t.Run("DeleteAfterCommit deletes the object, then the row, even after a client disconnect", func(t *testing.T) {
+		fs := &fakeStore{}
+		p := storage.NewPendingDeletion(d, fs, nil)
+		key := "slides/post-commit/ok.pdf"
+		id := recordInTx(t, p, key, storage.ReasonDeleted)
+		cctx, cancel := context.WithCancel(ctx)
+		cancel()
+		p.DeleteAfterCommit(cctx, id, key)
+		if len(fs.deleted) != 1 || fs.deleted[0] != key || fs.ctxErr[0] != nil {
+			t.Errorf("deleted = %v, ctxErr = %v", fs.deleted, fs.ctxErr)
+		}
+		if got := pendingRows(t, d, key); len(got) != 0 {
+			t.Errorf("row not removed: %+v", got)
+		}
+	})
+
+	t.Run("DeleteAfterCommit with MinIO down keeps the row and logs", func(t *testing.T) {
+		log, buf := newLogger()
+		fs := &fakeStore{deleteErr: errors.New("connection refused")}
+		p := storage.NewPendingDeletion(d, fs, log)
+		key := "slides/post-commit/down.pdf"
+		id := recordInTx(t, p, key, storage.ReasonReplaced)
+		p.DeleteAfterCommit(ctx, id, key)
+		if got := pendingRows(t, d, key); len(got) != 1 || got[0].Reason != "REPLACED" {
+			t.Errorf("rows = %+v, want the REPLACED row kept", got)
+		}
+		if !strings.Contains(buf.String(), "left for the clean-up job") || !strings.Contains(buf.String(), key) {
+			t.Errorf("log = %s", buf.String())
+		}
+	})
+
+	t.Run("database failures are logged, not panicked", func(t *testing.T) {
+		closed := dbtest.Open(t, dsn)
+		_ = closed.Close()
+		log, buf := newLogger()
+		fs := &fakeStore{}
+		p := storage.NewPendingDeletion(closed, fs, log)
+
+		if err := p.RecordUploadAborted(ctx, "slides/closed/a.pdf", db.Unknown); err == nil {
+			t.Error("RecordUploadAborted on a closed pool: want error")
+		}
+		p.DeleteAfterCommit(ctx, 1, "slides/closed/b.pdf")
+		if len(fs.deleted) != 1 {
+			t.Errorf("object delete must still be attempted: %v", fs.deleted)
+		}
+		for _, want := range []string{"may be orphaned", "row not removed"} {
+			if !strings.Contains(buf.String(), want) {
+				t.Errorf("log lacks %q: %s", want, buf.String())
+			}
+		}
+	})
+}
+
+// Lost-commit cases (Sequence.md §2, §7): InTx through the fault-injecting
+// connector, then the compensation a caller makes for the new key.
+func TestPendingDeletionAroundLostCommit(t *testing.T) {
+	dsn := dbtest.Start(t)
+	d := dbtest.Open(t, dsn)
+	faulty, faults := dbtest.OpenFaulty(t, dsn)
+	ctx := context.Background()
+	p := storage.NewPendingDeletion(d, &fakeStore{}, nil)
+
+	for _, tc := range []struct {
+		name       string
+		fault      dbtest.CommitFault
+		want       db.Outcome
+		oldKeyRows int // REPLACED rows for the old key: present iff the commit applied
+	}{
+		{"commit applied, ack lost", dbtest.LostAckCommitted, db.Unknown, 1},
+		{"connection lost before commit", dbtest.LostAckNotCommitted, db.Unknown, 0},
+		{"deadlock at commit", dbtest.DeadlockAtCommit, db.RolledBack, 0},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			oldKey := "slides/lost/" + tc.name + "/old.pdf"
+			newKey := "slides/lost/" + tc.name + "/new.pdf"
+			faults.FailNextCommit(tc.fault)
+			out, err := db.InTx(ctx, faulty, func(ctx context.Context, tx *sql.Tx) error {
+				_, err := p.RecordInTx(ctx, tx, oldKey, storage.ReasonReplaced)
+				return err
+			})
+			if out != tc.want || err == nil {
+				t.Fatalf("InTx = %v, %v; want %v with an error", out, err, tc.want)
+			}
+			if got := pendingRows(t, d, oldKey); len(got) != tc.oldKeyRows {
+				t.Errorf("old key rows = %+v, want %d", got, tc.oldKeyRows)
+			}
+			// The caller never deletes the new object on Unknown; it records it.
+			if err := p.RecordUploadAborted(ctx, newKey, out); err != nil {
+				t.Fatal(err)
+			}
+			got := pendingRows(t, d, newKey)
+			if len(got) != 1 || (out == db.Unknown) != (got[0].DueInSec > 0) {
+				t.Errorf("new key rows = %+v (outcome %v)", got, out)
+			}
+		})
+	}
+	if faults.Fired() != 3 {
+		t.Errorf("faults fired = %d, want 3", faults.Fired())
+	}
+
+	// The pool stays usable after the injected failures.
+	if out, err := db.InTx(ctx, faulty, func(context.Context, *sql.Tx) error { return nil }); out != db.Committed || err != nil {
+		t.Errorf("after faults: %v, %v", out, err)
+	}
+}
+
+// AbortUpload (Sequence.md §2): known rollback deletes now and records only
+// when that fails; Unknown never deletes and records with the grace period.
+// A cancelled request context does not skip the compensation.
+func TestAbortUpload(t *testing.T) {
+	d := dbtest.New(t)
+	gone, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	for _, tc := range []struct {
+		name      string
+		outcome   db.Outcome
+		deleteErr error
+		deleted   bool
+		rows      int
+		graced    bool
+	}{
+		{"rolled back", db.RolledBack, nil, true, 0, false},
+		{"rolled back, delete fails", db.RolledBack, errors.New("minio down"), false, 1, false},
+		{"unknown", db.Unknown, nil, false, 1, true},
+		{"committed is ignored", db.Committed, nil, false, 0, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			fs := &fakeStore{deleteErr: tc.deleteErr}
+			p := storage.NewPendingDeletion(d, fs, nil)
+			key := "slides/abort/" + strings.ReplaceAll(tc.name, " ", "-") + ".pdf"
+			p.AbortUpload(gone, key, tc.outcome)
+
+			if got := len(fs.deleted) == 1; got != tc.deleted {
+				t.Errorf("deleted = %v, want %v", fs.deleted, tc.deleted)
+			}
+			for _, err := range fs.ctxErr {
+				if err != nil {
+					t.Errorf("Delete saw ctx error %v; the request's cancellation must be ignored", err)
+				}
+			}
+			if tc.outcome == db.Unknown && len(fs.ctxErr) != 0 {
+				t.Error("Unknown must never call Delete")
+			}
+			got := pendingRows(t, d, key)
+			if len(got) != tc.rows {
+				t.Fatalf("rows = %+v, want %d", got, tc.rows)
+			}
+			if tc.rows == 1 {
+				if got[0].Reason != string(storage.ReasonUploadAborted) || (got[0].DueInSec > 1) != tc.graced {
+					t.Errorf("row = %+v, graced %v", got[0], tc.graced)
+				}
+			}
+		})
+	}
+}

package/backend/internal/storage/pending_test.go

@@ -0,0 +1,23 @@
+package storage
+
+import (
+	"context"
+	"testing"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/db"
+)
+
+// Misuse is rejected before any database call (nil pool on purpose).
+func TestPendingDeletionRejectsMisuse(t *testing.T) {
+	p := NewPendingDeletion(nil, nil, nil)
+	ctx := context.Background()
+	if _, err := p.RecordInTx(ctx, nil, "k", ReasonUploadAborted); err == nil {
+		t.Error("RecordInTx(UPLOAD_ABORTED): want error, the key is recorded outside the tx")
+	}
+	if _, err := p.RecordInTx(ctx, nil, "k", Reason("OTHER")); err == nil {
+		t.Error("RecordInTx(OTHER): want error")
+	}
+	if err := p.RecordUploadAborted(ctx, "k", db.Committed); err == nil {
+		t.Error("RecordUploadAborted(Committed): want error, a committed key is referenced")
+	}
+}

package/backend/internal/storage/validator.go

@@ -0,0 +1,100 @@
+// Package storage holds the slide rules of PRD §6.8 that run before any object
+// is written: SlideValidator, and later the MinIO port and ExpectedFilename.
+package storage
+
+import (
+	"archive/zip"
+	"bytes"
+	"io"
+	"strings"
+
+	"golang.org/x/text/unicode/norm"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/web"
+)
+
+// MaxSlideBytes is the exact size limit of one slide file (5 MiB).
+const MaxSlideBytes int64 = 5 * 1024 * 1024
+
+// Kind is the accepted slide type.
+type Kind string
+
+const (
+	PDF  Kind = "pdf"
+	PPTX Kind = "pptx"
+)
+
+// Part is one file part named "slides" of the multipart request.
+type Part struct {
+	Filename string // as sent, UTF-8, path components not stripped
+	Size     int64
+	Data     io.ReaderAt // the spooled part; only the head or central directory is read
+}
+
+// Validate runs PRD §6.8 steps 1–5 in order and stops at the first failure:
+// exactly one part (400), size (413), not empty (422), magic bytes agree with
+// the extension (415), expected filename (422). expectedBase is the expected
+// name without extension. It reads no more than the PDF head or the ZIP
+// central directory.
+func Validate(parts []Part, expectedBase string) (Kind, error) {
+	if len(parts) != 1 {
+		return "", web.NewError(web.CodeMalformedRequest, "Exactly one slides file part is required.")
+	}
+	p := parts[0]
+	if p.Size > MaxSlideBytes {
+		return "", web.NewError(web.CodeFileTooLarge, "Slides exceed 5 MiB.")
+	}
+	if p.Size == 0 {
+		return "", web.NewError(web.CodeEmptyFile, "Slides file is empty.")
+	}
+	kind, ok := kindFromExtension(p.Filename)
+	if !ok || !magicMatches(kind, p) {
+		return "", web.NewError(web.CodeUnsupportedFileType, "Slides must be a PDF or PPTX file whose content matches its extension.")
+	}
+	want := expectedBase + "." + string(kind)
+	// The extension is ASCII, so the split point survives NFC; only the base is
+	// compared exactly, the extension case-insensitively (kindFromExtension).
+	got := norm.NFC.String(p.Filename)
+	if got[:len(got)-len(kind)-1] != expectedBase {
+		e := web.NewError(web.CodeFilenameMismatch, "Uploaded filename does not match the expected filename.")
+		e.Fields = []web.FieldError{{Field: "slides", Code: web.CodeFilenameMismatch, Expected: want}}
+		return "", e
+	}
+	return kind, nil
+}
+
+func kindFromExtension(name string) (Kind, bool) {
+	l := strings.ToLower(name)
+	switch {
+	case strings.HasSuffix(l, ".pdf"):
+		return PDF, true
+	case strings.HasSuffix(l, ".pptx"):
+		return PPTX, true
+	}
+	return "", false
+}
+
+func magicMatches(kind Kind, p Part) bool {
+	switch kind {
+	case PDF:
+		head := make([]byte, 5)
+		n, _ := p.Data.ReadAt(head, 0)
+		return n == 5 && bytes.Equal(head, []byte("%PDF-"))
+	case PPTX:
+		zr, err := zip.NewReader(p.Data, p.Size)
+		if err != nil {
+			return false
+		}
+		var ct, pres bool
+		for _, f := range zr.File {
+			switch f.Name {
+			case "[Content_Types].xml":
+				ct = true
+			case "ppt/presentation.xml":
+				pres = true
+			}
+		}
+		return ct && pres
+	}
+	return false
+}

package/backend/internal/storage/validator_test.go

@@ -0,0 +1,95 @@
+package storage
+
+import (
+	"archive/zip"
+	"bytes"
+	"errors"
+	"strings"
+	"testing"
+
+	"golang.org/x/text/unicode/norm"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/web"
+)
+
+func zipOf(t *testing.T, names ...string) []byte {
+	t.Helper()
+	var b bytes.Buffer
+	w := zip.NewWriter(&b)
+	for _, n := range names {
+		f, err := w.Create(n)
+		if err != nil {
+			t.Fatal(err)
+		}
+		f.Write([]byte("x"))
+	}
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+	return b.Bytes()
+}
+
+func part(name string, data []byte) Part {
+	return Part{Filename: name, Size: int64(len(data)), Data: bytes.NewReader(data)}
+}
+
+func TestValidate(t *testing.T) {
+	const base = "I_BSID_王小明_089290_成立供應商永續學院"
+	pdf := []byte("%PDF-1.7 body")
+	pptx := zipOf(t, "[Content_Types].xml", "ppt/presentation.xml")
+	big := append([]byte("%PDF-"), make([]byte, MaxSlideBytes-5)...)
+	tooBig := append(big, 0)
+
+	tests := []struct {
+		name    string
+		parts   []Part
+		want    Kind
+		code    web.ErrorCode
+		wantExp string
+	}{
+		{"pdf ok", []Part{part(base+".pdf", pdf)}, PDF, "", ""},
+		{"pptx ok", []Part{part(base+".pptx", pptx)}, PPTX, "", ""},
+		{"extension upper case ok", []Part{part(base+".PDF", pdf)}, PDF, "", ""},
+		{"NFD filename ok", []Part{part(norm.NFD.String(base)+".pdf", pdf)}, PDF, "", ""},
+		{"exactly 5 MiB ok", []Part{part(base+".pdf", big)}, PDF, "", ""},
+		{"no part", nil, "", web.CodeMalformedRequest, ""},
+		{"two parts", []Part{part(base+".pdf", pdf), part(base+".pdf", pdf)}, "", web.CodeMalformedRequest, ""},
+		{"5 MiB + 1", []Part{part(base+".pdf", tooBig)}, "", web.CodeFileTooLarge, ""},
+		{"size beats type", []Part{part("x.txt", tooBig)}, "", web.CodeFileTooLarge, ""},
+		{"empty", []Part{part(base+".pdf", nil)}, "", web.CodeEmptyFile, ""},
+		{"empty beats type", []Part{part("x.txt", nil)}, "", web.CodeEmptyFile, ""},
+		{"unknown extension", []Part{part(base+".txt", pdf)}, "", web.CodeUnsupportedFileType, ""},
+		{"no extension", []Part{part(base, pdf)}, "", web.CodeUnsupportedFileType, ""},
+		{"pdf extension, pptx bytes", []Part{part(base+".pdf", pptx)}, "", web.CodeUnsupportedFileType, ""},
+		{"pptx extension, pdf bytes", []Part{part(base+".pptx", pdf)}, "", web.CodeUnsupportedFileType, ""},
+		{"pdf magic not at offset 0", []Part{part(base+".pdf", append([]byte(" "), pdf...))}, "", web.CodeUnsupportedFileType, ""},
+		{"short pdf", []Part{part(base+".pdf", []byte("%PDF"))}, "", web.CodeUnsupportedFileType, ""},
+		{"zip without presentation.xml", []Part{part(base+".pptx", zipOf(t, "[Content_Types].xml"))}, "", web.CodeUnsupportedFileType, ""},
+		{"zip without content types", []Part{part(base+".pptx", zipOf(t, "ppt/presentation.xml"))}, "", web.CodeUnsupportedFileType, ""},
+		{"docx is not pptx", []Part{part(base+".pptx", zipOf(t, "[Content_Types].xml", "word/document.xml"))}, "", web.CodeUnsupportedFileType, ""},
+		{"type beats filename", []Part{part("wrong.pdf", pptx)}, "", web.CodeUnsupportedFileType, ""},
+		{"wrong base", []Part{part("I_BSID_王小明_089290_其他.pdf", pdf)}, "", web.CodeFilenameMismatch, base + ".pdf"},
+		{"expected carries upload extension", []Part{part("wrong.PPTX", pptx)}, "", web.CodeFilenameMismatch, base + ".pptx"},
+		{"base is case sensitive", []Part{part(strings.ToLower(base)+".pdf", pdf)}, "", web.CodeFilenameMismatch, base + ".pdf"},
+		{"path is not stripped", []Part{part("dir/"+base+".pdf", pdf)}, "", web.CodeFilenameMismatch, base + ".pdf"},
+		{"surrounding space", []Part{part(" "+base+".pdf", pdf)}, "", web.CodeFilenameMismatch, base + ".pdf"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got, err := Validate(tc.parts, base)
+			if tc.code == "" {
+				if err != nil || got != tc.want {
+					t.Fatalf("got (%q, %v), want (%q, nil)", got, err, tc.want)
+				}
+				return
+			}
+			var we *web.Error
+			if !errors.As(err, &we) || we.Code != tc.code {
+				t.Fatalf("got %v, want code %s", err, tc.code)
+			}
+			if tc.wantExp != "" && (len(we.Fields) != 1 || we.Fields[0].Expected != tc.wantExp || we.Fields[0].Field != "slides") {
+				t.Fatalf("fields = %+v, want expected %q", we.Fields, tc.wantExp)
+			}
+		})
+	}
+}

package/backend/test/arch/arch_test.go

@@ -36,6 +36,9 @@ const (
 // may import. A module directory missing from this table fails the test, so adding a module forces
 // a conscious decision about its edges. Facts it encodes:
 //   - D29: storage has no dependency on idea; slides sits on idea + storage.
+//   - idea -> storage is allowed only for Idea delete (Sequence.md §5): idea inserts
+//     pending_file_deletion in its tx and deletes the object after commit. idea should depend on
+//     a small interface it declares itself, not on storage's concrete types (bd 1ve).
 //   - D30: account never imports auth (SessionRevoker is injected from main.go).
 //   - D53: audit is reached by business modules; audit itself imports no module.
 //   - admin holds HTTP entry points only and may call any service.
@@ -45,7 +48,7 @@ var allowedEdges = map[string][]string{
 	"account":  {"audit"},
 	"auth":     {"account", "audit"},
 	"storage":  {"audit"},
-	"idea":     {"audit", "deadline"},
+	"idea":     {"audit", "deadline", "storage"},
 	"team":     {"audit", "deadline", "idea"},
 	"slides":   {"audit", "deadline", "idea", "storage"},
 	"admin":    {"account", "audit", "auth", "deadline", "idea", "slides", "storage", "team"},
@@ -284,6 +287,7 @@ func TestChecksDetectViolations(t *testing.T) {
 
 	allowed := []imp{
 		{File: "a.go", Pkg: "slides", Target: "storage"},
+		{File: "a.go", Pkg: "idea", Target: "storage"},
 		{File: "a.go", Pkg: "idea", Target: "shared/web"},
 		{File: "a.go", Pkg: "idea", Target: "api"},
 		{File: "a.go", Pkg: "server", Target: "idea"},

package/backend/test/contract/expected_filename_test.go

@@ -0,0 +1,60 @@
+package contract
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/web"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/storage"
+)
+
+func TestExpectedFilename(t *testing.T) {
+	raw, err := os.ReadFile("../../../testdata/expected-filename.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var f struct {
+		Cases []struct {
+			ID          string `json:"id"`
+			Category    string `json:"category"`
+			Org         string `json:"org"`
+			LeaderName  string `json:"leaderName"`
+			LeaderEmpNo string `json:"leaderEmpNo"`
+			IdeaName    string `json:"ideaName"`
+			WantBase    string `json:"wantBase"`
+			WantBytes   int    `json:"wantBytes"`
+			WantTooLong bool   `json:"wantTooLong"`
+		}
+	}
+	if err := json.Unmarshal(raw, &f); err != nil {
+		t.Fatal(err)
+	}
+	if len(f.Cases) == 0 {
+		t.Fatal("no cases")
+	}
+	for _, c := range f.Cases {
+		t.Run(c.ID, func(t *testing.T) {
+			got, err := storage.ExpectedFilenameBase(c.Category, c.Org, c.LeaderName, c.LeaderEmpNo, c.IdeaName)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got != c.WantBase {
+				t.Errorf("base = %q, want %q", got, c.WantBase)
+			}
+			if n := len(got + ".pptx"); n != c.WantBytes {
+				t.Errorf("bytes = %d, want %d", n, c.WantBytes)
+			}
+			err = storage.CheckFilenameLength(got)
+			if c.WantTooLong {
+				var pe *web.Error
+				if !errors.As(err, &pe) || pe.Code != web.CodeFilenameTooLong {
+					t.Errorf("err = %v, want FILENAME_TOO_LONG", err)
+				}
+			} else if err != nil {
+				t.Errorf("unexpected error %v", err)
+			}
+		})
+	}
+}

package/backend/test/contract/password_test.go

@@ -0,0 +1,46 @@
+package contract
+
+import (
+	"encoding/json"
+	"os"
+	"slices"
+	"testing"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/account"
+)
+
+func TestPasswordPolicy(t *testing.T) {
+	raw, err := os.ReadFile("../../../testdata/password.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var f struct {
+		Cases []struct {
+			ID        string   `json:"id"`
+			Password  string   `json:"password"`
+			EmpNo     string   `json:"empNo"`
+			WantRules []string `json:"wantRules"`
+		}
+	}
+	if err := json.Unmarshal(raw, &f); err != nil {
+		t.Fatal(err)
+	}
+	if len(f.Cases) == 0 {
+		t.Fatal("no cases")
+	}
+	policy := account.DefaultPolicy()
+	for _, c := range f.Cases {
+		t.Run(c.ID, func(t *testing.T) {
+			got := []string{}
+			for _, fe := range policy.Check(c.Password, c.EmpNo) {
+				if fe.Field != "password" || fe.Code != "PASSWORD_POLICY" {
+					t.Errorf("entry %+v: want field password, code PASSWORD_POLICY", fe)
+				}
+				got = append(got, fe.Rule)
+			}
+			if !slices.Equal(got, c.WantRules) {
+				t.Errorf("rules = %v, want %v", got, c.WantRules)
+			}
+		})
+	}
+}