127 lines
4.2 KiB
Go
127 lines
4.2 KiB
Go
package store
|
|
|
|
import (
|
|
"io/fs"
|
|
"slices"
|
|
"testing"
|
|
)
|
|
|
|
// Diese Tests laufen immer, auch ohne PostgreSQL. Die Tests gegen eine echte
|
|
// PostgreSQL-Datenbank stehen in postgres_test.go.
|
|
|
|
func TestNumberPlaceholders(t *testing.T) {
|
|
cases := []struct {
|
|
name, in, out string
|
|
}{
|
|
{"ohne Platzhalter", `SELECT 1`, `SELECT 1`},
|
|
{"der Reihe nach", `SELECT a FROM t WHERE x = ? AND y = ?`, `SELECT a FROM t WHERE x = $1 AND y = $2`},
|
|
{"IN-Liste", `WHERE id IN (?, ?, ?) LIMIT ?`, `WHERE id IN ($1, $2, $3) LIMIT $4`},
|
|
{"Text bleibt", `WHERE a = 'Wie geht das?' AND b = ?`, `WHERE a = 'Wie geht das?' AND b = $1`},
|
|
{"verdoppeltes Hochkomma", `WHERE a = 'It''s ?' AND b = ?`, `WHERE a = 'It''s ?' AND b = $1`},
|
|
{"Bezeichner bleibt", `SELECT "was?" FROM t WHERE a = ?`, `SELECT "was?" FROM t WHERE a = $1`},
|
|
{"Zeilenkommentar", "SELECT a -- warum?\nFROM t WHERE b = ?", "SELECT a -- warum?\nFROM t WHERE b = $1"},
|
|
{"Blockkommentar", `SELECT /* wer? */ a FROM t WHERE b = ?`, `SELECT /* wer? */ a FROM t WHERE b = $1`},
|
|
{"offener Text am Ende", `WHERE a = ? AND b = 'kaputt?`, `WHERE a = $1 AND b = 'kaputt?`},
|
|
{"Kommentar am Ende ohne Zeilenumbruch", `WHERE a = ? -- fertig?`, `WHERE a = $1 -- fertig?`},
|
|
{"zweistellig", `(?,?,?,?,?,?,?,?,?,?,?)`, `($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`},
|
|
}
|
|
for _, f := range cases {
|
|
t.Run(f.name, func(t *testing.T) {
|
|
if got := numberPlaceholders(f.in); got != f.out {
|
|
t.Errorf("\nein: %s\nist: %s\nsoll: %s", f.in, got, f.out)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLiteRebindLeavesQueryUnchanged(t *testing.T) {
|
|
query := `SELECT a FROM t WHERE x = ?`
|
|
if got := (sqliteDialect{}).rebind(query); got != query {
|
|
t.Errorf("SQLite hat die Abfrage verändert: %s", got)
|
|
}
|
|
}
|
|
|
|
// TestMigrationDirsMatch prüft, dass sqlite/ und postgres/ dieselben
|
|
// Migrationen enthalten. Eine Migration, die nur in einem Ordner liegt, würde
|
|
// die beiden Datenbanken unbemerkt auseinanderlaufen lassen — siehe
|
|
// AUSBAUSTUFEN.md 4.10.
|
|
//
|
|
// Ob die Migrationen auch dasselbe SCHEMA ergeben, prüft TestSchemaMatches
|
|
// (braucht PostgreSQL).
|
|
func TestMigrationDirsMatch(t *testing.T) {
|
|
for _, source := range []struct {
|
|
fsys fs.FS
|
|
dir string
|
|
}{
|
|
{migrationsFS, "migrations"},
|
|
{controlMigrationsFS, "migrations_control"},
|
|
} {
|
|
files := func(subdir string) []string {
|
|
entries, err := fs.ReadDir(source.fsys, source.dir+"/"+subdir)
|
|
if err != nil {
|
|
t.Fatalf("%s/%s: %v", source.dir, subdir, err)
|
|
}
|
|
var names []string
|
|
for _, e := range entries {
|
|
names = append(names, e.Name())
|
|
}
|
|
return names
|
|
}
|
|
|
|
sqlite := files((sqliteDialect{}).migrationsSubdir())
|
|
postgres := files((postgresDialect{}).migrationsSubdir())
|
|
if len(sqlite) == 0 {
|
|
t.Errorf("%s: keine Migrationen gefunden", source.dir)
|
|
}
|
|
if !slices.Equal(sqlite, postgres) {
|
|
t.Errorf("%s: Ordner unterscheiden sich\nsqlite: %v\npostgres: %v", source.dir, sqlite, postgres)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestWorkspaceSchema(t *testing.T) {
|
|
got, err := WorkspaceSchema("mue9bh3x-1c0e1120")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got != "munin_ws_mue9bh3x_1c0e1120" {
|
|
t.Errorf("Schema = %q", got)
|
|
}
|
|
|
|
// Eine echte ID muss immer passen.
|
|
if _, err := WorkspaceSchema(NewID()); err != nil {
|
|
t.Errorf("NewID() ergibt keinen gültigen Schemanamen: %v", err)
|
|
}
|
|
|
|
// Alles, was nicht wie eine ID aussieht, darf nie in einen Schemanamen.
|
|
for _, broken := range []string{"", "Groß", "a b", "a;DROP", `a"b`, "../x", "ä"} {
|
|
if _, err := WorkspaceSchema(broken); err == nil {
|
|
t.Errorf("WorkspaceSchema(%q) hätte abgelehnt werden müssen", broken)
|
|
}
|
|
}
|
|
|
|
// PostgreSQL würde längere Namen stillschweigend kürzen.
|
|
long := ""
|
|
for len(long) < 60 {
|
|
long += "abcdefghij"
|
|
}
|
|
if _, err := WorkspaceSchema(long); err == nil {
|
|
t.Error("zu lange ID wurde nicht abgelehnt")
|
|
}
|
|
}
|
|
|
|
func TestTextLiteral(t *testing.T) {
|
|
cases := map[string]string{
|
|
"Vertrieb": `E'Vertrieb'`,
|
|
"O'Brien": `E'O''Brien'`,
|
|
`C:\temp`: `E'C:\\temp'`,
|
|
`\'; DROP x; --`: `E'\\''; DROP x; --'`,
|
|
"mit\x00Null": `E'mitNull'`,
|
|
"Ärger & Öl": `E'Ärger & Öl'`,
|
|
}
|
|
for in, expected := range cases {
|
|
if got := textLiteral(in); got != expected {
|
|
t.Errorf("textLiteral(%q) = %s, erwartet %s", in, got, expected)
|
|
}
|
|
}
|
|
}
|