forked from mtusi2026/mtusi2026lab2
127 lines
3.8 KiB
Go
127 lines
3.8 KiB
Go
package model
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
func isValidationError(err error) bool {
|
|
var v *ValidationError
|
|
return errors.As(err, &v)
|
|
}
|
|
|
|
func TestNewUserDraft(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name, username, display string
|
|
ok bool
|
|
}{
|
|
{"minimal", "abc", "A", true},
|
|
{"max username 32", strings.Repeat("a", 32), "A", true},
|
|
{"username too short", "ab", "A", false},
|
|
{"username too long", strings.Repeat("a", 33), "A", false},
|
|
{"uppercase rejected", "Alice", "A", false},
|
|
{"cyrillic username rejected", "алиса", "A", false},
|
|
{"display 100 emoji ok", "abc", strings.Repeat("😀", 100), true},
|
|
{"display 101 code points rejected", "abc", strings.Repeat("ж", 101), false},
|
|
{"display whitespace only", "abc", " \t\n", false},
|
|
{"display empty", "abc", "", false},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
_, err := NewUserDraft(tc.username, tc.display)
|
|
if tc.ok && err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !tc.ok && !isValidationError(err) {
|
|
t.Fatalf("want ValidationError, got %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNewChatDraft(t *testing.T) {
|
|
t.Parallel()
|
|
me, other := uuid.New(), uuid.New()
|
|
tooMany := []uuid.UUID{me}
|
|
for range 100 {
|
|
tooMany = append(tooMany, uuid.New())
|
|
}
|
|
cases := []struct {
|
|
name string
|
|
members []uuid.UUID
|
|
ok bool
|
|
}{
|
|
{"creator only", []uuid.UUID{me}, true},
|
|
{"two members", []uuid.UUID{me, other}, true},
|
|
{"empty", nil, false},
|
|
{"creator missing", []uuid.UUID{other}, false},
|
|
{"duplicate member", []uuid.UUID{me, other, other}, false},
|
|
{"over 100 members", tooMany, false},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
_, err := NewChatDraft(me, "Чат", tc.members)
|
|
if tc.ok != (err == nil) {
|
|
t.Fatalf("ok=%v, err=%v", tc.ok, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNewMessageDraftLimitsInCodePoints(t *testing.T) {
|
|
t.Parallel()
|
|
if _, err := NewMessageDraft(uuid.New(), uuid.New(), strings.Repeat("👋", MaxMessageRunes)); err != nil {
|
|
t.Fatalf("4000 four-byte code points must pass: %v", err)
|
|
}
|
|
if _, err := NewMessageDraft(uuid.New(), uuid.New(), strings.Repeat("a", MaxMessageRunes+1)); !isValidationError(err) {
|
|
t.Fatalf("4001 code points must be rejected, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCursorRoundTripAndScope(t *testing.T) {
|
|
t.Parallel()
|
|
pos := Position{CreatedAt: time.Date(2026, 9, 1, 12, 0, 0, 123456000, time.UTC), ID: uuid.New()}
|
|
cursor := EncodeCursor("messages:a", pos)
|
|
|
|
q, err := NewPageQuery(nil, &cursor, "messages:a")
|
|
if err != nil || q.After == nil || *q.After != pos || q.Limit != DefaultPageLimit {
|
|
t.Fatalf("round trip failed: %+v, %v", q, err)
|
|
}
|
|
if _, err := NewPageQuery(nil, &cursor, "messages:b"); !isValidationError(err) {
|
|
t.Fatalf("cursor of another resource must be rejected, got %v", err)
|
|
}
|
|
for _, bad := range []string{"", "!!!", EncodeCursor("x", pos)[:5]} {
|
|
if _, err := NewPageQuery(nil, &bad, "messages:a"); !isValidationError(err) {
|
|
t.Fatalf("garbage cursor %q must be rejected, got %v", bad, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPageLimitBounds(t *testing.T) {
|
|
t.Parallel()
|
|
for limit, ok := range map[int]bool{0: false, 1: true, 100: true, 101: false, -1: false} {
|
|
_, err := NewPageQuery(&limit, nil, "chats")
|
|
if ok != (err == nil) {
|
|
t.Errorf("limit=%d: ok=%v, err=%v", limit, ok, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPositionOrderTiesBrokenByID(t *testing.T) {
|
|
t.Parallel()
|
|
at := time.Now()
|
|
low := Position{CreatedAt: at, ID: uuid.MustParse("00000000-0000-4000-8000-000000000001")}
|
|
high := Position{CreatedAt: at, ID: uuid.MustParse("ffffffff-0000-4000-8000-000000000000")}
|
|
later := Position{CreatedAt: at.Add(time.Microsecond), ID: low.ID}
|
|
if !high.After(low) || low.After(high) || !later.After(high) || low.After(low) {
|
|
t.Fatal("order must be (created_at, id) ascending")
|
|
}
|
|
}
|