refactor: entrypoint

- add support for go test args to the entrypoint
- update Go version to 1.20
- rename is-subdomain to subdomain-gateway-spec
- add merged as argument to the extract-fixtures command
- rename entrypoint as gateway-conformance
- rename tests package from main to tests
- rename build tag to no_subdomain_gateway_spec
- add a utility function for accessing GATEWAY_CONFORMANCE_HOME

.github/actions/extract-fixtures/action.yml

@@ -6,6 +6,10 @@ inputs:
     description: 'The path where the fixtures will be saved'
     required: true
     default: 'fixtures'
+  merged:
+    description: 'Whether the fixtures should be merged into a single file'
+    required: false
+    default: 'false'
 runs:
   using: 'composite'
   steps:
@@ -15,8 +19,9 @@ runs:
       uses: pl-strflt/docker-container-action@v1
       env:
         OUTPUT: ${{ inputs.output }}
+        MERGED: ${{ inputs.merged }}
       with:
         repository: ${{ steps.github.outputs.action_repository }}
         ref: ${{ steps.github.outputs.action_ref }}
         dockerfile: Dockerfile
-        args: extract-fixtures "$OUTPUT"
+        args: extract-fixtures --directory="$OUTPUT" --merged="$MERGED"

.github/actions/test/action.yml

@@ -18,38 +18,30 @@ inputs:
   markdown:
     description: "The path where the Markdown report will be saved"
     required: false
-  is-subdomain:
-    description: "Enable the test suite for subdomain gateways"
+  subdomain-gateway-spec:
+    description: "Whether the gateway implements the subdomain gateway spec"
+    required: false
+    default: "true"
+  args:
+    description: "The arguments to pass to the test command"
     required: false
 runs:
   using: "composite"
   steps:
     - id: github
       uses: pl-strflt/docker-container-action/.github/actions/github@v1
-    - id: generate-args
-      name: Generate additional arguments
-      shell: bash
-      env:
-        IS_SUBDOMAIN: ${{ inputs.is-subdomain }}
-      run: |
-        ARGS=""
-        if [ "$IS_SUBDOMAIN" = "true" ]; then
-          ARGS="$ARGS --is-subdomain"
-        fi
-
-        echo "args=${ARGS}" >> "$GITHUB_OUTPUT"
     - name: Run the test
       uses: pl-strflt/docker-container-action@v1
       env:
-        GATEWAY_URL: ${{ inputs.gateway-url }}
+        URL: ${{ inputs.gateway-url }}
         JSON: ${{ inputs.json }}
-        ADDITIONAL_ARGS: ${{ steps.generate-args.outputs.args }}
+        SUBDOMAIN: ${{ inputs.subdomain-gateway-spec }}
       with:
         repository: ${{ steps.github.outputs.action_repository }}
         ref: ${{ steps.github.outputs.action_ref }}
         dockerfile: Dockerfile
         opts: --network=host
-        args: test --gateway-url "$GATEWAY_URL" --json-output "$JSON" ${ADDITIONAL_ARGS}
+        args: test --url="$URL" --json="$JSON" --subdomain="$SUBDOMAIN" -- ${{ inputs.args }}
     - name: Create the XML
       if: (inputs.xml || inputs.html || inputs.markdown) && (failure() || success())
       uses: pl-strflt/gotest-json-to-junit-xml@v1

.github/workflows/test.yml

@@ -34,7 +34,8 @@ jobs:
           xml: output.xml
           html: output.html
           markdown: output.md
-          is-subdomain: false
+          subdomain-gateway-spec: false
+          args: -skip TestGatewayCar
       - name: Set summary
         if: (failure() || success())
         run: cat ./output.md >> $GITHUB_STEP_SUMMARY

.gitignore

@@ -3,6 +3,7 @@
 /fixtures.car
 /merge-fixtures
 /entrypoint
+/gateway-conformance
 
 # Logs
 logs

Dockerfile

@@ -1,13 +1,11 @@
-FROM golang:1.19.1-buster
+FROM golang:1.20-alpine
 WORKDIR /app
-ENV TEST_PATH=/app
-
-RUN go install gotest.tools/gotestsum@v1.9.0
+ENV GATEWAY_CONFORMANCE_HOME=/app
 
 COPY ./go.mod ./go.sum ./
 RUN go mod download
 
 COPY . .
-RUN go build -o /entrypoint ./entrypoint.go
+RUN go build -o ./gateway-conformance ./entrypoint.go
 
-ENTRYPOINT ["/entrypoint"]
+ENTRYPOINT ["/app/gateway-conformance"]

Makefile

@@ -15,18 +15,18 @@ merge-fixtures:
 	go build -o merge-fixtures ./tooling/cmd/merge_fixtures.go
 
 # tools
-fixtures.car: entrypoint
-	./entrypoint merge-fixtures ./fixtures.car
+fixtures.car: gateway-conformance
+	./gateway-conformance extract-fixtures --merged=true --dir=.
 
-entrypoint:
-	go build -o ./entrypoint ./entrypoint.go
+gateway-conformance:
+	go build -o ./gateway-conformance ./entrypoint.go
 
-_test: fixtures.car entrypoint
-	./entrypoint test --json-output output.json --gateway-url ${GATEWAY_URL} --is-subdomain
+_test: fixtures.car gateway-conformance
+	./gateway-conformance test --json output.json --gateway-url ${GATEWAY_URL}
 
-test-docker: fixtures.car entrypoint
-	docker build -t gway-test .
-	docker run --rm -v "${PWD}:/workspace" -w "/workspace" --network=host gway-test test
+test-docker: fixtures.car gateway-conformance
+	docker build -t gateway-conformance .
+	docker run --rm -v "${PWD}:/workspace" -w "/workspace" --network=host gateway-conformance test
 
 output.xml: test-kubo
 	docker run --rm -v "${PWD}:/workspace" -w "/workspace" --entrypoint "/bin/bash" ghcr.io/pl-strflt/saxon:v1 -c """
@@ -37,4 +37,4 @@ output.html: output.xml
 	docker run --rm -v "${PWD}:/workspace" -w "/workspace" ghcr.io/pl-strflt/saxon:v1 -s:output.xml -xsl:/etc/junit-noframes-saxon.xsl -o:output.html
 	open ./output.html
 
-.PHONY: entrypoint
+.PHONY: gateway-conformance

entrypoint.go

@@ -1,119 +1,190 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
 
+	"github.com/ipfs/gateway-conformance/tooling"
 	"github.com/ipfs/gateway-conformance/tooling/cmd"
-
+	"github.com/ipfs/gateway-conformance/tooling/fixtures"
 	"github.com/urfave/cli/v2"
 )
 
+type event struct {
+	Action string
+	Test   string `json:",omitempty"`
+}
+
+type out struct {
+	Writer io.Writer
+}
+
+func (o out) Write(p []byte) (n int, err error) {
+	os.Stdout.Write(p)
+	return o.Writer.Write(p)
+}
+
+func copyFiles(inputPaths []string, outputDirectoryPath string) error {
+	err := os.MkdirAll(outputDirectoryPath, 0755)
+	if err != nil {
+		return err
+	}
+	for _, inputPath := range inputPaths {
+		outputPath := filepath.Join(outputDirectoryPath, filepath.Base(inputPath))
+		src, err := os.Open(inputPath)
+		if err != nil {
+			return err
+		}
+		defer src.Close()
+		dst, err := os.Create(outputPath)
+		if err != nil {
+			return err
+		}
+		defer dst.Close()
+		_, err = io.Copy(dst, src)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func main() {
-	var subdomain bool
 	var gatewayURL string
 	var jsonOutput string
+	var subdomainGatewaySpec bool
+	var directory string
+	var merged bool
 
 	app := &cli.App{
-		Name:  "entrypoint",
+		Name:  "gateway-conformance",
 		Usage: "Tooling for the gateway test suite",
 		Commands: []*cli.Command{
 			{
 				Name:  "test",
 				Aliases: []string{"t"},
 				Usage: "Run the conformance test suite against your gateway",
 				Flags: []cli.Flag{
-					&cli.BoolFlag{
-						Name:        "is-subdomain",
-						Aliases:     []string{"s"},
-						Usage:       "Run the testsuite for subdomain gateways",
-						Value:       false,
-						Destination: &subdomain,
-					},
 					&cli.StringFlag{
 						Name:        "gateway-url",
-						Aliases:     []string{"g"},
+						Aliases:     []string{"url", "g"},
 						Usage:       "The URL of the gateway to test",
 						Value:       "http://localhost:8080",
 						Destination: &gatewayURL,
 					},
 					&cli.StringFlag{
 						Name:        "json-output",
-						Aliases:     []string{"j"},
+						Aliases:     []string{"json", "j"},
 						Usage:       "The path to the JSON output file",
-						Value:       "results.json",
+						Value:       "",
 						Destination: &jsonOutput,
 					},
+					&cli.BoolFlag{
+						Name:        "subdomain-gateway-spec",
+						Aliases:     []string{"subdomain-gateway", "subdomain"},
+						Usage:       "Whether the gateway implements the subdomain gateway spec",
+						Value:       true,
+						Destination: &subdomainGatewaySpec,
+					},
 				},
 				Action: func(cCtx *cli.Context) error {
-					// Capture the output path, we run the tests in a different folder.
-					jsonOutputAbs, err := filepath.Abs(jsonOutput)
-					if err != nil {
-						panic(err)
-					}
+					args := []string{"test", "./tests", "-test.v=test2json"}
 
-					testTagsList := []string{}
-					if subdomain {
-						testTagsList = append(testTagsList, "test_subdomains")
+					tags := []string{}
+					if !subdomainGatewaySpec {
+						tags = append(tags, "no_subdomain_gateway_spec")
+					}
+					if len(tags) > 0 {
+						args = append(args, "-tags", strings.Join(tags, ","))
 					}
-					testTags := strings.Join(testTagsList, ",")
 
-					// run gotestsum --jsonfile ${...} ./tests -tags="${testTags}"
-					cmd := exec.Command("gotestsum", "--jsonfile", jsonOutputAbs, "./tests", "-tags="+testTags)
-					cmd.Env = append(os.Environ(), "GATEWAY_URL="+gatewayURL)
+					args = append(args, cCtx.Args().Slice()...)
 
-					// if environ containts "TEST_PATH" then use its value in cmd.Dir
-					if testPath, ok := os.LookupEnv("TEST_PATH"); ok {
-						cmd.Dir = testPath
-					}
-					cmd.Stdout = os.Stdout
+					fmt.Println("go " + strings.Join(args, " "))
+
+					output := &bytes.Buffer{}
+					cmd := exec.Command("go", args...)
+					cmd.Dir = tooling.Home()
+					cmd.Env = append(os.Environ(), fmt.Sprintf("GATEWAY_URL=%s", gatewayURL))
+					cmd.Stdout = out{output}
+					cmd.Stderr = os.Stderr
+					testErr := cmd.Run()
 
-					fmt.Printf("running: %s\n", cmd.String())
-					err = cmd.Run()
+					if jsonOutput != "" {
+						json := &bytes.Buffer{}
+						cmd = exec.Command("go", "tool", "test2json", "-p", "Gateway Tests", "-t")
+						cmd.Stdin = output
+						cmd.Stdout = json
+						cmd.Stderr = os.Stderr
+						err := cmd.Run()
+						if err != nil {
+							return err
+						}
+						// write jsonOutput to json file
+						f, err := os.Create(jsonOutput)
+						if err != nil {
+							return err
+						}
+						defer f.Close()
+						_, err = f.Write(json.Bytes())
+						if err != nil {
 							return err
+						}
+					}
+
+					return testErr
 				},
 			},
 			{
 				Name:  "extract-fixtures",
 				Aliases: []string{"e"},
-				Usage:   "Extract gateway testing fixture that is used by the conformance test suite",
+				Usage: "Extract gateway testing fixtures that are used by the conformance test suite",
+				Flags: []cli.Flag{
+					&cli.StringFlag{
+						Name:        "directory",
+						Aliases:     []string{"dir"},
+						Usage:       "The directory to extract the fixtures to",
+						Required:    true,
+						Destination: &directory,
+					},
+					&cli.BoolFlag{
+						Name:        "merged",
+						Usage:       "Merge the fixtures into a single CAR file",
+						Value:       false,
+						Destination: &merged,
+					},
+				},
 				Action: func(cCtx *cli.Context) error {
-					output := cCtx.Args().First()
-					if output == "" {
-						return fmt.Errorf("output path is required")
+					err := os.MkdirAll(directory, 0755)
+					if err != nil {
+						return err
 					}
 
-					// mkdir -p output:
-					err := os.MkdirAll(output, 0755)
+					files, err := fixtures.List()
 					if err != nil {
 						return err
 					}
 
-					// run shell command: `find /app/fixtures -name '*.car' -exec cp {} "${2}/" \;`
-					cmd := exec.Command("find", "/app/fixtures", "-name", "*.car", "-exec", "cp", "{}", output+"/", ";")
-					err = cmd.Run()
-
-					cmd.Stderr = os.Stderr
-					cmd.Stdout = os.Stdout
-
+					merged := cCtx.Bool("merged")
+					if merged {
+						err = cmd.Merge(filepath.Join(directory, "fixtures.car"))
+						if err != nil {
 							return err
-				},
-			},
-			{
-				Name:    "merge-fixtures",
-				Aliases: []string{"m"},
-				Usage:   "Merge all the fixtures into a single CAR file",
-				Action: func(cCtx *cli.Context) error {
-					output := cCtx.Args().First()
-					if output == "" {
-						return fmt.Errorf("output path is required")
+						}
+					} else {
+						err = copyFiles(files, directory)
+						if err != nil {
+							return err
+						}
 					}
 
-					return cmd.MergeFixtures(output)
+					return nil
 				},
 			},
 		},

tests/t0113_gateway_symlink_test.go

@@ -1,4 +1,4 @@
-package main
+package tests
 
 import (
 	"fmt"