Add an option to output environment variables (#1)

Adds an `--output env` option to emit `SHARD_TESTS` and `SHARD_PATHS`
environment variables.

Example GitHub usage:

```
go run github.com/blampe/shard@latest --total $(TOTAL) --index $(INDEX) --output env >> "$GITHUB_ENV"
```

```
go test -run "$(SHARD_TESTS)" $(SHARD_PATHS)
```

Author: blampe

.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: ci
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - "*"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+      - run: go test -coverpkg ./... -coverprofile coverage.txt ./...
+      - uses: codecov/codecov-action@v5

README.md

@@ -29,7 +29,7 @@ We can discover test cases significantly faster by essentially `grep`-ing for pa
 
 * A test can potentially be executed more than once if another package shares a test with the same name.
   Renaming your tests to be globally unique is currently the best workaround if you want to guarantee a single execution per test function.
-  You can discover test with name collisions by running `shard --total 1 --index 0`.
+  You can discover tests with name collisions by running `shard --total 1 --index 0`.
 * Benchmarks aren't currently collected so running with `-bench` will not have any effect.
 
 

go.mod

@@ -1,3 +1,3 @@
 module github.com/blampe/shard
 
-go 1.22.6
+go 1.21.0

main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"log"
@@ -24,30 +25,56 @@ func main() {
 	index := flag.Int("index", -1, "shard index to collect tests for")
 	total := flag.Int("total", -1, "total number of shards")
 	seed := flag.Int64("seed", 0, "randomly shuffle tests using this seed")
+	output := flag.String("output", "", "output format (env)")
 
 	flag.Parse()
-	if *index < 0 {
-		log.Fatal("index is required")
+
+	p := prog{index: *index, total: *total, seed: *seed, root: *root, output: *output}
+	out, err := p.run()
+	if err != nil {
+		log.Fatal(err.Error())
 	}
-	if *total < 0 {
-		log.Fatal("total is required")
+	fmt.Fprint(os.Stdout, out)
+}
+
+type prog struct {
+	index  int
+	total  int
+	seed   int64
+	root   string
+	output string
+}
+
+func (p prog) run() (string, error) {
+	if p.index < 0 {
+		return "", errors.New("index is required")
+	}
+	if p.total < 0 {
+		return "", errors.New("total is required")
 	}
-	if *index >= *total {
-		log.Fatal("index must be less than total")
+	if p.index >= p.total {
+		return "", errors.New("index must be less than total")
 	}
 
-	tests, err := internal.Collect(*root)
+	tests, err := internal.Collect(p.root)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	names, paths := internal.Assign(tests, *index, *total, *seed)
+	names, paths := internal.Assign(tests, p.index, p.total, p.seed)
 
 	// No-op if we didn't find any tests or get any assigned.
 	if len(paths) == 0 {
-		paths = []string{*root}
+		paths = []string{p.root}
 		names = []string{"NoTestsFound"}
 	}
 
-	fmt.Printf("-run ^(%s)$ %s\n", strings.Join(names, "|"), strings.Join(paths, " "))
+	pattern := fmt.Sprintf(`^(?:%s)\$`, strings.Join(names, "|"))
+
+	switch p.output {
+	case "env":
+		return fmt.Sprintf("SHARD_TESTS=%s\nSHARD_PATHS=%s", pattern, strings.Join(paths, " ")), nil
+	default:
+		return fmt.Sprintf("-run %s  %s", pattern, strings.Join(paths, " ")), nil
+	}
 }

main_test.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestProg(t *testing.T) {
+	tests := []struct {
+		p       prog
+		name    string
+		want    string
+		wantErr error
+	}{
+		{
+			name: "default output",
+			p:    prog{total: 1, root: "."},
+			want: `-run ^(?:TestAssign|TestCollect|TestProg)\$  ./. ./internal`,
+		},
+		{
+			name: "env output",
+			p:    prog{output: "env", total: 1, root: "."},
+			want: `SHARD_TESTS=^(?:TestAssign|TestCollect|TestProg)\$
+SHARD_PATHS=./. ./internal`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			out, err := tt.p.run()
+			if out != tt.want {
+				t.Errorf("wanted %q but got %q", tt.want, out)
+
+			}
+			if !errors.Is(err, tt.wantErr) {
+				t.Errorf("wanted %q but got %q", tt.wantErr, err)
+			}
+		})
+	}
+
+}