100 lines
2.6 KiB
Go
100 lines
2.6 KiB
Go
//go:build integration
|
|
|
|
package redisactivity
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
|
|
"proxy-pool/internal/platform/credentials"
|
|
)
|
|
|
|
var testNamespaceSequence atomic.Uint64
|
|
|
|
type redisTestFixture struct {
|
|
Adapter *Adapter
|
|
Client *redis.Client
|
|
Credentials *credentials.MemoryStore
|
|
Namespace string
|
|
}
|
|
|
|
func TestRedisFixtureUsesIsolatedNamespace(t *testing.T) {
|
|
fixture := newRedisTestFixture(t)
|
|
key := fixture.Adapter.keys.operation("fixture-probe")
|
|
if err := fixture.Client.Set(t.Context(), key, "ok", time.Minute).Err(); err != nil {
|
|
t.Fatalf("write isolated fixture key: %v", err)
|
|
}
|
|
if value, err := fixture.Client.Get(t.Context(), key).Result(); err != nil || value != "ok" {
|
|
t.Fatalf("read isolated fixture key = (%q, %v)", value, err)
|
|
}
|
|
}
|
|
|
|
func newRedisTestFixture(t *testing.T) redisTestFixture {
|
|
t.Helper()
|
|
redisURL := os.Getenv("PROXY_POOL_TEST_REDIS_URL")
|
|
if redisURL == "" {
|
|
t.Skip("PROXY_POOL_TEST_REDIS_URL is not set")
|
|
}
|
|
redisOptions, err := redis.ParseURL(redisURL)
|
|
if err != nil {
|
|
t.Fatalf("parse PROXY_POOL_TEST_REDIS_URL: %v", err)
|
|
}
|
|
client := redis.NewClient(redisOptions)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
if err := client.Ping(ctx).Err(); err != nil {
|
|
_ = client.Close()
|
|
t.Fatalf("ping test Redis: %v", err)
|
|
}
|
|
credentialStore, err := credentials.NewMemoryStore(10_000)
|
|
if err != nil {
|
|
_ = client.Close()
|
|
t.Fatalf("NewMemoryStore(): %v", err)
|
|
}
|
|
namespace := fmt.Sprintf("it-%d-%d-%d", os.Getpid(), time.Now().UnixNano(), testNamespaceSequence.Add(1))
|
|
adapter, err := New(client, Options{
|
|
Namespace: namespace, Credentials: credentialStore,
|
|
OperationTTL: time.Minute, MaxCandidateScan: 2_048, CleanupLimit: 128,
|
|
})
|
|
if err != nil {
|
|
_ = client.Close()
|
|
t.Fatalf("New(): %v", err)
|
|
}
|
|
t.Cleanup(func() {
|
|
cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cleanupCancel()
|
|
if err := deleteRedisNamespace(cleanupCtx, client, redisKeyPrefix+namespace+":*"); err != nil {
|
|
t.Errorf("clean Redis test namespace: %v", err)
|
|
}
|
|
_ = client.Close()
|
|
})
|
|
return redisTestFixture{
|
|
Adapter: adapter, Client: client, Credentials: credentialStore, Namespace: namespace,
|
|
}
|
|
}
|
|
|
|
func deleteRedisNamespace(ctx context.Context, client *redis.Client, pattern string) error {
|
|
var cursor uint64
|
|
for {
|
|
keys, next, err := client.Scan(ctx, cursor, pattern, 128).Result()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(keys) > 0 {
|
|
if err := client.Unlink(ctx, keys...).Err(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
cursor = next
|
|
if cursor == 0 {
|
|
return nil
|
|
}
|
|
}
|
|
}
|