143 lines
3.9 KiB
Go
143 lines
3.9 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/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(server.URL, "us-east-1", "attachments", "access", "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(server.URL, "us-east-1", "attachments", "access", "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")
|
|
}
|
|
}
|