Files
mtusi2026lab5/internal/platform/s3store/bootstrap_test.go
T

144 lines
4.1 KiB
Go

package s3store_test
import (
"context"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/http/httputil"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"messenger/internal/platform/config"
"messenger/internal/platform/s3store"
)
func TestBootstrapWaitsForRetainedBytesAndCleansWriteProbe(t *testing.T) {
var ready atomic.Bool
var reads atomic.Int32
var mu sync.Mutex
objects := map[string]string{".health/storage-v1": "messenger s3 readiness v1\n"}
var freshReads, deleted int
requested := make(chan struct{}, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
key := strings.TrimPrefix(r.URL.Path, "/attachments/")
if r.Method == "PUT" && strings.TrimSuffix(r.URL.Path, "/") == "/attachments" {
w.WriteHeader(200)
return
}
if r.Method == "GET" && key == ".health/storage-v1" {
reads.Add(1)
if !ready.Load() {
select {
case requested <- struct{}{}:
default:
}
w.WriteHeader(500)
io.WriteString(w, `<Error><Code>InternalError</Code><Message>volume not registered</Message></Error>`)
return
}
}
mu.Lock()
defer mu.Unlock()
switch r.Method {
case "GET":
value, ok := objects[key]
if !ok {
w.WriteHeader(404)
io.WriteString(w, `<Error><Code>NoSuchKey</Code></Error>`)
return
}
if key != ".health/storage-v1" {
freshReads++
}
w.Header().Set("ETag", `"probe"`)
w.Header().Set("Last-Modified", "Mon, 16 Nov 2026 08:00:00 GMT")
w.Header().Set("Content-Length", fmt.Sprint(len(value)))
io.WriteString(w, value)
case "PUT":
var body io.Reader = r.Body
if strings.Contains(r.Header.Get("Content-Encoding"), "aws-chunked") {
body = httputil.NewChunkedReader(body)
}
data, err := io.ReadAll(io.LimitReader(body, 1024))
if err != nil {
t.Error(err)
w.WriteHeader(400)
return
}
objects[key] = string(data)
w.Header().Set("ETag", `"probe"`)
case "DELETE":
if key == ".health/storage-v1" {
t.Error("deleted retained readiness marker")
}
delete(objects, key)
deleted++
w.WriteHeader(204)
default:
t.Errorf("unexpected storage probe: %s %s", r.Method, r.URL)
w.WriteHeader(400)
}
}))
defer server.Close()
s, err := s3store.New(config.S3{Endpoint: server.URL, Region: "us-east-1", Bucket: "attachments", AccessKey: "access", SecretKey: "secret"})
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
done := make(chan error, 1)
go func() { done <- s.Bootstrap(ctx) }()
select {
case err := <-done:
t.Fatalf("bootstrap returned before reading retained storage: %v", err)
case <-requested:
case <-ctx.Done():
t.Fatal(ctx.Err())
}
select {
case err := <-done:
t.Fatalf("bootstrap accepted unavailable retained storage: %v", err)
case <-time.After(40 * time.Millisecond):
}
ready.Store(true)
if err := <-done; err != nil {
t.Fatal(err)
}
mu.Lock()
defer mu.Unlock()
if reads.Load() < 2 || freshReads == 0 || deleted == 0 || len(objects) != 1 {
t.Fatalf("incomplete readiness proof: retainedReads=%d freshReads=%d deletes=%d remaining=%d", reads.Load(), freshReads, deleted, len(objects))
}
}
func TestBootstrapDeadlineIncludesStorageReadiness(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == "PUT" && strings.TrimSuffix(r.URL.Path, "/") == "/attachments" {
w.WriteHeader(200)
return
}
w.WriteHeader(503)
io.WriteString(w, `<Error><Code>ServiceUnavailable</Code><Message>volume not registered</Message></Error>`)
}))
defer server.Close()
s, err := s3store.New(config.S3{Endpoint: server.URL, Region: "us-east-1", Bucket: "attachments", AccessKey: "access", SecretKey: "secret"})
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
started := time.Now()
if err := s.Bootstrap(ctx); !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("storage readiness escaped its deadline: %v", err)
}
if time.Since(started) > time.Second {
t.Fatal("readiness did not honor caller deadline")
}
}