213 lines
5.4 KiB
Go
213 lines
5.4 KiB
Go
package cursor
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// TestCodec_EncodeDecode preserves the complete position through an authenticated round trip.
|
|
func TestCodec_EncodeDecode(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
position := Position{CreatedAt: time.Unix(1700000000, 123456789).UTC(), ID: uuid.New()}
|
|
|
|
// Act.
|
|
encoded, err := codec.Encode("chats:alice", position)
|
|
|
|
// Assert.
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if encoded == "" {
|
|
t.Fatal("encoded position is empty")
|
|
}
|
|
decoded, err := codec.Decode(encoded, "chats:alice")
|
|
if err != nil || decoded != position {
|
|
t.Fatalf("decoded=%v, want=%v, error=%v", decoded, position, err)
|
|
}
|
|
}
|
|
|
|
// TestCodec_Decode checks first-page behavior and independent rejection conditions.
|
|
func TestCodec_Decode(t *testing.T) {
|
|
t.Run("Positive: empty token starts first page", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
|
|
// Act.
|
|
got, err := codec.Decode("", "chats:alice")
|
|
|
|
// Assert.
|
|
if err != nil || got != (Position{}) {
|
|
t.Fatalf("first-page position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Negative: another resource", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
encoded := encodeFixture(t, codec, "chats:alice")
|
|
|
|
// Act.
|
|
got, err := codec.Decode(encoded, "chats:bob")
|
|
|
|
// Assert.
|
|
if !errors.Is(err, ErrInvalid) || got != (Position{}) {
|
|
t.Fatalf("position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Negative: another process key", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
encoded := encodeFixture(t, codec, "chats:alice")
|
|
codec = newTestCodec(t)
|
|
|
|
// Act.
|
|
got, err := codec.Decode(encoded, "chats:alice")
|
|
|
|
// Assert.
|
|
if !errors.Is(err, ErrInvalid) || got != (Position{}) {
|
|
t.Fatalf("position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Negative: tampered payload", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
encoded := encodeFixture(t, codec, "chats:alice")
|
|
signed, err := base64.RawURLEncoding.DecodeString(encoded)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
signed[0] ^= 1
|
|
encoded = base64.RawURLEncoding.EncodeToString(signed)
|
|
|
|
// Act.
|
|
got, err := codec.Decode(encoded, "chats:alice")
|
|
|
|
// Assert.
|
|
if !errors.Is(err, ErrInvalid) || got != (Position{}) {
|
|
t.Fatalf("position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Negative: oversized token", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
encoded := strings.Repeat("a", 1025)
|
|
|
|
// Act.
|
|
got, err := codec.Decode(encoded, "chats:alice")
|
|
|
|
// Assert.
|
|
if !errors.Is(err, ErrInvalid) || got != (Position{}) {
|
|
t.Fatalf("position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Negative: malformed base64", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
encoded := "!invalid!"
|
|
|
|
// Act.
|
|
got, err := codec.Decode(encoded, "chats:alice")
|
|
|
|
// Assert.
|
|
if !errors.Is(err, ErrInvalid) || got != (Position{}) {
|
|
t.Fatalf("position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Negative: signed malformed JSON", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
encoded := signedPayload(codec, []byte("not JSON"))
|
|
|
|
// Act.
|
|
got, err := codec.Decode(encoded, "chats:alice")
|
|
|
|
// Assert.
|
|
if !errors.Is(err, ErrInvalid) || got != (Position{}) {
|
|
t.Fatalf("position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Negative: signed zero timestamp", func(t *testing.T) {
|
|
// Arrange.
|
|
codec := newTestCodec(t)
|
|
encoded := signedPayload(codec, []byte(`{"r":"chats:alice","t":"0001-01-01T00:00:00Z","i":"11111111-1111-1111-1111-111111111111"}`))
|
|
|
|
// Act.
|
|
got, err := codec.Decode(encoded, "chats:alice")
|
|
|
|
// Assert.
|
|
if !errors.Is(err, ErrInvalid) || got != (Position{}) {
|
|
t.Fatalf("position=%v, error=%v", got, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
// signedPayload creates authenticated malformed fixtures to isolate payload validation.
|
|
func signedPayload(codec *Codec, payload []byte) string {
|
|
return base64.RawURLEncoding.EncodeToString(append(payload, codec.signature(payload)...))
|
|
}
|
|
|
|
// newTestCodec creates an independent signing key for one scenario.
|
|
func newTestCodec(t *testing.T) *Codec {
|
|
t.Helper()
|
|
codec, err := New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return codec
|
|
}
|
|
|
|
// encodeFixture prepares a valid token before testing a separate decoding condition.
|
|
func encodeFixture(t *testing.T, codec *Codec, resource string) string {
|
|
t.Helper()
|
|
token, err := codec.Encode(resource, Position{ID: uuid.New(), CreatedAt: time.Unix(1700000000, 0).UTC()})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return token
|
|
}
|
|
|
|
// TestSharedCodec verifies a second process can verify the first process's cursor.
|
|
func TestSharedCodec(t *testing.T) {
|
|
key := base64.StdEncoding.EncodeToString(make([]byte, 32))
|
|
first, err := NewShared(key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
second, err := NewShared(key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
position := Position{CreatedAt: time.Now().UTC(), ID: uuid.New()}
|
|
encoded, err := first.Encode("chat", position)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := second.Decode(encoded, "chat")
|
|
if err != nil || result != position {
|
|
t.Fatalf("cross-replica cursor: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestSharedCodecRejectsInvalidKey requires a full 256-bit decoded secret.
|
|
func TestSharedCodecRejectsInvalidKey(t *testing.T) {
|
|
for _, key := range []string{"", "broken!", base64.StdEncoding.EncodeToString([]byte("short"))} {
|
|
t.Run(key, func(t *testing.T) {
|
|
if _, err := NewShared(key); err == nil {
|
|
t.Fatal("invalid key accepted")
|
|
}
|
|
})
|
|
}
|
|
}
|