Clean up, test, and document ContextType and ClientGetter options (#77)

## Summary: ContextType is in use at Khan as a part of our ka-context system; it basically just lets you configure the type to pass as the `ctx` argument to genqlient helpers (or say to omit such an argument). ClientGetter I wrote thinking we might use it; then we didn't (because we have a few different clients we may use) but it's not much code and may be helpful to others. In this commit I clean up, document, and add tests for both options. The cleanup is mainly for ClientGetter, which was kind of broken before because it was a Go snippet but couldn't specify imports. I was thinking maybe you want to be able to write `ctx.Something()`, but I just don't see how to make it work, so I made it a function of context, which is probably the better idea anyway. Additionally, I improved the documentation for both, and added tests for those and several other config options that weren't completely tested. Fixes #5. Issue: https://github.com/Khan/genqlient/issues/5 ## Test plan: make check Author: benjaminjkraft Reviewers: dnerdy, aberkan, MiguelCastillo Required Reviewers: Approved By: dnerdy Checks: ✅ Test (1.17), ✅ Test (1.16), ✅ Test (1.15), ✅ Test (1.14), ✅ Test (1.13), ✅ Lint, ✅ Test (1.17), ✅ Test (1.16), ✅ Test (1.15), ✅ Test (1.14), ✅ Test (1.13), ✅ Lint Pull Request URL: https://github.com/Khan/genqlient/pull/77
2021-09-07 09:58:49 -07:00
parent f3e601353c
commit 6c86eed770
46 changed files with 835 additions and 73 deletions
@@ -18,6 +18,36 @@ const (
 	errorsDir = "testdata/errors"
 )

+// buildGoFile returns an error if the given Go code is not valid.
+//
+// namePrefix is used for the temp-file, and is just for debugging.
+func buildGoFile(namePrefix string, content []byte) error {
+	// We need to put this within the current module, rather than in
+	// /tmp, so that it can access internal/testutil.
+	f, err := ioutil.TempFile("./testdata/tmp", namePrefix+"_*.go")
+	if err != nil {
+		return err
+	}
+	defer func() {
+		f.Close()
+		os.Remove(f.Name())
+	}()
+
+	_, err = f.Write(content)
+	if err != nil {
+		return err
+	}
+
+	cmd := exec.Command("go", "build", f.Name())
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err = cmd.Run()
+	if err != nil {
+		return fmt.Errorf("generated code does not compile: %w", err)
+	}
+	return nil
+}
+
 // TestGenerate is a snapshot-based test of code-generation.
 //
 // This file just has the test runner; the actual data is all in
@@ -91,29 +121,102 @@ func TestGenerate(t *testing.T) {
 						"https://github.com/Khan/genqlient/issues/43")
 				}

-				goContent := generated[goFilename]
-				// We need to put this within the current module, rather than in
-				// /tmp, so that it can access internal/testutil.
-				f, err := ioutil.TempFile("./testdata/tmp", sourceFilename+"_*.go")
+				err := buildGoFile(sourceFilename, generated[goFilename])
 				if err != nil {
-					t.Fatal(err)
+					t.Error(err)
 				}
-				defer func() {
-					f.Close()
-					os.Remove(f.Name())
-				}()
+			})
+		})
+	}
+}

-				_, err = f.Write(goContent)
-				if err != nil {
-					t.Fatal(err)
+// TestGenerateWithConfig tests several configuration options that affect
+// generated code but don't require particular query structures to test.
+//
+// It runs a simple query from TestGenerate with several different genqlient
+// configurations.  It uses snapshots, just like TestGenerate.
+func TestGenerateWithConfig(t *testing.T) {
+	tests := []struct {
+		name               string
+		fakeConfigFilename string
+		config             *Config // omits Schema and Operations, set below.
+	}{
+		{"DefaultConfig", "genqlient.yaml", defaultConfig},
+		{"Subpackage", "genqlient.yaml", &Config{
+			Generated:   "mypkg/myfile.go",
+			ContextType: "context.Context", // (from defaultConfig)
+		}},
+		{"SubpackageConfig", "mypkg/genqlient.yaml", &Config{
+			Generated:   "myfile.go", // (relative to genqlient.yaml)
+			ContextType: "context.Context",
+		}},
+		{"PackageName", "genqlient.yaml", &Config{
+			Generated:   "myfile.go",
+			Package:     "mypkg",
+			ContextType: "context.Context",
+		}},
+		{"ExportOperations", "genqlient.yaml", &Config{
+			Generated:        "generated.go",
+			ExportOperations: "operations.json",
+			ContextType:      "context.Context",
+		}},
+		{"CustomContext", "genqlient.yaml", &Config{
+			Generated:   "generated.go",
+			ContextType: "github.com/Khan/genqlient/internal/testutil.MyContext",
+		}},
+		{"NoContext", "genqlient.yaml", &Config{
+			Generated:   "generated.go",
+			ContextType: "",
+		}},
+		{"ClientGetter", "genqlient.yaml", &Config{
+			Generated:    "generated.go",
+			ClientGetter: "github.com/Khan/genqlient/internal/testutil.GetClientFromContext",
+			ContextType:  "context.Context",
+		}},
+		{"ClientGetterCustomContext", "genqlient.yaml", &Config{
+			Generated:    "generated.go",
+			ClientGetter: "github.com/Khan/genqlient/internal/testutil.GetClientFromMyContext",
+			ContextType:  "github.com/Khan/genqlient/internal/testutil.MyContext",
+		}},
+		{"ClientGetterNoContext", "genqlient.yaml", &Config{
+			Generated:    "generated.go",
+			ClientGetter: "github.com/Khan/genqlient/internal/testutil.GetClientFromNowhere",
+			ContextType:  "",
+		}},
+	}
+
+	sourceFilename := "SimpleQuery.graphql"
+
+	for _, test := range tests {
+		config := test.config
+		t.Run(test.name, func(t *testing.T) {
+			err := config.ValidateAndFillDefaults(
+				filepath.Join(dataDir, test.fakeConfigFilename))
+			config.Schema = filepath.Join(dataDir, "schema.graphql")
+			config.Operations = []string{filepath.Join(dataDir, sourceFilename)}
+			if err != nil {
+				t.Fatal(err)
+			}
+			generated, err := Generate(config)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			for filename, content := range generated {
+				t.Run(filename, func(t *testing.T) {
+					testutil.Cupaloy.SnapshotT(t, string(content))
+				})
+			}
+
+			t.Run("Build", func(t *testing.T) {
+				if testing.Short() {
+					t.Skip("skipping build due to -short")
 				}

-				cmd := exec.Command("go", "build", f.Name())
-				cmd.Stdout = os.Stdout
-				cmd.Stderr = os.Stderr
-				err = cmd.Run()
+				err := buildGoFile(sourceFilename,
+					generated[config.Generated])
 				if err != nil {
-					t.Fatal(fmt.Errorf("generated code does not compile: %w", err))
+					t.Error(err)
 				}
 			})
 		})