github.com/wuhuizuo/gomplate@v3.5.0+incompatible/tests/integration/integration_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"encoding/json"
     5  	"go/build"
     6  	"io/ioutil"
     7  	"log"
     8  	"net"
     9  	"net/http"
    10  	"path/filepath"
    11  	"testing"
    12  	"time"
    13  
    14  	"github.com/gotestyourself/gotestyourself/icmd"
    15  	vaultapi "github.com/hashicorp/vault/api"
    16  	. "gopkg.in/check.v1"
    17  )
    18  
    19  var (
    20  	GomplateBin = filepath.Join(build.Default.GOPATH, "src", "github.com", "hairyhenderson", "gomplate", "bin", "gomplate")
    21  )
    22  
    23  // Hook up gocheck into the "go test" runner.
    24  func Test(t *testing.T) { TestingT(t) }
    25  
    26  // a convenience...
    27  func inOutTest(c *C, i string, o string) {
    28  	result := icmd.RunCommand(GomplateBin, "-i", i)
    29  	result.Assert(c, icmd.Expected{ExitCode: 0, Out: o})
    30  }
    31  
    32  func handle(c *C, err error) {
    33  	if err != nil {
    34  		c.Fatal(err)
    35  	}
    36  }
    37  
    38  // mirrorHandler - reflects back the HTTP headers from the request
    39  func mirrorHandler(w http.ResponseWriter, r *http.Request) {
    40  	type Req struct {
    41  		Headers http.Header `json:"headers"`
    42  	}
    43  	req := Req{r.Header}
    44  	b, err := json.Marshal(req)
    45  	if err != nil {
    46  		log.Println(err)
    47  		w.WriteHeader(http.StatusBadRequest)
    48  	}
    49  	w.Header().Set("Content-Type", "application/json")
    50  	w.Write(b)
    51  }
    52  
    53  func typeHandler(t, body string) func(http.ResponseWriter, *http.Request) {
    54  	return func(w http.ResponseWriter, r *http.Request) {
    55  		w.Header().Set("Content-Type", t)
    56  		w.Write([]byte(body))
    57  	}
    58  }
    59  
    60  // freeport - find a free TCP port for immediate use. No guarantees!
    61  func freeport() (port int, addr string) {
    62  	l, err := net.ListenTCP("tcp", &net.TCPAddr{IP: net.ParseIP("127.0.0.1")})
    63  	if err != nil {
    64  		panic(err)
    65  	}
    66  	defer l.Close()
    67  	a := l.Addr().(*net.TCPAddr)
    68  	port = a.Port
    69  	return port, a.String()
    70  }
    71  
    72  // waitForURL - waits up to 20s for a given URL to respond with a 200
    73  func waitForURL(c *C, url string) error {
    74  	client := http.DefaultClient
    75  	retries := 100
    76  	for retries > 0 {
    77  		retries--
    78  		time.Sleep(200 * time.Millisecond)
    79  		resp, err := client.Get(url)
    80  		if err != nil {
    81  			c.Logf("Got error, retries left: %d (error: %v)", retries, err)
    82  			continue
    83  		}
    84  		body, err := ioutil.ReadAll(resp.Body)
    85  		c.Logf("Body is: %s", body)
    86  		if err != nil {
    87  			return err
    88  		}
    89  		defer resp.Body.Close()
    90  		if resp.StatusCode == 200 {
    91  			return nil
    92  		}
    93  	}
    94  	return nil
    95  }
    96  
    97  type vaultClient struct {
    98  	addr      string
    99  	rootToken string
   100  	vc        *vaultapi.Client
   101  }
   102  
   103  func createVaultClient(addr string, rootToken string) (*vaultClient, error) {
   104  	config := vaultapi.DefaultConfig()
   105  	config.Address = "http://" + addr
   106  	client, err := vaultapi.NewClient(config)
   107  	if err != nil {
   108  		return nil, err
   109  	}
   110  	v := &vaultClient{
   111  		addr:      addr,
   112  		rootToken: rootToken,
   113  		vc:        client,
   114  	}
   115  	client.SetToken(rootToken)
   116  	return v, nil
   117  }
   118  
   119  func (v *vaultClient) tokenCreate(policy string, uses int) (string, error) {
   120  	opts := &vaultapi.TokenCreateRequest{
   121  		Policies: []string{policy},
   122  		TTL:      "1m",
   123  		NumUses:  uses,
   124  	}
   125  	token, err := v.vc.Auth().Token().Create(opts)
   126  	if err != nil {
   127  		return "", err
   128  	}
   129  	return token.Auth.ClientToken, nil
   130  }