Add github-local backend and E2E test coverage across all provider types

Introduce FakeGitHubProvider (embeds GitProvider, Type()="github") for
offline integration testing of GitHub-specific code paths. Wire a
--github-local flag on `wl join` so the offline test suite can exercise
the github provider without requiring a real GitHub account or gh CLI.

All existing integration tests now run against 3 backends (file, git,
github) instead of 2. New tests cover browse, status lifecycle, provider
gates (approve/request-changes/review --gh-pr), config get provider-type,
and review output formats (--md, --json).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: julianknutsen

cmd/wl/cmd_join.go

@@ -25,6 +25,7 @@ func newJoinCmd(stdout, stderr io.Writer) *cobra.Command {
 		remoteBase  string
 		gitRemote   string
 		github      bool
+		githubLocal string
 	)
 
 	cmd := &cobra.Command{
@@ -60,7 +61,7 @@ Examples:
 			if len(args) > 0 {
 				upstream = args[0]
 			}
-			return runJoin(stdout, stderr, upstream, handle, displayName, email, forkOrg, remoteBase, gitRemote, github)
+			return runJoin(stdout, stderr, upstream, handle, displayName, email, forkOrg, remoteBase, gitRemote, github, githubLocal)
 		},
 	}
 
@@ -71,12 +72,13 @@ Examples:
 	cmd.Flags().StringVar(&remoteBase, "remote-base", "", "Base directory for file:// remotes (offline mode)")
 	cmd.Flags().StringVar(&gitRemote, "git-remote", "", "Base directory for bare git remotes")
 	cmd.Flags().BoolVar(&github, "github", false, "Use GitHub as the upstream provider")
-	cmd.MarkFlagsMutuallyExclusive("remote-base", "git-remote", "github")
+	cmd.Flags().StringVar(&githubLocal, "github-local", "", "Local base directory for GitHub-compatible testing mode")
+	cmd.MarkFlagsMutuallyExclusive("remote-base", "git-remote", "github", "github-local")
 
 	return cmd
 }
 
-func runJoin(stdout, stderr io.Writer, upstream, handle, displayName, email, forkOrg, remoteBase, gitRemote string, github bool) error {
+func runJoin(stdout, stderr io.Writer, upstream, handle, displayName, email, forkOrg, remoteBase, gitRemote string, github bool, githubLocal string) error {
 	// Parse upstream path (validate early)
 	_, _, err := federation.ParseUpstream(upstream)
 	if err != nil {
@@ -123,6 +125,13 @@ func runJoin(stdout, stderr io.Writer, upstream, handle, displayName, email, for
 		}
 		provider = remote.NewGitHubProvider()
 
+	case githubLocal != "":
+		// GitHub-local mode — bare git repos that report type "github" for testing.
+		if forkOrg == "" {
+			return fmt.Errorf("--fork-org is required in GitHub-local mode (or set DOLTHUB_ORG)")
+		}
+		provider = remote.NewFakeGitHubProvider(githubLocal)
+
 	default:
 		// DoltHub mode — requires token and org.
 		token := commons.DoltHubToken()

cmd/wl/testdata/errors.txtar

@@ -18,6 +18,10 @@ env DOLTHUB_TOKEN=fake-token
 stderr 'DOLTHUB_ORG'
 env DOLTHUB_TOKEN=
 
+# join --github-local with --remote-base (mutually exclusive).
+! exec wl join hop/wl-commons --github-local /tmp --remote-base /tmp
+stderr 'none of the others can be'
+
 # post missing --title.
 ! exec wl post
 stderr 'required flag.*"title"'

internal/remote/conformance_test.go

@@ -173,6 +173,21 @@ func providers() []providerFactory {
 				}
 			},
 		},
+		{
+			name: "FakeGitHubProvider",
+			setup: func(t *testing.T, baseDir string) remote.Provider {
+				createGitSource(t, baseDir, "src-org", "testdb")
+				return remote.NewFakeGitHubProvider(baseDir)
+			},
+			urlTest: func(t *testing.T, url string) {
+				if !strings.HasPrefix(url, "file://") {
+					t.Errorf("FakeGitHubProvider URL should start with file://, got %q", url)
+				}
+				if !strings.HasSuffix(url, ".git") {
+					t.Errorf("FakeGitHubProvider URL should end with .git, got %q", url)
+				}
+			},
+		},
 	}
 }
 

internal/remote/github_fake.go

@@ -0,0 +1,17 @@
+package remote
+
+// FakeGitHubProvider embeds GitProvider and overrides Type() to return "github".
+// This enables offline integration tests to exercise GitHub-specific code paths
+// (provider gates, config fields) without requiring a real GitHub account or
+// the gh CLI.
+type FakeGitHubProvider struct {
+	*GitProvider
+}
+
+// NewFakeGitHubProvider creates a FakeGitHubProvider rooted at baseDir.
+func NewFakeGitHubProvider(baseDir string) *FakeGitHubProvider {
+	return &FakeGitHubProvider{GitProvider: NewGitProvider(baseDir)}
+}
+
+// Type returns "github" so cfg.IsGitHub() returns true after join.
+func (f *FakeGitHubProvider) Type() string { return "github" }

internal/remote/github_fake_test.go

@@ -0,0 +1,32 @@
+package remote_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/steveyegge/wasteland/internal/remote"
+)
+
+func TestFakeGitHubProviderType(t *testing.T) {
+	p := remote.NewFakeGitHubProvider("/tmp/test")
+	if got := p.Type(); got != "github" {
+		t.Errorf("Type() = %q, want %q", got, "github")
+	}
+}
+
+func TestFakeGitHubProviderDatabaseURL(t *testing.T) {
+	p := remote.NewFakeGitHubProvider("/tmp/base")
+	url := p.DatabaseURL("myorg", "mydb")
+	if !strings.HasPrefix(url, "file://") {
+		t.Errorf("URL should start with file://, got %q", url)
+	}
+	if !strings.HasSuffix(url, ".git") {
+		t.Errorf("URL should end with .git, got %q", url)
+	}
+	if !strings.Contains(url, "myorg") {
+		t.Errorf("URL should contain org, got %q", url)
+	}
+	if !strings.Contains(url, "mydb") {
+		t.Errorf("URL should contain db, got %q", url)
+	}
+}

test/integration/offline/browse_test.go

@@ -0,0 +1,66 @@
+//go:build integration
+
+package offline
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestBrowseIntegration(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := newTestEnv(t, backend)
+			env.createUpstreamStoreWithData(t, upstreamOrg, upstreamDB)
+			env.joinWasteland(t, upstream, forkOrg)
+
+			stdout, stderr, err := runWL(t, env, "browse")
+			if err != nil {
+				t.Fatalf("wl browse failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			if !strings.Contains(stdout, "Seed item from upstream") {
+				t.Errorf("expected browse output to contain 'Seed item from upstream', got: %s", stdout)
+			}
+		})
+	}
+}
+
+func TestBrowseJSON(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := newTestEnv(t, backend)
+			env.createUpstreamStoreWithData(t, upstreamOrg, upstreamDB)
+			env.joinWasteland(t, upstream, forkOrg)
+
+			stdout, stderr, err := runWL(t, env, "browse", "--json")
+			if err != nil {
+				t.Fatalf("wl browse --json failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			if !strings.Contains(stdout, "w-seed001") {
+				t.Errorf("expected JSON output to contain 'w-seed001', got: %s", stdout)
+			}
+		})
+	}
+}
+
+func TestBrowseFilterByType(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := newTestEnv(t, backend)
+			env.createUpstreamStoreWithData(t, upstreamOrg, upstreamDB)
+			env.joinWasteland(t, upstream, forkOrg)
+
+			// Seed data has type=feature. Filter by --type bug.
+			stdout, stderr, err := runWL(t, env, "browse", "--type", "bug")
+			if err != nil {
+				t.Fatalf("wl browse --type bug failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			if strings.Contains(stdout, "Seed item from upstream") {
+				t.Errorf("expected seed item NOT in bug-filtered output, got: %s", stdout)
+			}
+		})
+	}
+}

test/integration/offline/lifecycle_test.go

@@ -57,6 +57,42 @@ func TestJoinCreatesConfig(t *testing.T) {
 			if localDir == "" {
 				t.Fatal("local_dir is empty")
 			}
+
+			// Verify provider_type matches the backend.
+			providerType, _ := cfg["provider_type"].(string)
+			switch backend {
+			case fileBackend:
+				if providerType != "file" {
+					t.Errorf("provider_type = %q, want %q", providerType, "file")
+				}
+			case gitBackend:
+				if providerType != "git" {
+					t.Errorf("provider_type = %q, want %q", providerType, "git")
+				}
+			case githubBackend:
+				if providerType != "github" {
+					t.Errorf("provider_type = %q, want %q", providerType, "github")
+				}
+			}
+
+			// Verify upstream_url is set and has expected format.
+			upstreamURL, _ := cfg["upstream_url"].(string)
+			if upstreamURL == "" {
+				t.Fatal("upstream_url is empty")
+			}
+			if !strings.HasPrefix(upstreamURL, "file://") {
+				t.Errorf("upstream_url should start with file://, got %q", upstreamURL)
+			}
+			switch backend {
+			case gitBackend, githubBackend:
+				if !strings.HasSuffix(upstreamURL, ".git") {
+					t.Errorf("upstream_url for %s should end with .git, got %q", backend, upstreamURL)
+				}
+			case fileBackend:
+				if strings.HasSuffix(upstreamURL, ".git") {
+					t.Errorf("upstream_url for file should not end with .git, got %q", upstreamURL)
+				}
+			}
 		})
 	}
 }

test/integration/offline/offline_test.go

@@ -3,9 +3,10 @@
 // Package offline contains integration tests that exercise the wl binary
 // against real dolt databases using local remotes. No network required.
 //
-// Every test is parameterized over two backends:
+// Every test is parameterized over three backends:
 //   - file: dolt remote stores via --remote-base (file:// URLs)
 //   - git: bare git repos via --git-remote (file:// URLs to .git dirs)
+//   - github: bare git repos via --github-local (provider_type="github")
 //
 // Every test goes through the front door: "wl join" sets up the fork and
 // config, then post/claim/done/sync operate on the result.
@@ -80,12 +81,13 @@ func findRepoRoot() string {
 type backendKind string
 
 const (
-	fileBackend backendKind = "file"
-	gitBackend  backendKind = "git"
+	fileBackend   backendKind = "file"
+	gitBackend    backendKind = "git"
+	githubBackend backendKind = "github"
 )
 
 // backends lists all backends that every test runs against.
-var backends = []backendKind{fileBackend, gitBackend}
+var backends = []backendKind{fileBackend, gitBackend, githubBackend}
 
 // testEnv provides an isolated filesystem environment for each test.
 type testEnv struct {
@@ -201,7 +203,7 @@ func (e *testEnv) pushToUpstreamStore(t *testing.T, org, db, sql string) {
 func (e *testEnv) createStoreDir(t *testing.T, org, db string) string {
 	t.Helper()
 	switch e.Backend {
-	case gitBackend:
+	case gitBackend, githubBackend:
 		gitDir := filepath.Join(e.RemoteBase, org, db+".git")
 		if err := os.MkdirAll(gitDir, 0o755); err != nil {
 			t.Fatalf("creating upstream git dir: %v", err)
@@ -231,6 +233,8 @@ func (e *testEnv) remoteArgs() []string {
 	switch e.Backend {
 	case gitBackend:
 		return []string{"--git-remote", e.RemoteBase}
+	case githubBackend:
+		return []string{"--github-local", e.RemoteBase}
 	default:
 		return []string{"--remote-base", e.RemoteBase}
 	}

test/integration/offline/pr_mode_test.go

@@ -10,6 +10,98 @@ import (
 	"testing"
 )
 
+func TestConfigGetProviderType(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := joinedEnv(t, backend)
+
+			stdout, stderr, err := runWL(t, env, "config", "get", "provider-type")
+			if err != nil {
+				t.Fatalf("wl config get provider-type failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			got := strings.TrimSpace(stdout)
+			want := string(backend)
+			if got != want {
+				t.Errorf("provider-type = %q, want %q", got, want)
+			}
+		})
+	}
+}
+
+func TestReviewMarkdown(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := joinedEnv(t, backend)
+
+			// Switch to PR mode and post.
+			setMode(t, env, upstream, "pr")
+
+			stdout, _, err := runWL(t, env, "post",
+				"--title", "Markdown review test",
+				"--type", "feature",
+				"--no-push",
+			)
+			if err != nil {
+				t.Fatalf("wl post failed: %v", err)
+			}
+			wantedID := extractWantedID(t, stdout)
+			branch := "wl/" + forkOrg + "/" + wantedID
+
+			// Review with --md.
+			stdout, stderr, err := runWL(t, env, "review", branch, "--md")
+			if err != nil {
+				t.Fatalf("wl review --md failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			if !strings.Contains(stdout, "## wl review") {
+				t.Errorf("expected '## wl review' header, got: %s", stdout)
+			}
+			if !strings.Contains(stdout, "### Summary") {
+				t.Errorf("expected '### Summary' section, got: %s", stdout)
+			}
+			if !strings.Contains(stdout, "### Changes") {
+				t.Errorf("expected '### Changes' section, got: %s", stdout)
+			}
+		})
+	}
+}
+
+func TestReviewJSON(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := joinedEnv(t, backend)
+
+			// Switch to PR mode and post.
+			setMode(t, env, upstream, "pr")
+
+			stdout, _, err := runWL(t, env, "post",
+				"--title", "JSON review test",
+				"--type", "feature",
+				"--no-push",
+			)
+			if err != nil {
+				t.Fatalf("wl post failed: %v", err)
+			}
+			wantedID := extractWantedID(t, stdout)
+			branch := "wl/" + forkOrg + "/" + wantedID
+
+			// Review with --json.
+			stdout, stderr, err := runWL(t, env, "review", branch, "--json")
+			if err != nil {
+				t.Fatalf("wl review --json failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			// If there's output, it should be valid JSON.
+			// (dolt diff -r json may produce empty output on some versions.)
+			trimmed := strings.TrimSpace(stdout)
+			if trimmed != "" && !json.Valid([]byte(trimmed)) {
+				t.Errorf("review --json output is not valid JSON: %s", trimmed)
+			}
+		})
+	}
+}
+
 // setMode updates the wasteland config to the given mode.
 func setMode(t *testing.T, env *testEnv, upstreamPath, mode string) {
 	t.Helper()