forked from mtusi2026/mtusi2026lab2
248 lines
7.0 KiB
Go
248 lines
7.0 KiB
Go
package valkey
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab2/internal/admission"
|
|
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab2/internal/model/dto"
|
|
)
|
|
|
|
// testClient connects only to explicitly configured disposable Valkey shards.
|
|
func testClient(t *testing.T) *Client {
|
|
t.Helper()
|
|
address := os.Getenv("TEST_VALKEY_ADDRESS")
|
|
if address == "" {
|
|
t.Skip("TEST_VALKEY_ADDRESS is required for Valkey integration tests")
|
|
}
|
|
client, err := New(Options{Nodes: map[string]string{"test": address}, Coordinator: "test", PoolSize: 16, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() {
|
|
if err := client.Close(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
if err := client.Ping(t.Context()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return client
|
|
}
|
|
|
|
// testLimits builds independent small budgets for admission scenarios.
|
|
func testLimits() Limits {
|
|
return Limits{
|
|
Global: Budget{Rate: 10000, Slots: 100},
|
|
User: Budget{Rate: 1000, Slots: 3},
|
|
Groups: map[string]Budget{
|
|
"auth": {Rate: 100, Slots: 4},
|
|
"read": {Rate: 1000, Slots: 50},
|
|
"write": {Rate: 1000, Slots: 50},
|
|
},
|
|
UserGroups: map[string]Budget{
|
|
"auth": {Rate: 10, Slots: 1},
|
|
"read": {Rate: 100, Slots: 2},
|
|
"write": {Rate: 100, Slots: 2},
|
|
},
|
|
}
|
|
}
|
|
|
|
// TestPerUserSlotsAreAtomic verifies concurrent reservations cannot exceed the group budget.
|
|
func TestPerUserSlotsAreAtomic(t *testing.T) {
|
|
client := testClient(t)
|
|
limiter, err := NewLimiter(client, testLimits())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
user := uuid.NewString()
|
|
var accepted atomic.Int32
|
|
releases := make(chan func(), 30)
|
|
failures := make(chan error, 30)
|
|
var wg sync.WaitGroup
|
|
for range 30 {
|
|
wg.Go(func() {
|
|
release, err := limiter.Enter(t.Context(), "read", user)
|
|
if err == nil {
|
|
accepted.Add(1)
|
|
releases <- release
|
|
} else if !errors.Is(err, admission.ErrSlots) {
|
|
failures <- err
|
|
}
|
|
})
|
|
}
|
|
wg.Wait()
|
|
close(releases)
|
|
close(failures)
|
|
for release := range releases {
|
|
release()
|
|
}
|
|
for err := range failures {
|
|
t.Error(err)
|
|
}
|
|
if accepted.Load() != 2 {
|
|
t.Fatalf("accepted %d, want exactly two", accepted.Load())
|
|
}
|
|
}
|
|
|
|
// TestUserGroupsHaveSeparateSlots verifies read saturation does not consume write-group capacity.
|
|
func TestUserGroupsHaveSeparateSlots(t *testing.T) {
|
|
client := testClient(t)
|
|
limiter, err := NewLimiter(client, testLimits())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
user := uuid.NewString()
|
|
for range 2 {
|
|
release, err := limiter.Enter(t.Context(), "read", user)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(release)
|
|
}
|
|
release, err := limiter.Enter(t.Context(), "write", user)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
release()
|
|
}
|
|
|
|
// TestUserRateSurvivesSlotRelease checks that release returns concurrency but not rate tokens.
|
|
func TestUserRateSurvivesSlotRelease(t *testing.T) {
|
|
client := testClient(t)
|
|
limits := testLimits()
|
|
limits.User.Rate = 1
|
|
limiter, err := NewLimiter(client, limits)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
user := uuid.NewString()
|
|
release, err := limiter.Enter(t.Context(), "read", user)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
release()
|
|
if _, err := limiter.Enter(t.Context(), "read", user); !errors.Is(err, admission.ErrRate) {
|
|
t.Fatalf("rate budget reset after release: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestAdmissionRejectsUnavailableBackend verifies fail-closed behavior without network fallback.
|
|
func TestAdmissionRejectsUnavailableBackend(t *testing.T) {
|
|
client := testClient(t)
|
|
limiter, err := NewLimiter(client, testLimits())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
cancel()
|
|
if _, err := limiter.Enter(ctx, "read", ""); err == nil {
|
|
t.Fatal("canceled backend operation admitted request")
|
|
}
|
|
}
|
|
|
|
// TestGlobalAdmissionReleasesSlots verifies the coordinator path and release semantics.
|
|
func TestGlobalAdmissionReleasesSlots(t *testing.T) {
|
|
client := testClient(t)
|
|
limiter, err := NewLimiter(client, testLimits())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
release, err := limiter.Enter(t.Context(), "read", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
release()
|
|
}
|
|
|
|
// TestProfileRoundTrip checks storage and ownership of immutable cached profiles.
|
|
func TestProfileRoundTrip(t *testing.T) {
|
|
client := testClient(t)
|
|
user := dto.UserDTO{ID: uuid.New(), Username: "synthetic", DisplayName: "Test", CreatedAt: time.Now().UTC()}
|
|
client.PutProfile(t.Context(), user)
|
|
got, ok := client.GetProfile(t.Context(), user.ID)
|
|
if !ok || got.ID != user.ID || got.Username != user.Username {
|
|
t.Fatal("profile cache did not preserve account")
|
|
}
|
|
}
|
|
|
|
// TestProfileMissHandlesCorruption verifies corrupt cache entries cannot impersonate another account.
|
|
func TestProfileMissHandlesCorruption(t *testing.T) {
|
|
client := testClient(t)
|
|
id := uuid.New()
|
|
key := "profile:" + id.String()
|
|
if err := client.nodes[client.ring.Owner(key)].Set(t.Context(), key, `{"ID":"00000000-0000-0000-0000-000000000000"}`, time.Minute).Err(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, ok := client.GetProfile(t.Context(), id); ok {
|
|
t.Fatal("corrupt profile accepted")
|
|
}
|
|
}
|
|
|
|
// TestProfileBackendFailureIsMiss checks optional-cache fallback semantics.
|
|
func TestProfileBackendFailureIsMiss(t *testing.T) {
|
|
client := testClient(t)
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
cancel()
|
|
if _, ok := client.GetProfile(ctx, uuid.New()); ok {
|
|
t.Fatal("failed cache read treated as hit")
|
|
}
|
|
client.PutProfile(ctx, dto.UserDTO{ID: uuid.New()})
|
|
if err := client.Ping(ctx); err == nil {
|
|
t.Fatal("canceled readiness succeeded")
|
|
}
|
|
}
|
|
|
|
// TestClientRejectsInvalidConfiguration covers configuration boundaries without opening sockets.
|
|
func TestClientRejectsInvalidConfiguration(t *testing.T) {
|
|
cases := []Options{
|
|
{},
|
|
{Nodes: map[string]string{"a": ""}, Coordinator: "a", PoolSize: 1, Timeout: time.Second},
|
|
{Nodes: map[string]string{"": "localhost:6379"}, Coordinator: "", PoolSize: 1, Timeout: time.Second},
|
|
{Nodes: map[string]string{"a": "localhost:6379"}, Coordinator: "b", PoolSize: 1, Timeout: time.Second},
|
|
}
|
|
for index, options := range cases {
|
|
t.Run(string(rune('a'+index)), func(t *testing.T) {
|
|
if _, err := New(options); err == nil {
|
|
t.Fatal("invalid client options accepted")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestLimiterRejectsInvalidConfiguration verifies policy completeness.
|
|
func TestLimiterRejectsInvalidConfiguration(t *testing.T) {
|
|
if _, err := NewLimiter(nil, testLimits()); err == nil {
|
|
t.Fatal("nil client accepted")
|
|
}
|
|
client := testClient(t)
|
|
limits := testLimits()
|
|
delete(limits.Groups, "auth")
|
|
if _, err := NewLimiter(client, limits); err == nil {
|
|
t.Fatal("missing group accepted")
|
|
}
|
|
limiter, err := NewLimiter(client, testLimits())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := limiter.Enter(t.Context(), "unknown", ""); err == nil {
|
|
t.Fatal("unknown group accepted")
|
|
}
|
|
}
|
|
|
|
// TestTopologyMismatchFailsClosed prevents replicas from silently splitting user budgets.
|
|
func TestTopologyMismatchFailsClosed(t *testing.T) {
|
|
client := testClient(t)
|
|
client.topology = "different-ring"
|
|
if err := client.Ping(t.Context()); err == nil {
|
|
t.Fatal("incompatible topology accepted")
|
|
}
|
|
}
|