testcase.go

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package integration

import (
	"encoding/json"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"unicode"

	"github.com/golang/dep/internal/test"
)

// TestCase manages a test case directory structure and content
type TestCase struct {
	t             *testing.T
	name          string
	rootPath      string
	initialPath   string
	finalPath     string
	Commands      [][]string        `json:"commands"`
	ShouldFail    bool              `json:"should-fail"`
	ErrorExpected string            `json:"error-expected"`
	GopathInitial map[string]string `json:"gopath-initial"`
	VendorInitial map[string]string `json:"vendor-initial"`
	VendorFinal   []string          `json:"vendor-final"`
	InitPath      string            `json:"init-path"`

	RequiredFeatureFlag string `json:"feature"`
}

// NewTestCase creates a new TestCase.
func NewTestCase(t *testing.T, dir, name string) *TestCase {
	rootPath := filepath.FromSlash(filepath.Join(dir, name))
	n := &TestCase{
		t:           t,
		name:        name,
		rootPath:    rootPath,
		initialPath: filepath.Join(rootPath, "initial"),
		finalPath:   filepath.Join(rootPath, "final"),
	}
	j, err := ioutil.ReadFile(filepath.Join(rootPath, "testcase.json"))
	if err != nil {
		t.Fatal(err)
	}
	err = json.Unmarshal(j, n)
	if err != nil {
		t.Fatal(err)
	}

	// Flip ShouldFail on if it's not set, but there's an expected error.
	if n.ErrorExpected != "" && !n.ShouldFail {
		n.ShouldFail = true
	}
	return n
}

// InitialPath represents the initial set of files in a project.
func (tc *TestCase) InitialPath() string {
	return tc.initialPath
}

// UpdateFile updates the golden file with the working result.
func (tc *TestCase) UpdateFile(goldenPath, workingPath string) {
	exists, working, err := getFile(workingPath)
	if err != nil {
		tc.t.Fatalf("Error reading project file %s: %s", goldenPath, err)
	}

	golden := filepath.Join(tc.finalPath, goldenPath)
	if exists {
		if err := tc.WriteFile(golden, working); err != nil {
			tc.t.Fatal(err)
		}
	} else {
		err := os.Remove(golden)
		if err != nil && !os.IsNotExist(err) {
			tc.t.Fatal(err)
		}
	}
}

// CompareFile compares the golden file with the working result.
func (tc *TestCase) CompareFile(goldenPath, working string) {
	golden := filepath.Join(tc.finalPath, goldenPath)

	gotExists, got, err := getFile(working)
	if err != nil {
		tc.t.Fatalf("Error reading project file %q: %s", goldenPath, err)
	}
	wantExists, want, err := getFile(golden)
	if err != nil {
		tc.t.Fatalf("Error reading testcase file %q: %s", goldenPath, err)
	}

	if wantExists && gotExists {
		if want != got {
			tc.t.Errorf("%s was not as expected\n(WNT):\n%s\n(GOT):\n%s", filepath.Base(goldenPath), want, got)
		}
	} else if !wantExists && gotExists {
		tc.t.Errorf("%q created where none was expected", goldenPath)
	} else if wantExists && !gotExists {
		tc.t.Errorf("%q not created where one was expected", goldenPath)
	}
}

// UpdateOutput updates the golden file for stdout with the working result.
func (tc *TestCase) UpdateOutput(stdout string) {
	stdoutPath := filepath.Join(tc.rootPath, "stdout.txt")
	_, err := os.Stat(stdoutPath)
	if err != nil {
		if os.IsNotExist(err) {
			// Don't update the stdout.txt file if it doesn't exist.
			return
		}
		panic(err)
	}

	if err := tc.WriteFile(stdoutPath, stdout); err != nil {
		tc.t.Fatal(err)
	}
}

// CompareOutput compares expected and actual stdout output.
func (tc *TestCase) CompareOutput(stdout string) {
	expected, err := ioutil.ReadFile(filepath.Join(tc.rootPath, "stdout.txt"))
	if err != nil {
		if os.IsNotExist(err) {
			// Nothing to verify
			return
		}
		panic(err)
	}

	expStr := normalizeLines(string(expected))
	stdout = normalizeLines(stdout)

	if expStr != stdout {
		tc.t.Errorf("stdout was not as expected\n(WNT):\n%s\n(GOT):\n%s\n", expStr, stdout)
	}
}

// normalizeLines returns a version with trailing whitespace stripped from each line.
func normalizeLines(s string) string {
	lines := strings.Split(s, "\n")
	for i := range lines {
		lines[i] = strings.TrimRightFunc(lines[i], unicode.IsSpace)
	}
	return strings.Join(lines, "\n")
}

// CompareError compares expected and actual stderr output.
func (tc *TestCase) CompareError(err error, stderr string) {
	wantExists, want := tc.ErrorExpected != "", tc.ErrorExpected
	gotExists, got := stderr != "" && err != nil, stderr

	if wantExists && gotExists {
		switch c := strings.Count(got, want); c {
		case 0:
			tc.t.Errorf("error did not contain expected string:\n\t(GOT): %s\n\t(WNT): %s", got, want)
		case 1:
		default:
			tc.t.Errorf("expected error %s matches %d times to actual error %s", want, c, got)
		}
	} else if !wantExists && gotExists {
		tc.t.Fatalf("error raised where none was expected: \n%v", stderr)
	} else if wantExists && !gotExists {
		tc.t.Error("error not raised where one was expected:", want)
	}
}

// CompareCmdFailure checks to see if the failure/success (in the sense of an
// exit code) was as expected by the test fixture.
func (tc *TestCase) CompareCmdFailure(gotFail bool) {
	if gotFail == tc.ShouldFail {
		return
	}

	if tc.ShouldFail {
		tc.t.Errorf("expected command to fail, but it did not")
	} else {
		tc.t.Errorf("expected command not to fail, but it did")
	}
}

// CompareVendorPaths validates the vendor directory contents.
func (tc *TestCase) CompareVendorPaths(gotVendorPaths []string) {
	if *test.UpdateGolden {
		tc.VendorFinal = gotVendorPaths
	} else {
		wantVendorPaths := tc.VendorFinal
		if len(gotVendorPaths) != len(wantVendorPaths) {
			tc.t.Fatalf("Wrong number of vendor paths created: want %d got %d", len(wantVendorPaths), len(gotVendorPaths))
		}
		for ind := range gotVendorPaths {
			if gotVendorPaths[ind] != wantVendorPaths[ind] {
				tc.t.Errorf("Mismatch in vendor paths created: want %s got %s", wantVendorPaths, gotVendorPaths)
			}
		}
	}
}

// WriteFile writes a file using the default file permissions.
func (tc *TestCase) WriteFile(src string, content string) error {
	return ioutil.WriteFile(src, []byte(content), 0666)
}

func getFile(path string) (bool, string, error) {
	_, err := os.Stat(path)
	if err != nil {
		return false, "", nil
	}
	f, err := ioutil.ReadFile(path)
	if err != nil {
		return true, "", err
	}
	return true, string(f), nil
}