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