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  }