hex_test.go raw
1 package validation
2
3 import "testing"
4
5 func TestContainsUppercaseHex(t *testing.T) {
6 tests := []struct {
7 name string
8 input []byte
9 expected bool
10 }{
11 {"empty", []byte{}, false},
12 {"lowercase only", []byte("abcdef0123456789"), false},
13 {"uppercase A", []byte("Abcdef0123456789"), true},
14 {"uppercase F", []byte("abcdeF0123456789"), true},
15 {"mixed uppercase", []byte("ABCDEF"), true},
16 {"numbers only", []byte("0123456789"), false},
17 {"lowercase with numbers", []byte("abc123def456"), false},
18 }
19
20 for _, tt := range tests {
21 t.Run(tt.name, func(t *testing.T) {
22 result := containsUppercaseHex(tt.input)
23 if result != tt.expected {
24 t.Errorf("containsUppercaseHex(%s) = %v, want %v", tt.input, result, tt.expected)
25 }
26 })
27 }
28 }
29
30 func TestValidateLowercaseHexInJSON(t *testing.T) {
31 tests := []struct {
32 name string
33 json []byte
34 wantError bool
35 }{
36 {
37 name: "valid lowercase",
38 json: []byte(`{"id":"abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789","pubkey":"fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210","sig":"abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789"}`),
39 wantError: false,
40 },
41 {
42 name: "uppercase in id",
43 json: []byte(`{"id":"ABCDEF0123456789abcdef0123456789abcdef0123456789abcdef0123456789","pubkey":"fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210"}`),
44 wantError: true,
45 },
46 {
47 name: "uppercase in pubkey",
48 json: []byte(`{"id":"abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789","pubkey":"FEDCBA9876543210fedcba9876543210fedcba9876543210fedcba9876543210"}`),
49 wantError: true,
50 },
51 {
52 name: "uppercase in sig",
53 json: []byte(`{"id":"abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789","sig":"ABCDEF0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789"}`),
54 wantError: true,
55 },
56 {
57 name: "no hex fields",
58 json: []byte(`{"kind":1,"content":"hello"}`),
59 wantError: false,
60 },
61 }
62
63 for _, tt := range tests {
64 t.Run(tt.name, func(t *testing.T) {
65 result := ValidateLowercaseHexInJSON(tt.json)
66 hasError := result != ""
67 if hasError != tt.wantError {
68 t.Errorf("ValidateLowercaseHexInJSON() error = %v, wantError %v, msg: %s", hasError, tt.wantError, result)
69 }
70 })
71 }
72 }
73
74 func TestValidateEPTagsInJSON(t *testing.T) {
75 tests := []struct {
76 name string
77 json []byte
78 wantError bool
79 }{
80 {
81 name: "valid lowercase e tag",
82 json: []byte(`{"tags":[["e","abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789"]]}`),
83 wantError: false,
84 },
85 {
86 name: "valid lowercase p tag",
87 json: []byte(`{"tags":[["p","abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789"]]}`),
88 wantError: false,
89 },
90 {
91 name: "uppercase in e tag",
92 json: []byte(`{"tags":[["e","ABCDEF0123456789abcdef0123456789abcdef0123456789abcdef0123456789"]]}`),
93 wantError: true,
94 },
95 {
96 name: "uppercase in p tag",
97 json: []byte(`{"tags":[["p","ABCDEF0123456789abcdef0123456789abcdef0123456789abcdef0123456789"]]}`),
98 wantError: true,
99 },
100 {
101 name: "mixed valid tags",
102 json: []byte(`{"tags":[["e","abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789"],["p","fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210"]]}`),
103 wantError: false,
104 },
105 {
106 name: "no tags",
107 json: []byte(`{"kind":1,"content":"hello"}`),
108 wantError: false,
109 },
110 {
111 name: "non-hex tag value",
112 json: []byte(`{"tags":[["t","sometag"]]}`),
113 wantError: false, // Non e/p tags are not checked
114 },
115 {
116 name: "short e tag value",
117 json: []byte(`{"tags":[["e","short"]]}`),
118 wantError: false, // Short values are not 64 chars so skipped
119 },
120 }
121
122 for _, tt := range tests {
123 t.Run(tt.name, func(t *testing.T) {
124 result := validateEPTagsInJSON(tt.json)
125 hasError := result != ""
126 if hasError != tt.wantError {
127 t.Errorf("validateEPTagsInJSON() error = %v, wantError %v, msg: %s", hasError, tt.wantError, result)
128 }
129 })
130 }
131 }
132
133 func TestValidateJSONHexField(t *testing.T) {
134 tests := []struct {
135 name string
136 json []byte
137 fieldName string
138 wantError bool
139 }{
140 {
141 name: "valid lowercase id",
142 json: []byte(`{"id":"abcdef0123456789"}`),
143 fieldName: `"id"`,
144 wantError: false,
145 },
146 {
147 name: "uppercase in field",
148 json: []byte(`{"id":"ABCDEF0123456789"}`),
149 fieldName: `"id"`,
150 wantError: true,
151 },
152 {
153 name: "field not found",
154 json: []byte(`{"other":"value"}`),
155 fieldName: `"id"`,
156 wantError: false,
157 },
158 {
159 name: "field with whitespace",
160 json: []byte(`{"id": "abcdef0123456789"}`),
161 fieldName: `"id"`,
162 wantError: false,
163 },
164 }
165
166 for _, tt := range tests {
167 t.Run(tt.name, func(t *testing.T) {
168 result := validateJSONHexField(tt.json, tt.fieldName)
169 hasError := result != ""
170 if hasError != tt.wantError {
171 t.Errorf("validateJSONHexField() error = %v, wantError %v, msg: %s", hasError, tt.wantError, result)
172 }
173 })
174 }
175 }
176