github.com/kardianos/nomad@v0.1.3-0.20151022182107-b13df73ee850/api/api_test.go (about)

     1  package api
     2  
     3  import (
     4  	"net/http"
     5  	"os"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/hashicorp/nomad/testutil"
    10  )
    11  
    12  type configCallback func(c *Config)
    13  
    14  // seen is used to track which tests we have already marked as parallel
    15  var seen map[*testing.T]struct{}
    16  
    17  func init() {
    18  	seen = make(map[*testing.T]struct{})
    19  }
    20  
    21  func makeClient(t *testing.T, cb1 configCallback,
    22  	cb2 testutil.ServerConfigCallback) (*Client, *testutil.TestServer) {
    23  	// Always run these tests in parallel. Check if we have already
    24  	// marked the current test, as more than 1 call causes panics.
    25  	if _, ok := seen[t]; !ok {
    26  		seen[t] = struct{}{}
    27  		t.Parallel()
    28  	}
    29  
    30  	// Make client config
    31  	conf := DefaultConfig()
    32  	if cb1 != nil {
    33  		cb1(conf)
    34  	}
    35  
    36  	// Create server
    37  	server := testutil.NewTestServer(t, cb2)
    38  	conf.Address = "http://" + server.HTTPAddr
    39  
    40  	// Create client
    41  	client, err := NewClient(conf)
    42  	if err != nil {
    43  		t.Fatalf("err: %v", err)
    44  	}
    45  
    46  	return client, server
    47  }
    48  
    49  func TestDefaultConfig_env(t *testing.T) {
    50  	t.Parallel()
    51  	url := "http://1.2.3.4:5678"
    52  
    53  	os.Setenv("NOMAD_ADDR", url)
    54  	defer os.Setenv("NOMAD_ADDR", "")
    55  
    56  	config := DefaultConfig()
    57  
    58  	if config.Address != url {
    59  		t.Errorf("expected %q to be %q", config.Address, url)
    60  	}
    61  }
    62  
    63  func TestSetQueryOptions(t *testing.T) {
    64  	c, s := makeClient(t, nil, nil)
    65  	defer s.Stop()
    66  
    67  	r := c.newRequest("GET", "/v1/jobs")
    68  	q := &QueryOptions{
    69  		Region:     "foo",
    70  		AllowStale: true,
    71  		WaitIndex:  1000,
    72  		WaitTime:   100 * time.Second,
    73  	}
    74  	r.setQueryOptions(q)
    75  
    76  	if r.params.Get("region") != "foo" {
    77  		t.Fatalf("bad: %v", r.params)
    78  	}
    79  	if _, ok := r.params["stale"]; !ok {
    80  		t.Fatalf("bad: %v", r.params)
    81  	}
    82  	if r.params.Get("index") != "1000" {
    83  		t.Fatalf("bad: %v", r.params)
    84  	}
    85  	if r.params.Get("wait") != "100000ms" {
    86  		t.Fatalf("bad: %v", r.params)
    87  	}
    88  }
    89  
    90  func TestSetWriteOptions(t *testing.T) {
    91  	c, s := makeClient(t, nil, nil)
    92  	defer s.Stop()
    93  
    94  	r := c.newRequest("GET", "/v1/jobs")
    95  	q := &WriteOptions{
    96  		Region: "foo",
    97  	}
    98  	r.setWriteOptions(q)
    99  
   100  	if r.params.Get("region") != "foo" {
   101  		t.Fatalf("bad: %v", r.params)
   102  	}
   103  }
   104  
   105  func TestRequestToHTTP(t *testing.T) {
   106  	c, s := makeClient(t, nil, nil)
   107  	defer s.Stop()
   108  
   109  	r := c.newRequest("DELETE", "/v1/jobs/foo")
   110  	q := &QueryOptions{
   111  		Region: "foo",
   112  	}
   113  	r.setQueryOptions(q)
   114  	req, err := r.toHTTP()
   115  	if err != nil {
   116  		t.Fatalf("err: %v", err)
   117  	}
   118  
   119  	if req.Method != "DELETE" {
   120  		t.Fatalf("bad: %v", req)
   121  	}
   122  	if req.URL.RequestURI() != "/v1/jobs/foo?region=foo" {
   123  		t.Fatalf("bad: %v", req)
   124  	}
   125  }
   126  
   127  func TestParseQueryMeta(t *testing.T) {
   128  	t.Parallel()
   129  	resp := &http.Response{
   130  		Header: make(map[string][]string),
   131  	}
   132  	resp.Header.Set("X-Nomad-Index", "12345")
   133  	resp.Header.Set("X-Nomad-LastContact", "80")
   134  	resp.Header.Set("X-Nomad-KnownLeader", "true")
   135  
   136  	qm := &QueryMeta{}
   137  	if err := parseQueryMeta(resp, qm); err != nil {
   138  		t.Fatalf("err: %v", err)
   139  	}
   140  
   141  	if qm.LastIndex != 12345 {
   142  		t.Fatalf("Bad: %v", qm)
   143  	}
   144  	if qm.LastContact != 80*time.Millisecond {
   145  		t.Fatalf("Bad: %v", qm)
   146  	}
   147  	if !qm.KnownLeader {
   148  		t.Fatalf("Bad: %v", qm)
   149  	}
   150  }
   151  
   152  func TestParseWriteMeta(t *testing.T) {
   153  	t.Parallel()
   154  	resp := &http.Response{
   155  		Header: make(map[string][]string),
   156  	}
   157  	resp.Header.Set("X-Nomad-Index", "12345")
   158  
   159  	wm := &WriteMeta{}
   160  	if err := parseWriteMeta(resp, wm); err != nil {
   161  		t.Fatalf("err: %v", err)
   162  	}
   163  
   164  	if wm.LastIndex != 12345 {
   165  		t.Fatalf("Bad: %v", wm)
   166  	}
   167  }
   168  
   169  func TestQueryString(t *testing.T) {
   170  	c, s := makeClient(t, nil, nil)
   171  	defer s.Stop()
   172  
   173  	r := c.newRequest("PUT", "/v1/abc?foo=bar&baz=zip")
   174  	q := &WriteOptions{Region: "foo"}
   175  	r.setWriteOptions(q)
   176  
   177  	req, err := r.toHTTP()
   178  	if err != nil {
   179  		t.Fatalf("err: %s", err)
   180  	}
   181  
   182  	if uri := req.URL.RequestURI(); uri != "/v1/abc?baz=zip&foo=bar&region=foo" {
   183  		t.Fatalf("bad uri: %q", uri)
   184  	}
   185  }