126 lines
2.8 KiB
Go
126 lines
2.8 KiB
Go
package cursortoken
|
|
|
|
import (
|
|
"git.blackforestbytes.com/BlackForestBytes/goext/tst"
|
|
"testing"
|
|
)
|
|
|
|
func TestDecodeEmpty(t *testing.T) {
|
|
tok, err := Decode("")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsStart())
|
|
tst.AssertFalse(t, tok.IsEnd())
|
|
tst.AssertEqual(t, tok.Token(), "@start")
|
|
}
|
|
|
|
func TestDecodeAtStart(t *testing.T) {
|
|
tok, err := Decode("@start")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsStart())
|
|
tst.AssertFalse(t, tok.IsEnd())
|
|
}
|
|
|
|
func TestDecodeAtStartUppercase(t *testing.T) {
|
|
tok, err := Decode("@START")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsStart())
|
|
}
|
|
|
|
func TestDecodeAtStartMixedCase(t *testing.T) {
|
|
tok, err := Decode("@StArT")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsStart())
|
|
}
|
|
|
|
func TestDecodeAtEnd(t *testing.T) {
|
|
tok, err := Decode("@end")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsEnd())
|
|
tst.AssertFalse(t, tok.IsStart())
|
|
}
|
|
|
|
func TestDecodeAtEndUppercase(t *testing.T) {
|
|
tok, err := Decode("@END")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsEnd())
|
|
}
|
|
|
|
func TestDecodeDollarEnd(t *testing.T) {
|
|
tok, err := Decode("$end")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsEnd())
|
|
_, ok := tok.(CTPaginated)
|
|
tst.AssertTrue(t, ok)
|
|
}
|
|
|
|
func TestDecodeDollarEndUppercase(t *testing.T) {
|
|
tok, err := Decode("$END")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsEnd())
|
|
}
|
|
|
|
func TestDecodeDollarPage(t *testing.T) {
|
|
tok, err := Decode("$5")
|
|
tst.AssertNoErr(t, err)
|
|
pg, ok := tok.(CTPaginated)
|
|
tst.AssertTrue(t, ok)
|
|
tst.AssertEqual(t, pg.Page, 5)
|
|
tst.AssertEqual(t, pg.Mode, CTMNormal)
|
|
}
|
|
|
|
func TestDecodeDollarPageOne(t *testing.T) {
|
|
tok, err := Decode("$1")
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertTrue(t, tok.IsStart())
|
|
pg, ok := tok.(CTPaginated)
|
|
tst.AssertTrue(t, ok)
|
|
tst.AssertEqual(t, pg.Page, 1)
|
|
}
|
|
|
|
func TestDecodeDollarPageInvalid(t *testing.T) {
|
|
_, err := Decode("$abc")
|
|
if err == nil {
|
|
t.Fatalf("expected error for invalid page")
|
|
}
|
|
}
|
|
|
|
func TestDecodeUnknownPrefix(t *testing.T) {
|
|
_, err := Decode("foobar")
|
|
if err == nil {
|
|
t.Fatalf("expected error for unknown prefix")
|
|
}
|
|
}
|
|
|
|
func TestDecodeInvalidBase32(t *testing.T) {
|
|
_, err := Decode("tok_!!!")
|
|
if err == nil {
|
|
t.Fatalf("expected error for invalid base32 body")
|
|
}
|
|
}
|
|
|
|
func TestDecodeInvalidJSON(t *testing.T) {
|
|
// "tok_" prefix with valid base32 but invalid JSON content
|
|
_, err := Decode("tok_NBSWY3DP")
|
|
if err == nil {
|
|
t.Fatalf("expected error for invalid json body")
|
|
}
|
|
}
|
|
|
|
func TestDecodeJustDollar(t *testing.T) {
|
|
// "$" alone (length == 1) should fall through to the unknown-prefix branch
|
|
_, err := Decode("$")
|
|
if err == nil {
|
|
t.Fatalf("expected error for bare $")
|
|
}
|
|
}
|
|
|
|
func TestDecodeKnownTokenContent(t *testing.T) {
|
|
tok := NewKeySortToken("k1", "k2", SortASC, SortDESC, 33, Extra{})
|
|
encoded := tok.Token()
|
|
|
|
decoded, err := Decode(encoded)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
tst.AssertEqual(t, decoded.Token(), encoded)
|
|
}
|