github.com/tcnksm/gcli@v0.2.4-0.20170129033839-7eb950507e5a/tests/helper_test.go (about)

     1  package main
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"os"
     8  	"os/exec"
     9  	"path/filepath"
    10  	"sync"
    11  )
    12  
    13  const EnvGcliPath = "GCLI_PATH"
    14  
    15  // runGcliMux is mutex for running gcli because GOPATH
    16  // is modified while test
    17  var runGcliMux sync.Mutex
    18  
    19  // gcli is executable path of gcli
    20  var gcli string
    21  
    22  func init() {
    23  	gcli = os.Getenv(EnvGcliPath)
    24  	if gcli == "" {
    25  		gcli = "../bin/gcli"
    26  	}
    27  
    28  	// Should be absolute path so that we can change dir
    29  	var err error
    30  	gcli, err = filepath.Abs(gcli)
    31  	if err != nil {
    32  		panic(err)
    33  	}
    34  }
    35  
    36  // tmpGopath create temporary GOPATH.
    37  // it returns its path and cleanFunction to remove directory.
    38  // return error if any.
    39  func tmpGopath() (string, func(), error) {
    40  	gopath, err := ioutil.TempDir("./", "test-tmp-gopath-")
    41  	if err != nil {
    42  		return "", nil, err
    43  	}
    44  
    45  	absGopath, err := filepath.Abs(gopath)
    46  	if err != nil {
    47  		return "", nil, err
    48  	}
    49  
    50  	return absGopath, func() {
    51  		if err := os.RemoveAll(absGopath); err != nil {
    52  			panic(err)
    53  		}
    54  	}, nil
    55  }
    56  
    57  // setEnv set enviromental variables and return restore function.
    58  func setEnv(key, val string) func() {
    59  
    60  	preVal := os.Getenv(key)
    61  	os.Setenv(key, val)
    62  
    63  	return func() {
    64  		os.Setenv(key, preVal)
    65  	}
    66  }
    67  
    68  func createFiles(outDir string, files []string) error {
    69  	// Check directory is exsit or not
    70  	if _, err := os.Stat(outDir); os.IsNotExist(err) {
    71  		return fmt.Errorf("no such file or directory")
    72  	}
    73  
    74  	if fi, _ := os.Stat(outDir); !fi.IsDir() {
    75  		return fmt.Errorf("%q shoudl be directory", outDir)
    76  	}
    77  
    78  	for _, file := range files {
    79  		newFile := filepath.Join(outDir, file)
    80  		fi, err := os.Create(newFile)
    81  		if err != nil {
    82  			return err
    83  		}
    84  		defer fi.Close()
    85  	}
    86  
    87  	return nil
    88  }
    89  
    90  func checkFiles(outDir string, files []string) error {
    91  
    92  	// Check directory is exsit or not
    93  	if _, err := os.Stat(outDir); os.IsNotExist(err) {
    94  		return fmt.Errorf("no such file or directory")
    95  	}
    96  
    97  	if fi, _ := os.Stat(outDir); !fi.IsDir() {
    98  		return fmt.Errorf("%q shoudl be directory", outDir)
    99  	}
   100  
   101  	// Read dir files
   102  	outputs, err := ioutil.ReadDir(outDir)
   103  	if err != nil {
   104  		return err
   105  	}
   106  
   107  	for _, file := range files {
   108  		isExist := false
   109  		for _, fi := range outputs {
   110  			if file == fi.Name() {
   111  				isExist = true
   112  				break
   113  			}
   114  		}
   115  
   116  		if !isExist {
   117  			return fmt.Errorf("%q is not exsit", file)
   118  		}
   119  	}
   120  
   121  	return nil
   122  }
   123  
   124  func runGcli(runDir, gopath string, args []string) (string, error) {
   125  	// Only one process can run gcli because it required
   126  	// modifying GOPATH and changing directory.
   127  	runGcliMux.Lock()
   128  	defer runGcliMux.Unlock()
   129  
   130  	// Modiry GOPATH while running gcli
   131  	resetFunc := setEnv("GOPATH", gopath)
   132  	defer resetFunc()
   133  
   134  	var stdout, stderr bytes.Buffer
   135  	cmd := exec.Command(gcli, args...)
   136  	cmd.Dir = runDir
   137  	cmd.Stderr = &stderr
   138  	cmd.Stdout = &stdout
   139  
   140  	if err := cmd.Start(); err != nil {
   141  		return "", fmt.Errorf("failed to start: %s\n\n %s", err, stderr.String())
   142  	}
   143  
   144  	if err := cmd.Wait(); err != nil {
   145  		return "", fmt.Errorf("failed to execute: %s\n\n %s", err, stderr.String())
   146  	}
   147  
   148  	return stdout.String(), nil
   149  
   150  }
   151  
   152  func runExecutable(bin string, args []string) string {
   153  	var stdout, stderr bytes.Buffer
   154  	cmd := exec.Command(bin, args...)
   155  	cmd.Stderr = &stderr
   156  	cmd.Stdout = &stdout
   157  
   158  	// cmd.Wait() returns error
   159  	_ = cmd.Run()
   160  
   161  	return stdout.String() + stderr.String()
   162  }