Skip to content

armgit / lyftr

Public Imported from GitHub
0

Self-hosted fitness tracker. Log workouts, track nutrition, and monitor progress. Docker deployment, mobile-friendly.

6.1 KB
Raw Blame
package utils

import (
	"encoding/json"
	"go/ast"
	"go/parser"
	"go/token"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"sort"
	"strings"
	"testing"
	"unicode"
)

func TestCodeIDs(t *testing.T) {
	re := regexp.MustCompile(`^[A-Z][A-Z0-9_]*[A-Z0-9]$`)
	for id, c := range registry {
		if !re.MatchString(id) || len(id) > 63 {
			t.Errorf("%q is not an UPPER_SNAKE id of at most 63 characters", id)
		}
		if c.ID != id || c.Status < 400 {
			t.Errorf("%s: id %q status %d", id, c.ID, c.Status)
		}
	}
}

func TestCodeTemplatesAreSentences(t *testing.T) {
	params := map[string]any{"field": "exercises.sets.weight", "min": json.Number("8"), "max": 500, "options": "a, b", "timezone": "Mars/Base"}
	for id, c := range registry {
		if c.text == "" {
			t.Errorf("%s has no text", id)
			continue
		}
		if strings.TrimSpace(c.text) != c.text {
			t.Errorf("%s: %q has leading or trailing whitespace", id, c.text)
		}
		msg := c.Message(params)
		if !unicode.IsUpper([]rune(msg)[0]) {
			t.Errorf("%s: %q should start with a capital", id, msg)
		}
		switch msg[len(msg)-1] {
		case '.', '!', '?':
		default:
			t.Errorf("%s: %q should end in punctuation", id, msg)
		}
		if strings.Contains(msg, "{{") {
			t.Errorf("%s: unrendered placeholder in %q", id, msg)
		}
	}
}

// modelRules returns json name -> validate tags for every validated model field.
func modelRules(t *testing.T) map[string]string {
	t.Helper()
	files, err := filepath.Glob("../models/*.go")
	if err != nil || len(files) == 0 {
		t.Fatalf("no model files: %v", err)
	}
	out := map[string]string{}
	fset := token.NewFileSet()
	for _, f := range files {
		file, err := parser.ParseFile(fset, f, nil, 0)
		if err != nil {
			t.Fatal(err)
		}
		ast.Inspect(file, func(n ast.Node) bool {
			field, ok := n.(*ast.Field)
			if !ok || field.Tag == nil {
				return true
			}
			tag := reflect.StructTag(strings.Trim(field.Tag.Value, "`"))
			validate := tag.Get("validate")
			name := strings.SplitN(tag.Get("json"), ",", 2)[0]
			if validate != "" && name != "" && name != "-" {
				out[name] += validate + ","
			}
			return true
		})
	}
	return out
}

func clientCatalog(t *testing.T) map[string]map[string]string {
	t.Helper()
	raw, err := os.ReadFile("../../packages/shared/src/i18n/locales/en.json")
	if err != nil {
		t.Fatal(err)
	}
	var doc struct {
		Errors struct {
			API struct {
				Codes  map[string]string `json:"codes"`
				Fields map[string]string `json:"fields"`
			} `json:"api"`
		} `json:"errors"`
	}
	if err := json.Unmarshal(raw, &doc); err != nil {
		t.Fatal(err)
	}
	return map[string]map[string]string{"codes": doc.Errors.API.Codes, "fields": doc.Errors.API.Fields}
}

func keys[V any](m map[string]V) []string {
	out := make([]string, 0, len(m))
	for k := range m {
		out = append(out, k)
	}
	sort.Strings(out)
	return out
}

func TestClientCatalogMatchesRegistry(t *testing.T) {
	cat := clientCatalog(t)

	registered := map[string]string{}
	for id, c := range registry {
		registered[id] = c.text
	}
	if !reflect.DeepEqual(keys(cat["codes"]), keys(registered)) {
		t.Fatalf("en.json errors.api.codes keys differ from the registry:\n catalog  %v\n registry %v", keys(cat["codes"]), keys(registered))
	}
	for id, text := range registered {
		if cat["codes"][id] != text {
			t.Errorf("%s: en.json says %q, registry says %q", id, cat["codes"][id], text)
		}
	}

	fields := requestFields(t)
	if !reflect.DeepEqual(keys(cat["fields"]), keys(fields)) {
		t.Fatalf("en.json errors.api.fields keys differ from the request models' JSON names:\n catalog %v\n models  %v", keys(cat["fields"]), keys(fields))
	}
	for name, text := range cat["fields"] {
		if text != label(name) {
			t.Errorf("field %s: en.json says %q, label() says %q", name, text, label(name))
		}
	}
}

// isRequestType is the one definition of "a body a client sends": the field catalog is
// every JSON name of these, and every bind target must be one.
func isRequestType(name string) bool {
	return strings.HasSuffix(name, "Request") || strings.HasSuffix(name, "Req")
}

// requestFields returns the JSON name of every field of every models Request/Req struct.
func requestFields(t *testing.T) map[string]bool {
	t.Helper()
	files, err := filepath.Glob("../models/*.go")
	if err != nil || len(files) == 0 {
		t.Fatalf("no model files: %v", err)
	}
	out := map[string]bool{}
	fset := token.NewFileSet()
	for _, f := range files {
		file, err := parser.ParseFile(fset, f, nil, 0)
		if err != nil {
			t.Fatal(err)
		}
		ast.Inspect(file, func(n ast.Node) bool {
			spec, ok := n.(*ast.TypeSpec)
			if !ok || !isRequestType(spec.Name.Name) {
				return true
			}
			st, ok := spec.Type.(*ast.StructType)
			if !ok {
				return true
			}
			for _, field := range st.Fields.List {
				if field.Tag == nil {
					continue
				}
				tag := reflect.StructTag(strings.Trim(field.Tag.Value, "`"))
				name := strings.SplitN(tag.Get("json"), ",", 2)[0]
				if name != "" && name != "-" {
					out[name] = true
				}
			}
			return true
		})
	}
	return out
}

func TestEveryModelTagHasARule(t *testing.T) {
	known := map[string]bool{"omitempty": true, "dive": true}
	for name, tags := range modelRules(t) {
		for _, part := range strings.Split(strings.Trim(tags, ","), ",") {
			tag, param, _ := strings.Cut(part, "=")
			if known[tag] {
				continue
			}
			if param == "1" && (tag == "min" || tag == "max") {
				t.Errorf("%s: %s=1 breaks the plural templates", name, part)
			}
			found := false
			for k := range rules {
				if k == tag || strings.HasPrefix(k, tag+":") {
					found = true
				}
			}
			if !found {
				t.Errorf("%s: tag %q has no rule, so it would answer INVALID_FIELD", name, tag)
			}
		}
	}
}

func TestUnlabelInvertsLabel(t *testing.T) {
	for name := range modelRules(t) {
		if got := unlabel(label(name)); got != name {
			t.Errorf("unlabel(label(%q)) = %q", name, got)
		}
	}
}

func TestMessageRendersNumbers(t *testing.T) {
	cases := []struct {
		in   any
		want string
	}{{json.Number("2000"), "2,000"}, {2000, "2000"}, {json.Number("0"), "0"}}
	for _, tc := range cases {
		got := codeAboveMaximum.Message(map[string]any{"field": "weight", "max": tc.in})
		if want := "Weight must be " + tc.want + " or less."; got != want {
			t.Errorf("got %q, want %q", got, want)
		}
	}
}