1 package templates
2
3 import (
4 "embed"
5 "fmt"
6 "os"
7 "path/filepath"
8 "testing"
9
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12
13 "github.com/99designs/gqlgen/internal/code"
14 )
15
16
17 var templateFS embed.FS
18
19 func TestToGo(t *testing.T) {
20 require.Equal(t, "ToCamel", ToGo("TO_CAMEL"))
21 require.Equal(t, "ToCamel", ToGo("to_camel"))
22 require.Equal(t, "ToCamel", ToGo("toCamel"))
23 require.Equal(t, "ToCamel", ToGo("ToCamel"))
24 require.Equal(t, "ToCamel", ToGo("to-camel"))
25 require.Equal(t, "ToCamel", ToGo("-to-camel"))
26 require.Equal(t, "ToCamel", ToGo("_to-camel"))
27 require.Equal(t, "_", ToGo("_"))
28
29 require.Equal(t, "RelatedURLs", ToGo("RelatedURLs"))
30 require.Equal(t, "ImageIDs", ToGo("ImageIDs"))
31 require.Equal(t, "FooID", ToGo("FooID"))
32 require.Equal(t, "IDFoo", ToGo("IDFoo"))
33 require.Equal(t, "FooASCII", ToGo("FooASCII"))
34 require.Equal(t, "ASCIIFoo", ToGo("ASCIIFoo"))
35 require.Equal(t, "FooUTF8", ToGo("FooUTF8"))
36 require.Equal(t, "UTF8Foo", ToGo("UTF8Foo"))
37 require.Equal(t, "JSONEncoding", ToGo("JSONEncoding"))
38
39 require.Equal(t, "A", ToGo("A"))
40 require.Equal(t, "ID", ToGo("ID"))
41 require.Equal(t, "ID", ToGo("id"))
42 require.Equal(t, "", ToGo(""))
43
44 require.Equal(t, "RelatedUrls", ToGo("RelatedUrls"))
45 require.Equal(t, "ITicket", ToGo("ITicket"))
46 require.Equal(t, "FooTicket", ToGo("fooTicket"))
47
48 require.Equal(t, "Idle", ToGo("IDLE"))
49 require.Equal(t, "Idle", ToGo("Idle"))
50 require.Equal(t, "Idle", ToGo("idle"))
51 require.Equal(t, "Identities", ToGo("IDENTITIES"))
52 require.Equal(t, "Identities", ToGo("Identities"))
53 require.Equal(t, "Identities", ToGo("identities"))
54 require.Equal(t, "Iphone", ToGo("IPHONE"))
55 require.Equal(t, "IPhone", ToGo("iPHONE"))
56 }
57
58 func TestToGoPrivate(t *testing.T) {
59 require.Equal(t, "toCamel", ToGoPrivate("TO_CAMEL"))
60 require.Equal(t, "toCamel", ToGoPrivate("to_camel"))
61 require.Equal(t, "toCamel", ToGoPrivate("toCamel"))
62 require.Equal(t, "toCamel", ToGoPrivate("ToCamel"))
63 require.Equal(t, "toCamel", ToGoPrivate("to-camel"))
64
65 require.Equal(t, "relatedURLs", ToGoPrivate("RelatedURLs"))
66 require.Equal(t, "imageIDs", ToGoPrivate("ImageIDs"))
67 require.Equal(t, "fooID", ToGoPrivate("FooID"))
68 require.Equal(t, "idFoo", ToGoPrivate("IDFoo"))
69 require.Equal(t, "fooASCII", ToGoPrivate("FooASCII"))
70 require.Equal(t, "asciiFoo", ToGoPrivate("ASCIIFoo"))
71 require.Equal(t, "fooUTF8", ToGoPrivate("FooUTF8"))
72 require.Equal(t, "utf8Foo", ToGoPrivate("UTF8Foo"))
73 require.Equal(t, "jsonEncoding", ToGoPrivate("JSONEncoding"))
74
75 require.Equal(t, "relatedUrls", ToGoPrivate("RelatedUrls"))
76 require.Equal(t, "iTicket", ToGoPrivate("ITicket"))
77
78 require.Equal(t, "rangeArg", ToGoPrivate("Range"))
79
80 require.Equal(t, "a", ToGoPrivate("A"))
81 require.Equal(t, "id", ToGoPrivate("ID"))
82 require.Equal(t, "id", ToGoPrivate("id"))
83 require.Equal(t, "", ToGoPrivate(""))
84 require.Equal(t, "_", ToGoPrivate("_"))
85
86 require.Equal(t, "idle", ToGoPrivate("IDLE"))
87 require.Equal(t, "idle", ToGoPrivate("Idle"))
88 require.Equal(t, "idle", ToGoPrivate("idle"))
89 require.Equal(t, "identities", ToGoPrivate("IDENTITIES"))
90 require.Equal(t, "identities", ToGoPrivate("Identities"))
91 require.Equal(t, "identities", ToGoPrivate("identities"))
92 require.Equal(t, "iphone", ToGoPrivate("IPHONE"))
93 require.Equal(t, "iPhone", ToGoPrivate("iPHONE"))
94 }
95
96 func TestToGoModelName(t *testing.T) {
97 type aTest struct {
98 input [][]string
99 expected []string
100 }
101
102 theTests := []aTest{
103 {
104 input: [][]string{{"MyValue"}},
105 expected: []string{"MyValue"},
106 },
107 {
108 input: [][]string{{"MyValue"}, {"myValue"}},
109 expected: []string{"MyValue", "MyValue0"},
110 },
111 {
112 input: [][]string{{"MyValue"}, {"YourValue"}},
113 expected: []string{"MyValue", "YourValue"},
114 },
115 {
116 input: [][]string{{"MyEnumName", "Value"}},
117 expected: []string{"MyEnumNameValue"},
118 },
119 {
120 input: [][]string{{"MyEnumName", "Value"}, {"MyEnumName", "value"}},
121 expected: []string{"MyEnumNameValue", "MyEnumNamevalue"},
122 },
123 {
124 input: [][]string{{"MyEnumName", "value"}, {"MyEnumName", "Value"}},
125 expected: []string{"MyEnumNameValue", "MyEnumNameValue0"},
126 },
127 {
128 input: [][]string{{"MyEnumName", "Value"}, {"MyEnumName", "value"}, {"MyEnumName", "vALue"}, {"MyEnumName", "VALue"}},
129 expected: []string{"MyEnumNameValue", "MyEnumNamevalue", "MyEnumNameVALue", "MyEnumNameVALue0"},
130 },
131 {
132 input: [][]string{{"MyEnumName", "TitleValue"}, {"MyEnumName", "title_value"}, {"MyEnumName", "title_Value"}, {"MyEnumName", "Title_Value"}},
133 expected: []string{"MyEnumNameTitleValue", "MyEnumNametitle_value", "MyEnumNametitle_Value", "MyEnumNameTitle_Value"},
134 },
135 {
136 input: [][]string{{"MyEnumName", "TitleValue", "OtherValue"}},
137 expected: []string{"MyEnumNameTitleValueOtherValue"},
138 },
139 {
140 input: [][]string{{"MyEnumName", "TitleValue", "OtherValue"}, {"MyEnumName", "title_value", "OtherValue"}},
141 expected: []string{"MyEnumNameTitleValueOtherValue", "MyEnumNametitle_valueOtherValue"},
142 },
143 }
144
145 for ti, at := range theTests {
146 resetModelNames()
147 t.Run(fmt.Sprintf("modelname-%d", ti), func(t *testing.T) {
148 at := at
149 for i, n := range at.input {
150 require.Equal(t, at.expected[i], ToGoModelName(n...))
151 }
152 })
153 }
154 }
155
156 func TestToGoPrivateModelName(t *testing.T) {
157 type aTest struct {
158 input [][]string
159 expected []string
160 }
161
162 theTests := []aTest{
163 {
164 input: [][]string{{"MyValue"}},
165 expected: []string{"myValue"},
166 },
167 {
168 input: [][]string{{"MyValue"}, {"myValue"}},
169 expected: []string{"myValue", "myValue0"},
170 },
171 {
172 input: [][]string{{"MyValue"}, {"YourValue"}},
173 expected: []string{"myValue", "yourValue"},
174 },
175 {
176 input: [][]string{{"MyEnumName", "Value"}},
177 expected: []string{"myEnumNameValue"},
178 },
179 {
180 input: [][]string{{"MyEnumName", "Value"}, {"MyEnumName", "value"}},
181 expected: []string{"myEnumNameValue", "myEnumNamevalue"},
182 },
183 {
184 input: [][]string{{"MyEnumName", "value"}, {"MyEnumName", "Value"}},
185 expected: []string{"myEnumNameValue", "myEnumNameValue0"},
186 },
187 {
188 input: [][]string{{"MyEnumName", "Value"}, {"MyEnumName", "value"}, {"MyEnumName", "vALue"}, {"MyEnumName", "VALue"}},
189 expected: []string{"myEnumNameValue", "myEnumNamevalue", "myEnumNameVALue", "myEnumNameVALue0"},
190 },
191 {
192 input: [][]string{{"MyEnumName", "TitleValue"}, {"MyEnumName", "title_value"}, {"MyEnumName", "title_Value"}, {"MyEnumName", "Title_Value"}},
193 expected: []string{"myEnumNameTitleValue", "myEnumNametitle_value", "myEnumNametitle_Value", "myEnumNameTitle_Value"},
194 },
195 {
196 input: [][]string{{"MyEnumName", "TitleValue", "OtherValue"}},
197 expected: []string{"myEnumNameTitleValueOtherValue"},
198 },
199 {
200 input: [][]string{{"MyEnumName", "TitleValue", "OtherValue"}, {"MyEnumName", "title_value", "OtherValue"}},
201 expected: []string{"myEnumNameTitleValueOtherValue", "myEnumNametitle_valueOtherValue"},
202 },
203 }
204
205 for ti, at := range theTests {
206 resetModelNames()
207 t.Run(fmt.Sprintf("modelname-%d", ti), func(t *testing.T) {
208 at := at
209 for i, n := range at.input {
210 require.Equal(t, at.expected[i], ToGoPrivateModelName(n...))
211 }
212 })
213 }
214 }
215
216 func Test_wordWalker(t *testing.T) {
217 makeInput := func(str string) []*wordInfo {
218 resultList := make([]*wordInfo, 0)
219 wordWalker(str, func(info *wordInfo) {
220 resultList = append(resultList, info)
221 })
222 return resultList
223 }
224
225 type aTest struct {
226 expected []*wordInfo
227 input []*wordInfo
228 }
229
230 theTests := []aTest{
231 {
232 input: makeInput("TO_CAMEL"),
233 expected: []*wordInfo{{Word: "TO"}, {WordOffset: 1, Word: "CAMEL"}},
234 },
235 {
236 input: makeInput("to_camel"),
237 expected: []*wordInfo{{Word: "to"}, {WordOffset: 1, Word: "camel"}},
238 },
239 {
240 input: makeInput("toCamel"),
241 expected: []*wordInfo{{Word: "to"}, {WordOffset: 1, Word: "Camel"}},
242 },
243 {
244 input: makeInput("ToCamel"),
245 expected: []*wordInfo{{Word: "To"}, {WordOffset: 1, Word: "Camel"}},
246 },
247 {
248 input: makeInput("to-camel"),
249 expected: []*wordInfo{{Word: "to"}, {WordOffset: 1, Word: "camel"}},
250 },
251 {
252 input: makeInput("RelatedURLs"),
253 expected: []*wordInfo{{Word: "Related"}, {WordOffset: 1, Word: "URLs", HasCommonInitial: true}},
254 },
255 {
256 input: makeInput("ImageIDs"),
257 expected: []*wordInfo{{Word: "Image"}, {WordOffset: 1, Word: "IDs", HasCommonInitial: true}},
258 },
259 {
260 input: makeInput("FooID"),
261 expected: []*wordInfo{{Word: "Foo"}, {WordOffset: 1, Word: "ID", HasCommonInitial: true, MatchCommonInitial: true}},
262 },
263 {
264 input: makeInput("IDFoo"),
265 expected: []*wordInfo{{Word: "ID", HasCommonInitial: true, MatchCommonInitial: true}, {WordOffset: 1, Word: "Foo"}},
266 },
267 {
268 input: makeInput("FooASCII"),
269 expected: []*wordInfo{{Word: "Foo"}, {WordOffset: 1, Word: "ASCII", HasCommonInitial: true, MatchCommonInitial: true}},
270 },
271 {
272 input: makeInput("ASCIIFoo"),
273 expected: []*wordInfo{{Word: "ASCII", HasCommonInitial: true, MatchCommonInitial: true}, {WordOffset: 1, Word: "Foo"}},
274 },
275 {
276 input: makeInput("FooUTF8"),
277 expected: []*wordInfo{{Word: "Foo"}, {WordOffset: 1, Word: "UTF8", HasCommonInitial: true, MatchCommonInitial: true}},
278 },
279 {
280 input: makeInput("UTF8Foo"),
281 expected: []*wordInfo{{Word: "UTF8", HasCommonInitial: true, MatchCommonInitial: true}, {WordOffset: 1, Word: "Foo"}},
282 },
283 {
284 input: makeInput("A"),
285 expected: []*wordInfo{{Word: "A"}},
286 },
287 {
288 input: makeInput("ID"),
289 expected: []*wordInfo{{Word: "ID", HasCommonInitial: true, MatchCommonInitial: true}},
290 },
291 {
292 input: makeInput("id"),
293 expected: []*wordInfo{{Word: "id", HasCommonInitial: true, MatchCommonInitial: true}},
294 },
295 {
296 input: makeInput(""),
297 expected: make([]*wordInfo, 0),
298 },
299 {
300 input: makeInput("RelatedUrls"),
301 expected: []*wordInfo{{Word: "Related"}, {WordOffset: 1, Word: "Urls"}},
302 },
303 {
304 input: makeInput("ITicket"),
305 expected: []*wordInfo{{Word: "ITicket"}},
306 },
307 }
308
309 for i, at := range theTests {
310 t.Run(fmt.Sprintf("wordWalker-%d", i), func(t *testing.T) {
311 require.Equal(t, at.input, at.expected)
312 })
313 }
314 }
315
316 func TestCenter(t *testing.T) {
317 require.Equal(t, "fffff", center(3, "#", "fffff"))
318 require.Equal(t, "##fffff###", center(10, "#", "fffff"))
319 require.Equal(t, "###fffff###", center(11, "#", "fffff"))
320 }
321
322 func TestTemplateOverride(t *testing.T) {
323 f, err := os.CreateTemp("", "gqlgen")
324 if err != nil {
325 t.Fatal(err)
326 }
327 defer f.Close()
328 defer os.RemoveAll(f.Name())
329 err = Render(Options{Template: "hello", Filename: f.Name(), Packages: code.NewPackages()})
330 if err != nil {
331 t.Fatal(err)
332 }
333 }
334
335 func TestRenderFS(t *testing.T) {
336
337 tempDir := t.TempDir()
338
339 outDir := filepath.Join(tempDir, "output")
340
341 _ = os.Mkdir(outDir, 0o755)
342
343 f, err := os.CreateTemp(outDir, "gqlgen.go")
344 if err != nil {
345 t.Fatal(err)
346 }
347 defer f.Close()
348 defer os.RemoveAll(f.Name())
349 err = Render(Options{TemplateFS: templateFS, Filename: f.Name(), Packages: code.NewPackages()})
350 if err != nil {
351 t.Fatal(err)
352 }
353
354 expectedString := "package \n\nimport (\n)\nthis is my test package"
355 actualContents, _ := os.ReadFile(f.Name())
356 actualContentsStr := string(actualContents)
357
358
359 assert.Equal(t, expectedString, actualContentsStr[:len(expectedString)])
360 }
361
View as plain text