~bigbes/sr-ht-dolt

ref: 6b1c9b76a7fa6e49faa81a5959cf60dce5e947d0 sr-ht-dolt/core/names_test.go -rw-r--r-- 2.5 KiB
6b1c9b76 — Eugene Blikh browse: read-only doltdb browsing over bare stores a month ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

package core

import (
	"strings"
	"testing"
)

func TestValidateName(t *testing.T) {
	tests := []struct {
		name  string
		input string
		ok    bool
	}{
		{"simple", "demo", true},
		{"alnum", "db123", true},
		{"with-hyphen", "my-db", true},
		{"with-underscore", "my_db", true},
		{"mixed", "a-b_c-1", true},
		{"single-char", "a", true},
		{"single-digit", "7", true},
		{"max-length", strings.Repeat("a", MaxNameLen), true},

		{"empty", "", false},
		{"dot", ".", false},
		{"dotdot", "..", false},
		{"embedded-dot", "a.b", false},
		{"leading-hyphen", "-db", false},
		{"trailing-hyphen", "db-", false},
		{"leading-underscore", "_db", false},
		{"trailing-underscore", "db_", false},
		{"slash", "a/b", false},
		{"space", "a b", false},
		{"tilde", "~db", false},
		{"too-long", strings.Repeat("a", MaxNameLen+1), false},
		{"unicode", "café", false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateName(tt.input)
			if tt.ok && err != nil {
				t.Fatalf("ValidateName(%q) = %v, want nil", tt.input, err)
			}
			if !tt.ok && err == nil {
				t.Fatalf("ValidateName(%q) = nil, want error", tt.input)
			}
		})
	}
}

func TestParseRepoPath(t *testing.T) {
	tests := []struct {
		name      string
		input     string
		wantOwner string
		wantDB    string
		wantErr   bool
	}{
		{"tilde", "~user/db", "user", "db", false},
		{"no-tilde", "user/db", "user", "db", false},
		{"leading-slash", "/~user/db", "user", "db", false},
		{"trailing-slash", "~user/db/", "user", "db", false},
		{"both-slashes", "/~user/db/", "user", "db", false},
		{"names-with-symbols", "~my-user/my_db-1", "my-user", "my_db-1", false},

		{"empty", "", "", "", true},
		{"only-slashes", "///", "", "", true},
		{"one-segment", "~user", "", "", true},
		{"three-segments", "~user/db/extra", "", "", true},
		{"empty-inner-segment", "~user//db", "", "", true},
		{"traversal-dotdot", "~user/..", "", "", true},
		{"traversal-owner-dotdot", "../db", "", "", true},
		{"traversal-dot", "~user/.", "", "", true},
		{"tilde-only-owner", "~/db", "", "", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			owner, db, err := ParseRepoPath(tt.input)
			if tt.wantErr {
				if err == nil {
					t.Fatalf("ParseRepoPath(%q) = (%q,%q,nil), want error", tt.input, owner, db)
				}
				return
			}
			if err != nil {
				t.Fatalf("ParseRepoPath(%q) unexpected error: %v", tt.input, err)
			}
			if owner != tt.wantOwner || db != tt.wantDB {
				t.Fatalf("ParseRepoPath(%q) = (%q,%q), want (%q,%q)",
					tt.input, owner, db, tt.wantOwner, tt.wantDB)
			}
		})
	}
}