orm/inflection/inflections_test.go

package inflection

import (
	"strings"
	"testing"
)

var inflections = map[string]string{
	"star":        "stars",
	"STAR":        "STARS",
	"Star":        "Stars",
	"bus":         "buses",
	"fish":        "fish",
	"mouse":       "mice",
	"query":       "queries",
	"ability":     "abilities",
	"agency":      "agencies",
	"movie":       "movies",
	"archive":     "archives",
	"index":       "indices",
	"wife":        "wives",
	"safe":        "saves",
	"half":        "halves",
	"move":        "moves",
	"salesperson": "salespeople",
	"person":      "people",
	"spokesman":   "spokesmen",
	"man":         "men",
	"woman":       "women",
	"basis":       "bases",
	"diagnosis":   "diagnoses",
	"diagnosis_a": "diagnosis_as",
	"datum":       "data",
	"medium":      "media",
	"stadium":     "stadia",
	"analysis":    "analyses",
	"node_child":  "node_children",
	"child":       "children",
	"experience":  "experiences",
	"day":         "days",
	"comment":     "comments",
	"foobar":      "foobars",
	"newsletter":  "newsletters",
	"old_news":    "old_news",
	"news":        "news",
	"series":      "series",
	"species":     "species",
	"quiz":        "quizzes",
	"perspective": "perspectives",
	"ox":          "oxen",
	"photo":       "photos",
	"buffalo":     "buffaloes",
	"tomato":      "tomatoes",
	"dwarf":       "dwarves",
	"elf":         "elves",
	"information": "information",
	"equipment":   "equipment",
	"criterion":   "criteria",
}

// storage is used to restore the state of the global variables
// on each test execution, to ensure no global state pollution
type storage struct {
	singulars    RegularSlice
	plurals      RegularSlice
	irregulars   IrregularSlice
	uncountables []string
}

var backup = storage{}

func init() {
	AddIrregular("criterion", "criteria")
	copy(backup.singulars, singularInflections)
	copy(backup.plurals, pluralInflections)
	copy(backup.irregulars, irregularInflections)
	copy(backup.uncountables, uncountableInflections)
}

func restore() {
	copy(singularInflections, backup.singulars)
	copy(pluralInflections, backup.plurals)
	copy(irregularInflections, backup.irregulars)
	copy(uncountableInflections, backup.uncountables)
}

func TestPlural(t *testing.T) {
	for key, value := range inflections {
		if v := Plural(strings.ToUpper(key)); v != strings.ToUpper(value) {
			t.Errorf("%v's plural should be %v, but got %v", strings.ToUpper(key), strings.ToUpper(value), v)
		}

		if v := Plural(strings.Title(key)); v != strings.Title(value) {
			t.Errorf("%v's plural should be %v, but got %v", strings.Title(key), strings.Title(value), v)
		}

		if v := Plural(key); v != value {
			t.Errorf("%v's plural should be %v, but got %v", key, value, v)
		}
	}
}

func TestSingular(t *testing.T) {
	for key, value := range inflections {
		if v := Singular(strings.ToUpper(value)); v != strings.ToUpper(key) {
			t.Errorf("%v's singular should be %v, but got %v", strings.ToUpper(value), strings.ToUpper(key), v)
		}

		if v := Singular(strings.Title(value)); v != strings.Title(key) {
			t.Errorf("%v's singular should be %v, but got %v", strings.Title(value), strings.Title(key), v)
		}

		if v := Singular(value); v != key {
			t.Errorf("%v's singular should be %v, but got %v", value, key, v)
		}
	}
}

func TestAddPlural(t *testing.T) {
	defer restore()
	ln := len(pluralInflections)
	AddPlural("", "")
	if ln+1 != len(pluralInflections) {
		t.Errorf("Expected len %d, got %d", ln+1, len(pluralInflections))
	}
}

func TestAddSingular(t *testing.T) {
	defer restore()
	ln := len(singularInflections)
	AddSingular("", "")
	if ln+1 != len(singularInflections) {
		t.Errorf("Expected len %d, got %d", ln+1, len(singularInflections))
	}
}

func TestAddIrregular(t *testing.T) {
	defer restore()
	ln := len(irregularInflections)
	AddIrregular("", "")
	if ln+1 != len(irregularInflections) {
		t.Errorf("Expected len %d, got %d", ln+1, len(irregularInflections))
	}
}

func TestAddUncountable(t *testing.T) {
	defer restore()
	ln := len(uncountableInflections)
	AddUncountable("", "")
	if ln+2 != len(uncountableInflections) {
		t.Errorf("Expected len %d, got %d", ln+2, len(uncountableInflections))
	}
}

func TestGetPlural(t *testing.T) {
	plurals := GetPlural()
	if len(plurals) != len(pluralInflections) {
		t.Errorf("Expected len %d, got %d", len(plurals), len(pluralInflections))
	}
}

func TestGetSingular(t *testing.T) {
	singular := GetSingular()
	if len(singular) != len(singularInflections) {
		t.Errorf("Expected len %d, got %d", len(singular), len(singularInflections))
	}
}

func TestGetIrregular(t *testing.T) {
	irregular := GetIrregular()
	if len(irregular) != len(irregularInflections) {
		t.Errorf("Expected len %d, got %d", len(irregular), len(irregularInflections))
	}
}

func TestGetUncountable(t *testing.T) {
	uncountables := GetUncountable()
	if len(uncountables) != len(uncountableInflections) {
		t.Errorf("Expected len %d, got %d", len(uncountables), len(uncountableInflections))
	}
}

func TestSetPlural(t *testing.T) {
	defer restore()
	SetPlural(RegularSlice{{}, {}})
	if len(pluralInflections) != 2 {
		t.Errorf("Expected len 2, got %d", len(pluralInflections))
	}
}

func TestSetSingular(t *testing.T) {
	defer restore()
	SetSingular(RegularSlice{{}, {}})
	if len(singularInflections) != 2 {
		t.Errorf("Expected len 2, got %d", len(singularInflections))
	}
}

func TestSetIrregular(t *testing.T) {
	defer restore()
	SetIrregular(IrregularSlice{{}, {}})
	if len(irregularInflections) != 2 {
		t.Errorf("Expected len 2, got %d", len(irregularInflections))
	}
}

func TestSetUncountable(t *testing.T) {
	defer restore()
	SetUncountable([]string{"", ""})
	if len(uncountableInflections) != 2 {
		t.Errorf("Expected len 2, got %d", len(uncountableInflections))
	}
}