299 lines
8.4 KiB
Go
299 lines
8.4 KiB
Go
package furcadia
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestAddFurre(t *testing.T) {
|
|
testNames := []string{
|
|
"Artex",
|
|
"Albert Quirky",
|
|
"A|B|C",
|
|
"#SA",
|
|
}
|
|
|
|
pounce := NewPounceList()
|
|
|
|
// Success Scenarios //////////////////////////////////////////////////////////////////////////
|
|
|
|
for _, name := range testNames {
|
|
// check AddFurre() success
|
|
furre, err := pounce.AddFurre(name)
|
|
if err != nil {
|
|
t.Errorf("AddFurre(%v) failed: %v", name, err)
|
|
}
|
|
|
|
// check display name
|
|
if furre.DisplayName != name {
|
|
t.Errorf("AddFurre(%v).DisplayName == %v (mismatch)", name, furre.DisplayName)
|
|
}
|
|
|
|
// check shortname
|
|
expShort := GetShortName(name)
|
|
furreShort := furre.GetShortName()
|
|
if furreShort != expShort {
|
|
t.Errorf("AddFurre(%v).GetShortName() -> %v (expected: %v)", name, furreShort, expShort)
|
|
}
|
|
}
|
|
|
|
if len(pounce.Furres) != len(testNames) {
|
|
t.Errorf("Length inconsistency: len(pounce.Furres)=%v, len(testNames)=%v", len(pounce.Furres), len(testNames))
|
|
}
|
|
|
|
// Bad Scenarios //////////////////////////////////////////////////////////////////////////////
|
|
|
|
// already on record
|
|
furre, err := pounce.AddFurre("||ARTEX||")
|
|
if err == nil {
|
|
t.Errorf("AddFurre(||ARTEX||) unexpectedly succeeded: %v", furre)
|
|
}
|
|
|
|
// already on record
|
|
furre, err = pounce.AddFurre("albertquirky")
|
|
if err == nil {
|
|
t.Errorf("AddFurre(albertquirky) unexpectedly succeeded: %v", furre)
|
|
}
|
|
}
|
|
|
|
func TestDeleteFurre(t *testing.T) {
|
|
testNames := []string{
|
|
"Artex",
|
|
"Albert Quirky",
|
|
"A|B|C",
|
|
"#SA",
|
|
}
|
|
|
|
// create a pounce list and populate it with names
|
|
pounce := NewPounceList()
|
|
for _, name := range testNames {
|
|
pounce.AddFurre(name)
|
|
}
|
|
|
|
// delete using a different display name - should work
|
|
err := pounce.DeleteFurre("ALBERT|QUIRKY")
|
|
if err != nil {
|
|
t.Errorf("DeleteFurre(ALBERT|QUIRKY) failed: %v", err)
|
|
}
|
|
if len(pounce.Furres) != len(testNames)-1 {
|
|
t.Errorf("DeleteFurre(ALBERT|QUIRKY) caused invalid furre count: %v (testNames: %v)", len(pounce.Furres), len(testNames))
|
|
}
|
|
|
|
// delete for the second time - expect ErrNotFound
|
|
err = pounce.DeleteFurre("Albert Quirky")
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("DeleteFurre(Albert Quirky) for a missing record produced: %v (expected ErrNotFound)", err)
|
|
}
|
|
|
|
// delete everyone
|
|
for _, name := range testNames {
|
|
pounce.DeleteFurre(name)
|
|
}
|
|
if len(pounce.Furres) != 0 {
|
|
t.Errorf("Mass-delete did not empty furre list: %v", pounce.Furres)
|
|
}
|
|
}
|
|
|
|
func TestAddDream(t *testing.T) {
|
|
pounce := NewPounceList()
|
|
dream, err := pounce.AddDream("Ice Dragon", "Some dream name")
|
|
if err != nil {
|
|
t.Errorf("AddDream() failed: %v", err)
|
|
}
|
|
|
|
// test basic output
|
|
if dream.Title != "Ice Dragon: Some dream name" {
|
|
t.Errorf("AddDream(): unexpected title '%v'", dream.Title)
|
|
}
|
|
if dream.ShortURL != "icedragon:somedreamname" {
|
|
t.Errorf("AddDream(): unexpected short url '%v'", dream.ShortURL)
|
|
}
|
|
if dream.LastState != StateUnknown {
|
|
t.Errorf("AddDream(): unexpected initial state '%v'", dream.LastState)
|
|
}
|
|
if dream.LastState.IsOnline() {
|
|
t.Errorf("AddDream(): dream is with unknown state is initially online")
|
|
}
|
|
if dream.GetDreamURL() != "furc://icedragon:somedreamname/" {
|
|
t.Errorf("AddDream(): unexpected URL from GetDreamURL(): '%v'", dream.GetDreamURL())
|
|
}
|
|
|
|
// try to add this dream again; make sure it fails
|
|
d, err := pounce.AddDream("icedragon", "some_dream_name")
|
|
if !errors.Is(err, ErrExists) {
|
|
t.Errorf("AddDream(): duplicate add did not produce ErrExists, but %T(%v)", err, err)
|
|
}
|
|
if d != dream {
|
|
t.Errorf("AddDream(): expected existing dream, but got %T(%v)", d, d)
|
|
}
|
|
|
|
// try to add an analogous dream via dreamurl; make sure it also fails
|
|
d, err = pounce.AddDreamURL(dream.GetDreamURL())
|
|
if !errors.Is(err, ErrExists) {
|
|
t.Errorf("AddDreamURL(): analogous duplicate add did not produce ErrExists, but %T(%v)", err, err)
|
|
}
|
|
if d != dream {
|
|
t.Errorf("AddDreamURL(): expected existing dream, but got %T(%v)", d, d)
|
|
}
|
|
}
|
|
|
|
func TestAddDreamURL(t *testing.T) {
|
|
const longURL = "furc://a_r_t_e_x:some_dream_name"
|
|
const normalURL = "furc://artex:somedreamname/"
|
|
const shortURL = "artex:somedreamname"
|
|
|
|
pounce := NewPounceList()
|
|
dream, err := pounce.AddDreamURL(longURL)
|
|
if err != nil {
|
|
t.Errorf("AddDreamURL() failed: %v", err)
|
|
}
|
|
|
|
// test basic output
|
|
if dream.Title != longURL {
|
|
t.Errorf("AddDreamURL(): unexpected title '%v' (expected '%v')", dream.Title, longURL)
|
|
}
|
|
if dream.ShortURL != shortURL {
|
|
t.Errorf("AddDreamURL(): unexpected dream short url '%v' (expected '%v')", dream.ShortURL, shortURL)
|
|
}
|
|
if dream.LastState != StateUnknown {
|
|
t.Errorf("AddDream(): unexpected initial state '%v'", dream.LastState)
|
|
}
|
|
if dream.LastState.IsOnline() {
|
|
t.Errorf("AddDream(): dream is with unknown state is initially online")
|
|
}
|
|
if dream.GetDreamURL() != normalURL {
|
|
t.Errorf("AddDream(): unexpected URL from GetDreamURL(): '%v' (expected: '%v')", dream.GetDreamURL(), normalURL)
|
|
}
|
|
|
|
// try to add this dream again; make sure it fails
|
|
testDup := func(url string) {
|
|
d, err := pounce.AddDreamURL(url)
|
|
if !errors.Is(err, ErrExists) {
|
|
t.Errorf("AddDreamURL(): duplicate add for '%v' did not produce ErrExists, but %T(%v)", url, err, err)
|
|
}
|
|
|
|
// in case of ErrExists, d is the existing dream object
|
|
if d != dream {
|
|
t.Errorf("AddDreamURL(): expected existing dream for '%v', but got %+v", url, d)
|
|
}
|
|
}
|
|
testDup(longURL)
|
|
testDup(normalURL)
|
|
|
|
// try to add analogous dream via AddDream(); make sure it also fails
|
|
d, err := pounce.AddDream("Artex", "Some Dream Name")
|
|
if !errors.Is(err, ErrExists) {
|
|
t.Errorf("AddDream(): duplicate analogous add did not produce ErrExists, but %T(%v)", err, err)
|
|
}
|
|
if d != dream {
|
|
// in case of ErrExists, d is the existing dream object
|
|
t.Errorf("AddDream(): expected existing dream, but got %+v", d)
|
|
}
|
|
}
|
|
|
|
func TestDeleteDream(t *testing.T) {
|
|
const uploader = "Ice Dragon"
|
|
const dreamName = "Some dream name"
|
|
|
|
pounce := NewPounceList()
|
|
|
|
// try deleting a non-existant dream
|
|
err := pounce.DeleteDream(uploader, dreamName)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("DeleteDream(): expected ErrNotFound for non-existent dream, but got %T(%v)", err, err)
|
|
}
|
|
|
|
// add the dream
|
|
_, err = pounce.AddDream(uploader, dreamName)
|
|
if err != nil {
|
|
t.Errorf("AddDream() failed: %v", err)
|
|
}
|
|
|
|
// delete should succeed now
|
|
err = pounce.DeleteDream(uploader, dreamName)
|
|
if err != nil {
|
|
t.Errorf("DeleteDream() unexpectedly failed with %T(%v)", err, err)
|
|
}
|
|
|
|
// dream is no longer available again
|
|
err = pounce.DeleteDream(uploader, dreamName)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("DeleteDream(): expected ErrNotFound for deleted dream, but got %T(%v)", err, err)
|
|
}
|
|
}
|
|
|
|
func TestDeleteDreamURL(t *testing.T) {
|
|
const dreamURL = "furc://icedragon:somedreamname"
|
|
|
|
pounce := NewPounceList()
|
|
|
|
// try deleting a non-existant dream
|
|
err := pounce.DeleteDreamURL(dreamURL)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("DeleteDreamURL(): expected ErrNotFound for non-existent dream, but got %T(%v)", err, err)
|
|
}
|
|
|
|
// add the dream
|
|
_, err = pounce.AddDreamURL(dreamURL)
|
|
if err != nil {
|
|
t.Errorf("AddDreamURL() failed: %v", err)
|
|
}
|
|
|
|
// delete should succeed now
|
|
err = pounce.DeleteDreamURL(dreamURL)
|
|
if err != nil {
|
|
t.Errorf("DeleteDreamURL() unexpectedly failed with %T(%v)", err, err)
|
|
}
|
|
|
|
// dream is no longer available again
|
|
err = pounce.DeleteDreamURL(dreamURL)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("DeleteDreamURL(): expected ErrNotFound for deleted dream, but got %T(%v)", err, err)
|
|
}
|
|
}
|
|
|
|
func TestGetQueryString(t *testing.T) {
|
|
pounce := NewPounceList()
|
|
pounce.AddFurre("Artex")
|
|
pounce.AddFurre("Albert Quirky")
|
|
pounce.AddFurre("|Test|Alt|666#SA")
|
|
pounce.AddDream("Allegria", "")
|
|
pounce.AddDream("FurN", "")
|
|
pounce.AddDream("Bramblebrook", "Welcome")
|
|
pounce.AddDreamURL("furc://artex")
|
|
pounce.AddDreamURL("furc://artex:somename/")
|
|
|
|
query := pounce.GetQueryString() + "&"
|
|
expectedSubs := []string{
|
|
"u[]=artex&",
|
|
"u[]=albertquirky&",
|
|
"u[]=testalt666sa&",
|
|
"d[]=allegria&",
|
|
"d[]=furn&",
|
|
"d[]=bramblebrook:welcome&",
|
|
"d[]=artex&",
|
|
"d[]=artex:somename&",
|
|
}
|
|
unexpectedSubs := []string{
|
|
"&&",
|
|
}
|
|
|
|
nItems := len(strings.Split(query, "&"))
|
|
if nItems != len(expectedSubs)+1 {
|
|
t.Errorf("Unexpected number of items (%v) in query: %v", nItems, query)
|
|
}
|
|
|
|
for _, sub := range expectedSubs {
|
|
if !strings.Contains(query, sub) {
|
|
t.Errorf("Missing substring '%v' in query: %v", sub, query)
|
|
}
|
|
}
|
|
|
|
for _, sub := range unexpectedSubs {
|
|
if strings.Contains(query, sub) {
|
|
t.Errorf("Unexpected substring '%v' in query: %v", sub, query)
|
|
}
|
|
}
|
|
}
|