use_test.go

package main

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"

	"github.com/andrewkroh/gvm"
)

func TestGVMRunUse(t *testing.T) {
	cases := []struct {
		Version string
		Format  string
		Cmds    []string
	}{
		{"1.7.4", "bash", []string{"export GOROOT=", "export PATH"}},
		{"1.7.4", "batch", []string{"set GOROOT=", "set PATH"}},
		{"1.7.4", "powershell", []string{"$env:GOROOT = ", "$env:PATH ="}},
		{"1.5.4", "bash", []string{"export GOROOT=", "export PATH", `export GO15VENDOREXPERIMENT="1"`}},
		{"1.5.4", "batch", []string{"set GOROOT=", "set PATH=", `set GO15VENDOREXPERIMENT=1`}},
		{"1.5.4", "powershell", []string{"$env:GOROOT = ", "$env:PATH =", `$env:GO15VENDOREXPERIMENT = "1"`}},
	}

	for _, tc := range cases {
		t.Run(fmt.Sprintf("%v_%v", tc.Version, tc.Format), func(t *testing.T) {
			output, err := withStdout(func() {
				manager := &gvm.Manager{}
				if err := manager.Init(); err != nil {
					t.Fatal(err)
				}

				cmd := &useCmd{
					version: tc.Version,
					format:  tc.Format,
				}
				err := cmd.Run(manager)
				if err != nil {
					t.Fatal(err)
				}
			})
			if err != nil {
				t.Fatal(err)
			}

			t.Log(output)
			lines := strings.Split(output, "\n")

			if !assert.Len(t, lines, len(tc.Cmds)+1, "expected %d lines, got [%v]", strings.Join(lines, "|")) {
				return
			}

			var goroot string
			for i, line := range lines[:len(lines)-1] {
				assert.Contains(t, line, tc.Cmds[i])

				if !strings.Contains(line, "PATH") && strings.Contains(line, "GOROOT") {
					parts := strings.SplitN(line, "=", 2)
					if len(parts) != 2 {
						t.Fatal("failed to parse GOROOT", line)
					}
					goroot = strings.Trim(parts[1], ` "`)
				}
			}

			// Test that GOROOT/bin/go exists and is the correct version.
			goVersionCmd := exec.Command(filepath.Join(goroot, "bin", "go"), "version")
			goVersionCmd.Env = append(goVersionCmd.Env, "GOROOT="+goroot)

			version, err := goVersionCmd.Output()
			if err != nil {
				var exitErr *exec.ExitError
				if errors.As(err, &exitErr) {
					t.Fatalf("failed to run go version: %v\n%s", err, exitErr.Stderr)
				} else {
					t.Fatal("failed to run go version", err)
				}
			}
			assert.Contains(t, string(version), tc.Version)
		})
	}
}

// capture stdout and return captured string
func withStdout(fn func()) (string, error) {
	stdout := os.Stdout

	r, w, err := os.Pipe()
	if err != nil {
		return "", err
	}

	os.Stdout = w
	defer func() {
		os.Stdout = stdout
	}()

	outC := make(chan string)
	go func() {
		// capture all output
		var buf bytes.Buffer
		_, err = io.Copy(&buf, r)
		r.Close()
		outC <- buf.String()
	}()

	fn()
	w.Close()
	result := <-outC
	return result, err
}