From 13dab7dd2411f9de14eabbeb8d047307d989f00f Mon Sep 17 00:00:00 2001 From: Jeff Mitchell Date: Fri, 29 Mar 2019 14:47:40 -0400 Subject: [PATCH] Divest api/ package of deps elsewhere in the nomad repo. (#5488) * Divest api/ package of deps elsewhere in the nomad repo. This will allow making api/ a module without then pulling in the external repo, leading to a package name conflict. This required some migration of tests to an apitests/ folder (can be moved anywhere as it has no deps on it). It also required some duplication of code, notably some test helpers from api/ -> apitests/ and part (but not all) of testutil/ -> api/testutil/. Once there's more separation and an e.g. sdk/ folder those can be removed in favor of a dep on the sdk/ folder, provided the sdk/ folder doesn't depend on api/ or /. * Also remove consul dep from api/ package * Fix stupid linters * Some restructuring --- api/agent_test.go | 2 +- api/allocations_test.go | 16 +- api/api_test.go | 16 +- api/fs_test.go | 2 +- api/internal/testutil/discover/discover.go | 66 +++ api/internal/testutil/freeport/freeport.go | 139 +++++++ api/internal/testutil/responsewriter.go | 76 ++++ api/internal/testutil/server.go | 378 ++++++++++++++++++ api/internal/testutil/slow.go | 15 + api/internal/testutil/wait.go | 74 ++++ api/jobs_test.go | 80 +--- api/nodes_test.go | 28 +- api/operator_test.go | 70 ---- api/regions_test.go | 2 +- api/tasks_test.go | 162 -------- internal/testing/apitests/api_test.go | 56 +++ internal/testing/apitests/jobs_test.go | 85 ++++ internal/testing/apitests/nodes_test.go | 33 ++ .../apitests}/operator_autopilot_test.go | 13 +- internal/testing/apitests/operator_test.go | 76 ++++ .../testing/apitests}/structsync_test.go | 15 +- internal/testing/apitests/tasks_test.go | 171 ++++++++ internal/testing/apitests/util_test.go | 83 ++++ vendor/github.com/hashicorp/go-uuid/README.md | 2 +- vendor/github.com/hashicorp/go-uuid/go.mod | 1 + vendor/github.com/hashicorp/go-uuid/uuid.go | 24 +- vendor/vendor.json | 2 +- 27 files changed, 1311 insertions(+), 376 deletions(-) create mode 100644 api/internal/testutil/discover/discover.go create mode 100644 api/internal/testutil/freeport/freeport.go create mode 100644 api/internal/testutil/responsewriter.go create mode 100644 api/internal/testutil/server.go create mode 100644 api/internal/testutil/slow.go create mode 100644 api/internal/testutil/wait.go create mode 100644 internal/testing/apitests/api_test.go create mode 100644 internal/testing/apitests/jobs_test.go create mode 100644 internal/testing/apitests/nodes_test.go rename {api => internal/testing/apitests}/operator_autopilot_test.go (88%) create mode 100644 internal/testing/apitests/operator_test.go rename {api => internal/testing/apitests}/structsync_test.go (88%) create mode 100644 internal/testing/apitests/tasks_test.go create mode 100644 internal/testing/apitests/util_test.go create mode 100644 vendor/github.com/hashicorp/go-uuid/go.mod diff --git a/api/agent_test.go b/api/agent_test.go index b21390899..b8658ae08 100644 --- a/api/agent_test.go +++ b/api/agent_test.go @@ -5,7 +5,7 @@ import ( "sort" "testing" - "github.com/hashicorp/nomad/testutil" + "github.com/hashicorp/nomad/api/internal/testutil" "github.com/stretchr/testify/assert" ) diff --git a/api/allocations_test.go b/api/allocations_test.go index 267ce96a6..a18b7e147 100644 --- a/api/allocations_test.go +++ b/api/allocations_test.go @@ -7,7 +7,7 @@ import ( "time" - "github.com/hashicorp/nomad/helper/uuid" + "github.com/hashicorp/go-uuid" "github.com/stretchr/testify/require" ) @@ -146,12 +146,20 @@ func TestAllocations_RescheduleInfo(t *testing.T) { } job.Canonicalize() + uuidGen := func() string { + ret, err := uuid.GenerateUUID() + if err != nil { + t.Fatal(err) + } + return ret + } + alloc := &Allocation{ - ID: uuid.Generate(), + ID: uuidGen(), Namespace: DefaultNamespace, - EvalID: uuid.Generate(), + EvalID: uuidGen(), Name: "foo-bar[1]", - NodeID: uuid.Generate(), + NodeID: uuidGen(), TaskGroup: *job.TaskGroups[0].Name, JobID: *job.ID, Job: job, diff --git a/api/api_test.go b/api/api_test.go index 55cf17090..6313e5271 100644 --- a/api/api_test.go +++ b/api/api_test.go @@ -10,8 +10,8 @@ import ( "testing" "time" - "github.com/hashicorp/nomad/helper/uuid" - "github.com/hashicorp/nomad/testutil" + "github.com/hashicorp/go-uuid" + "github.com/hashicorp/nomad/api/internal/testutil" "github.com/stretchr/testify/assert" ) @@ -316,16 +316,24 @@ func TestQueryString(t *testing.T) { func TestClient_NodeClient(t *testing.T) { http := "testdomain:4646" tlsNode := func(string, *QueryOptions) (*Node, *QueryMeta, error) { + uu, err := uuid.GenerateUUID() + if err != nil { + t.Fatal(err) + } return &Node{ - ID: uuid.Generate(), + ID: uu, Status: "ready", HTTPAddr: http, TLSEnabled: true, }, nil, nil } noTlsNode := func(string, *QueryOptions) (*Node, *QueryMeta, error) { + uu, err := uuid.GenerateUUID() + if err != nil { + t.Fatal(err) + } return &Node{ - ID: uuid.Generate(), + ID: uu, Status: "ready", HTTPAddr: http, TLSEnabled: false, diff --git a/api/fs_test.go b/api/fs_test.go index bcf500720..a9e1efb0c 100644 --- a/api/fs_test.go +++ b/api/fs_test.go @@ -10,7 +10,7 @@ import ( "time" units "github.com/docker/go-units" - "github.com/hashicorp/nomad/testutil" + "github.com/hashicorp/nomad/api/internal/testutil" "github.com/kr/pretty" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" diff --git a/api/internal/testutil/discover/discover.go b/api/internal/testutil/discover/discover.go new file mode 100644 index 000000000..f385c3c25 --- /dev/null +++ b/api/internal/testutil/discover/discover.go @@ -0,0 +1,66 @@ +package discover + +import ( + "fmt" + "os" + "os/exec" + "path/filepath" + "runtime" + "strings" +) + +// Checks the current executable, then $GOPATH/bin, and finally the CWD, in that +// order. If it can't be found, an error is returned. +func NomadExecutable() (string, error) { + nomadExe := "nomad" + if runtime.GOOS == "windows" { + nomadExe = "nomad.exe" + } + + // Check the current executable. + bin, err := os.Executable() + if err != nil { + return "", fmt.Errorf("Failed to determine the nomad executable: %v", err) + } + + if _, err := os.Stat(bin); err == nil && isNomad(bin, nomadExe) { + return bin, nil + } + + // Check the $PATH + if bin, err := exec.LookPath(nomadExe); err == nil { + return bin, nil + } + + // Check the $GOPATH. + bin = filepath.Join(os.Getenv("GOPATH"), "bin", nomadExe) + if _, err := os.Stat(bin); err == nil { + return bin, nil + } + + // Check the CWD. + pwd, err := os.Getwd() + if err != nil { + return "", fmt.Errorf("Could not find Nomad executable (%v): %v", nomadExe, err) + } + + bin = filepath.Join(pwd, nomadExe) + if _, err := os.Stat(bin); err == nil { + return bin, nil + } + + // Check CWD/bin + bin = filepath.Join(pwd, "bin", nomadExe) + if _, err := os.Stat(bin); err == nil { + return bin, nil + } + + return "", fmt.Errorf("Could not find Nomad executable (%v)", nomadExe) +} + +func isNomad(path, nomadExe string) bool { + if strings.HasSuffix(path, ".test") || strings.HasSuffix(path, ".test.exe") { + return false + } + return true +} diff --git a/api/internal/testutil/freeport/freeport.go b/api/internal/testutil/freeport/freeport.go new file mode 100644 index 000000000..806449ba4 --- /dev/null +++ b/api/internal/testutil/freeport/freeport.go @@ -0,0 +1,139 @@ +// Package freeport provides a helper for allocating free ports across multiple +// processes on the same machine. +package freeport + +import ( + "fmt" + "math/rand" + "net" + "sync" + "time" + + "github.com/mitchellh/go-testing-interface" +) + +const ( + // blockSize is the size of the allocated port block. ports are given out + // consecutively from that block with roll-over for the lifetime of the + // application/test run. + blockSize = 1500 + + // maxBlocks is the number of available port blocks. + // lowPort + maxBlocks * blockSize must be less than 65535. + maxBlocks = 30 + + // lowPort is the lowest port number that should be used. + lowPort = 10000 + + // attempts is how often we try to allocate a port block + // before giving up. + attempts = 10 +) + +var ( + // firstPort is the first port of the allocated block. + firstPort int + + // lockLn is the system-wide mutex for the port block. + lockLn net.Listener + + // mu guards nextPort + mu sync.Mutex + + // once is used to do the initialization on the first call to retrieve free + // ports + once sync.Once + + // port is the last allocated port. + port int +) + +// initialize is used to initialize freeport. +func initialize() { + if lowPort+maxBlocks*blockSize > 65535 { + panic("freeport: block size too big or too many blocks requested") + } + + rand.Seed(time.Now().UnixNano()) + firstPort, lockLn = alloc() +} + +// alloc reserves a port block for exclusive use for the lifetime of the +// application. lockLn serves as a system-wide mutex for the port block and is +// implemented as a TCP listener which is bound to the firstPort and which will +// be automatically released when the application terminates. +func alloc() (int, net.Listener) { + for i := 0; i < attempts; i++ { + block := int(rand.Int31n(int32(maxBlocks))) + firstPort := lowPort + block*blockSize + ln, err := net.ListenTCP("tcp", tcpAddr("127.0.0.1", firstPort)) + if err != nil { + continue + } + // log.Printf("[DEBUG] freeport: allocated port block %d (%d-%d)", block, firstPort, firstPort+blockSize-1) + return firstPort, ln + } + panic("freeport: cannot allocate port block") +} + +func tcpAddr(ip string, port int) *net.TCPAddr { + return &net.TCPAddr{IP: net.ParseIP(ip), Port: port} +} + +// Get wraps the Free function and panics on any failure retrieving ports. +func Get(n int) (ports []int) { + ports, err := Free(n) + if err != nil { + panic(err) + } + + return ports +} + +// GetT is suitable for use when retrieving unused ports in tests. If there is +// an error retrieving free ports, the test will be failed. +func GetT(t testing.T, n int) (ports []int) { + ports, err := Free(n) + if err != nil { + t.Fatalf("Failed retrieving free port: %v", err) + } + + return ports +} + +// Free returns a list of free ports from the allocated port block. It is safe +// to call this method concurrently. Ports have been tested to be available on +// 127.0.0.1 TCP but there is no guarantee that they will remain free in the +// future. +func Free(n int) (ports []int, err error) { + mu.Lock() + defer mu.Unlock() + + if n > blockSize-1 { + return nil, fmt.Errorf("freeport: block size too small") + } + + // Reserve a port block + once.Do(initialize) + + for len(ports) < n { + port++ + + // roll-over the port + if port < firstPort+1 || port >= firstPort+blockSize { + port = firstPort + 1 + } + + // if the port is in use then skip it + ln, err := net.ListenTCP("tcp", tcpAddr("127.0.0.1", port)) + if err != nil { + // log.Println("[DEBUG] freeport: port already in use: ", port) + continue + } + ln.Close() + + ports = append(ports, port) + } + // log.Println("[DEBUG] freeport: free ports:", ports) + return ports, nil +} diff --git a/api/internal/testutil/responsewriter.go b/api/internal/testutil/responsewriter.go new file mode 100644 index 000000000..20bb38bb6 --- /dev/null +++ b/api/internal/testutil/responsewriter.go @@ -0,0 +1,76 @@ +package testutil + +import ( + "net/http" + "net/http/httptest" + "sync" +) + +// assert ResponseRecorder implements the http.ResponseWriter interface +var _ http.ResponseWriter = (*ResponseRecorder)(nil) + +// ResponseRecorder implements a ResponseWriter which can be written to and +// read from concurrently. For use in testing streaming APIs where +// httptest.ResponseRecorder is unsafe for concurrent access. Uses +// httptest.ResponseRecorder internally and exposes most of the functionality. +type ResponseRecorder struct { + rr *httptest.ResponseRecorder + mu sync.Mutex +} + +func NewResponseRecorder() *ResponseRecorder { + return &ResponseRecorder{ + rr: httptest.NewRecorder(), + } +} + +// Flush sets Flushed=true. +func (r *ResponseRecorder) Flush() { + r.mu.Lock() + defer r.mu.Unlock() + r.rr.Flush() +} + +// Flushed returns true if Flush has been called. +func (r *ResponseRecorder) Flushed() bool { + r.mu.Lock() + defer r.mu.Unlock() + return r.rr.Flushed +} + +// Header returns the response headers. Readers should call HeaderMap() to +// avoid races due to the server concurrently mutating headers. +func (r *ResponseRecorder) Header() http.Header { + r.mu.Lock() + defer r.mu.Unlock() + return r.rr.Header() +} + +// HeaderMap returns the HTTP headers written before WriteHeader was called. +func (r *ResponseRecorder) HeaderMap() http.Header { + r.mu.Lock() + defer r.mu.Unlock() + return r.rr.HeaderMap +} + +// Write to the underlying response buffer. Safe to call concurrent with Read. +func (r *ResponseRecorder) Write(p []byte) (int, error) { + r.mu.Lock() + defer r.mu.Unlock() + return r.rr.Body.Write(p) +} + +// WriteHeader sets the response code and freezes the headers returned by +// HeaderMap. Safe to call concurrent with Read and HeaderMap. +func (r *ResponseRecorder) WriteHeader(statusCode int) { + r.mu.Lock() + defer r.mu.Unlock() + r.rr.WriteHeader(statusCode) +} + +// Read available response bytes. Safe to call concurrently with Write(). +func (r *ResponseRecorder) Read(p []byte) (int, error) { + r.mu.Lock() + defer r.mu.Unlock() + return r.rr.Body.Read(p) +} diff --git a/api/internal/testutil/server.go b/api/internal/testutil/server.go new file mode 100644 index 000000000..b927e8e04 --- /dev/null +++ b/api/internal/testutil/server.go @@ -0,0 +1,378 @@ +package testutil + +// TestServer is a test helper. It uses a fork/exec model to create +// a test Nomad server instance in the background and initialize it +// with some data and/or services. The test server can then be used +// to run a unit test, and offers an easy API to tear itself down +// when the test has completed. The only prerequisite is to have a nomad +// binary available on the $PATH. +// +// This package does not use Nomad's official API client. This is +// because we use TestServer to test the API client, which would +// otherwise cause an import cycle. + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "net/http" + "os" + "os/exec" + + cleanhttp "github.com/hashicorp/go-cleanhttp" + "github.com/hashicorp/nomad/api/internal/testutil/discover" + "github.com/hashicorp/nomad/api/internal/testutil/freeport" + testing "github.com/mitchellh/go-testing-interface" +) + +// TestServerConfig is the main server configuration struct. +type TestServerConfig struct { + NodeName string `json:"name,omitempty"` + DataDir string `json:"data_dir,omitempty"` + Region string `json:"region,omitempty"` + DisableCheckpoint bool `json:"disable_update_check"` + LogLevel string `json:"log_level,omitempty"` + Consul *Consul `json:"consul,omitempty"` + AdvertiseAddrs *Advertise `json:"advertise,omitempty"` + Ports *PortsConfig `json:"ports,omitempty"` + Server *ServerConfig `json:"server,omitempty"` + Client *ClientConfig `json:"client,omitempty"` + Vault *VaultConfig `json:"vault,omitempty"` + ACL *ACLConfig `json:"acl,omitempty"` + DevMode bool `json:"-"` + Stdout, Stderr io.Writer `json:"-"` +} + +// Consul is used to configure the communication with Consul +type Consul struct { + Address string `json:"address,omitempty"` + Auth string `json:"auth,omitempty"` + Token string `json:"token,omitempty"` +} + +// Advertise is used to configure the addresses to advertise +type Advertise struct { + HTTP string `json:"http,omitempty"` + RPC string `json:"rpc,omitempty"` + Serf string `json:"serf,omitempty"` +} + +// PortsConfig is used to configure the network ports we use. +type PortsConfig struct { + HTTP int `json:"http,omitempty"` + RPC int `json:"rpc,omitempty"` + Serf int `json:"serf,omitempty"` +} + +// ServerConfig is used to configure the nomad server. +type ServerConfig struct { + Enabled bool `json:"enabled"` + BootstrapExpect int `json:"bootstrap_expect"` + RaftProtocol int `json:"raft_protocol,omitempty"` +} + +// ClientConfig is used to configure the client +type ClientConfig struct { + Enabled bool `json:"enabled"` +} + +// VaultConfig is used to configure Vault +type VaultConfig struct { + Enabled bool `json:"enabled"` +} + +// ACLConfig is used to configure ACLs +type ACLConfig struct { + Enabled bool `json:"enabled"` +} + +// ServerConfigCallback is a function interface which can be +// passed to NewTestServerConfig to modify the server config. +type ServerConfigCallback func(c *TestServerConfig) + +// defaultServerConfig returns a new TestServerConfig struct +// with all of the listen ports incremented by one. +func defaultServerConfig(t testing.T) *TestServerConfig { + ports := freeport.GetT(t, 3) + return &TestServerConfig{ + NodeName: fmt.Sprintf("node-%d", ports[0]), + DisableCheckpoint: true, + LogLevel: "DEBUG", + Ports: &PortsConfig{ + HTTP: ports[0], + RPC: ports[1], + Serf: ports[2], + }, + Server: &ServerConfig{ + Enabled: true, + BootstrapExpect: 1, + }, + Client: &ClientConfig{ + Enabled: false, + }, + Vault: &VaultConfig{ + Enabled: false, + }, + ACL: &ACLConfig{ + Enabled: false, + }, + } +} + +// TestServer is the main server wrapper struct. +type TestServer struct { + cmd *exec.Cmd + Config *TestServerConfig + t testing.T + + HTTPAddr string + SerfAddr string + HTTPClient *http.Client +} + +// NewTestServer creates a new TestServer, and makes a call to +// an optional callback function to modify the configuration. +func NewTestServer(t testing.T, cb ServerConfigCallback) *TestServer { + path, err := discover.NomadExecutable() + if err != nil { + t.Skipf("nomad not found, skipping: %v", err) + } + + // Do a sanity check that we are actually running nomad + vcmd := exec.Command(path, "-version") + vcmd.Stdout = nil + vcmd.Stderr = nil + if err := vcmd.Run(); err != nil { + t.Skipf("nomad version failed: %v", err) + } + + dataDir, err := ioutil.TempDir("", "nomad") + if err != nil { + t.Fatalf("err: %s", err) + } + + configFile, err := ioutil.TempFile(dataDir, "nomad") + if err != nil { + defer os.RemoveAll(dataDir) + t.Fatalf("err: %s", err) + } + defer configFile.Close() + + nomadConfig := defaultServerConfig(t) + nomadConfig.DataDir = dataDir + + if cb != nil { + cb(nomadConfig) + } + + configContent, err := json.Marshal(nomadConfig) + if err != nil { + t.Fatalf("err: %s", err) + } + + if _, err := configFile.Write(configContent); err != nil { + t.Fatalf("err: %s", err) + } + configFile.Close() + + stdout := io.Writer(os.Stdout) + if nomadConfig.Stdout != nil { + stdout = nomadConfig.Stdout + } + + stderr := io.Writer(os.Stderr) + if nomadConfig.Stderr != nil { + stderr = nomadConfig.Stderr + } + + args := []string{"agent", "-config", configFile.Name()} + if nomadConfig.DevMode { + args = append(args, "-dev") + } + + // Start the server + cmd := exec.Command(path, args...) + cmd.Stdout = stdout + cmd.Stderr = stderr + if err := cmd.Start(); err != nil { + t.Fatalf("err: %s", err) + } + + client := cleanhttp.DefaultClient() + + server := &TestServer{ + Config: nomadConfig, + cmd: cmd, + t: t, + + HTTPAddr: fmt.Sprintf("127.0.0.1:%d", nomadConfig.Ports.HTTP), + SerfAddr: fmt.Sprintf("127.0.0.1:%d", nomadConfig.Ports.Serf), + HTTPClient: client, + } + + // Wait for the server to be ready + if nomadConfig.Server.Enabled && nomadConfig.Server.BootstrapExpect != 0 { + server.waitForLeader() + } else { + server.waitForAPI() + } + + // Wait for the client to be ready + if nomadConfig.DevMode { + server.waitForClient() + } + return server +} + +// Stop stops the test Nomad server, and removes the Nomad data +// directory once we are done. +func (s *TestServer) Stop() { + defer os.RemoveAll(s.Config.DataDir) + + if err := s.cmd.Process.Kill(); err != nil { + s.t.Errorf("err: %s", err) + } + + // wait for the process to exit to be sure that the data dir can be + // deleted on all platforms. + s.cmd.Wait() +} + +// waitForAPI waits for only the agent HTTP endpoint to start +// responding. This is an indication that the agent has started, +// but will likely return before a leader is elected. +func (s *TestServer) waitForAPI() { + WaitForResult(func() (bool, error) { + // Using this endpoint as it is does not have restricted access + resp, err := s.HTTPClient.Get(s.url("/v1/metrics")) + if err != nil { + return false, err + } + defer resp.Body.Close() + if err := s.requireOK(resp); err != nil { + return false, err + } + return true, nil + }, func(err error) { + defer s.Stop() + s.t.Fatalf("err: %s", err) + }) +} + +// waitForLeader waits for the Nomad server's HTTP API to become +// available, and then waits for a known leader and an index of +// 1 or more to be observed to confirm leader election is done. +func (s *TestServer) waitForLeader() { + WaitForResult(func() (bool, error) { + // Query the API and check the status code + // Using this endpoint as it is does not have restricted access + resp, err := s.HTTPClient.Get(s.url("/v1/status/leader")) + if err != nil { + return false, err + } + defer resp.Body.Close() + if err := s.requireOK(resp); err != nil { + return false, err + } + + return true, nil + }, func(err error) { + defer s.Stop() + s.t.Fatalf("err: %s", err) + }) +} + +// waitForClient waits for the Nomad client to be ready. The function returns +// immediately if the server is not in dev mode. +func (s *TestServer) waitForClient() { + if !s.Config.DevMode { + return + } + + WaitForResult(func() (bool, error) { + resp, err := s.HTTPClient.Get(s.url("/v1/nodes")) + if err != nil { + return false, err + } + defer resp.Body.Close() + if err := s.requireOK(resp); err != nil { + return false, err + } + + var decoded []struct { + ID string + Status string + } + + dec := json.NewDecoder(resp.Body) + if err := dec.Decode(&decoded); err != nil { + return false, err + } + + if len(decoded) != 1 || decoded[0].Status != "ready" { + return false, fmt.Errorf("Node not ready: %v", decoded) + } + + return true, nil + }, func(err error) { + defer s.Stop() + s.t.Fatalf("err: %s", err) + }) +} + +// url is a helper function which takes a relative URL and +// makes it into a proper URL against the local Nomad server. +func (s *TestServer) url(path string) string { + return fmt.Sprintf("http://%s%s", s.HTTPAddr, path) +} + +// requireOK checks the HTTP response code and ensures it is acceptable. +func (s *TestServer) requireOK(resp *http.Response) error { + if resp.StatusCode != 200 { + return fmt.Errorf("Bad status code: %d", resp.StatusCode) + } + return nil +} + +// put performs a new HTTP PUT request. +func (s *TestServer) put(path string, body io.Reader) *http.Response { + req, err := http.NewRequest("PUT", s.url(path), body) + if err != nil { + s.t.Fatalf("err: %s", err) + } + resp, err := s.HTTPClient.Do(req) + if err != nil { + s.t.Fatalf("err: %s", err) + } + if err := s.requireOK(resp); err != nil { + defer resp.Body.Close() + s.t.Fatal(err) + } + return resp +} + +// get performs a new HTTP GET request. +func (s *TestServer) get(path string) *http.Response { + resp, err := s.HTTPClient.Get(s.url(path)) + if err != nil { + s.t.Fatalf("err: %s", err) + } + if err := s.requireOK(resp); err != nil { + defer resp.Body.Close() + s.t.Fatal(err) + } + return resp +} + +// encodePayload returns a new io.Reader wrapping the encoded contents +// of the payload, suitable for passing directly to a new request. +func (s *TestServer) encodePayload(payload interface{}) io.Reader { + var encoded bytes.Buffer + enc := json.NewEncoder(&encoded) + if err := enc.Encode(payload); err != nil { + s.t.Fatalf("err: %s", err) + } + return &encoded +} diff --git a/api/internal/testutil/slow.go b/api/internal/testutil/slow.go new file mode 100644 index 000000000..1a8088024 --- /dev/null +++ b/api/internal/testutil/slow.go @@ -0,0 +1,15 @@ +package testutil + +import ( + "os" + + testing "github.com/mitchellh/go-testing-interface" +) + +// SkipSlow skips a slow test unless the NOMAD_SLOW_TEST environment variable +// is set. +func SkipSlow(t testing.T) { + if os.Getenv("NOMAD_SLOW_TEST") == "" { + t.Skip("Skipping slow test. Set NOMAD_SLOW_TEST=1 to run.") + } +} diff --git a/api/internal/testutil/wait.go b/api/internal/testutil/wait.go new file mode 100644 index 000000000..dba69d2db --- /dev/null +++ b/api/internal/testutil/wait.go @@ -0,0 +1,74 @@ +package testutil + +import ( + "os" + "time" +) + +type testFn func() (bool, error) +type errorFn func(error) + +func WaitForResult(test testFn, error errorFn) { + WaitForResultRetries(500*TestMultiplier(), test, error) +} + +func WaitForResultRetries(retries int64, test testFn, error errorFn) { + for retries > 0 { + time.Sleep(10 * time.Millisecond) + retries-- + + success, err := test() + if success { + return + } + + if retries == 0 { + error(err) + } + } +} + +// AssertUntil asserts the test function passes throughout the given duration. +// Otherwise error is called on failure. +func AssertUntil(until time.Duration, test testFn, error errorFn) { + deadline := time.Now().Add(until) + for time.Now().Before(deadline) { + success, err := test() + if !success { + error(err) + return + } + // Sleep some arbitrary fraction of the deadline + time.Sleep(until / 30) + } +} + +// TestMultiplier returns a multiplier for retries and waits given environment +// the tests are being run under. +func TestMultiplier() int64 { + if IsCI() { + return 4 + } + + return 1 +} + +// Timeout takes the desired timeout and increases it if running in Travis +func Timeout(original time.Duration) time.Duration { + return original * time.Duration(TestMultiplier()) +} + +func IsCI() bool { + _, ok := os.LookupEnv("CI") + return ok +} + +func IsTravis() bool { + _, ok := os.LookupEnv("TRAVIS") + return ok +} + +func IsAppVeyor() bool { + _, ok := os.LookupEnv("APPVEYOR") + return ok +} diff --git a/api/jobs_test.go b/api/jobs_test.go index fbeb8fcf9..ee0ebfabb 100644 --- a/api/jobs_test.go +++ b/api/jobs_test.go @@ -7,10 +7,8 @@ import ( "testing" "time" - "github.com/hashicorp/nomad/nomad/mock" - "github.com/hashicorp/nomad/testutil" + "github.com/hashicorp/nomad/api/internal/testutil" "github.com/kr/pretty" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -46,43 +44,6 @@ func TestJobs_Register(t *testing.T) { } } -func TestJobs_Parse(t *testing.T) { - t.Parallel() - c, s := makeClient(t, nil, nil) - defer s.Stop() - - jobs := c.Jobs() - - checkJob := func(job *Job, expectedRegion string) { - if job == nil { - t.Fatal("job should not be nil") - } - - region := job.Region - - if region == nil { - if expectedRegion != "" { - t.Fatalf("expected job region to be '%s' but was unset", expectedRegion) - } - } else { - if expectedRegion != *region { - t.Fatalf("expected job region '%s', but got '%s'", expectedRegion, *region) - } - } - } - job, err := jobs.ParseHCL(mock.HCL(), true) - if err != nil { - t.Fatalf("err: %s", err) - } - checkJob(job, "global") - - job, err = jobs.ParseHCL(mock.HCL(), false) - if err != nil { - t.Fatalf("err: %s", err) - } - checkJob(job, "") -} - func TestJobs_Validate(t *testing.T) { t.Parallel() c, s := makeClient(t, nil, nil) @@ -1435,42 +1396,3 @@ func TestJobs_AddSpread(t *testing.T) { t.Fatalf("expect: %#v, got: %#v", expect, job.Spreads) } } - -func TestJobs_Summary_WithACL(t *testing.T) { - t.Parallel() - assert := assert.New(t) - - c, s, root := makeACLClient(t, nil, nil) - defer s.Stop() - jobs := c.Jobs() - - invalidToken := mock.ACLToken() - - // Registering with an invalid token should fail - c.SetSecretID(invalidToken.SecretID) - job := testJob() - _, _, err := jobs.Register(job, nil) - assert.NotNil(err) - - // Register with token should succeed - c.SetSecretID(root.SecretID) - resp2, wm, err := jobs.Register(job, nil) - assert.Nil(err) - assert.NotNil(resp2) - assert.NotEqual("", resp2.EvalID) - assertWriteMeta(t, wm) - - // Query the job summary with an invalid token should fail - c.SetSecretID(invalidToken.SecretID) - result, _, err := jobs.Summary(*job.ID, nil) - assert.NotNil(err) - - // Query the job summary with a valid token should succeed - c.SetSecretID(root.SecretID) - result, qm, err := jobs.Summary(*job.ID, nil) - assert.Nil(err) - assertQueryMeta(t, qm) - - // Check that the result is what we expect - assert.Equal(*job.ID, result.JobID) -} diff --git a/api/nodes_test.go b/api/nodes_test.go index 0541d05fb..4bf8c41b2 100644 --- a/api/nodes_test.go +++ b/api/nodes_test.go @@ -9,9 +9,7 @@ import ( "testing" "time" - "github.com/hashicorp/nomad/helper/uuid" - "github.com/hashicorp/nomad/nomad/structs" - "github.com/hashicorp/nomad/testutil" + "github.com/hashicorp/nomad/api/internal/testutil" "github.com/stretchr/testify/require" ) @@ -353,30 +351,6 @@ func TestNodes_Sort(t *testing.T) { } } -func TestNodes_GC(t *testing.T) { - t.Parallel() - require := require.New(t) - c, s := makeClient(t, nil, nil) - defer s.Stop() - nodes := c.Nodes() - - err := nodes.GC(uuid.Generate(), nil) - require.NotNil(err) - require.True(structs.IsErrUnknownNode(err)) -} - -func TestNodes_GcAlloc(t *testing.T) { - t.Parallel() - require := require.New(t) - c, s := makeClient(t, nil, nil) - defer s.Stop() - nodes := c.Nodes() - - err := nodes.GcAlloc(uuid.Generate(), nil) - require.NotNil(err) - require.True(structs.IsErrUnknownAllocation(err)) -} - // Unittest monitorDrainMultiplex when an error occurs func TestNodes_MonitorDrain_Multiplex_Bad(t *testing.T) { t.Parallel() diff --git a/api/operator_test.go b/api/operator_test.go index 8caa89e61..5b13fc66c 100644 --- a/api/operator_test.go +++ b/api/operator_test.go @@ -3,9 +3,6 @@ package api import ( "strings" "testing" - - "github.com/hashicorp/consul/testutil/retry" - "github.com/stretchr/testify/require" ) func TestOperator_RaftGetConfiguration(t *testing.T) { @@ -54,70 +51,3 @@ func TestOperator_RaftRemovePeerByID(t *testing.T) { t.Fatalf("err: %v", err) } } - -func TestAPI_OperatorSchedulerGetSetConfiguration(t *testing.T) { - t.Parallel() - require := require.New(t) - c, s := makeClient(t, nil, nil) - defer s.Stop() - - operator := c.Operator() - var config *SchedulerConfigurationResponse - retry.Run(t, func(r *retry.R) { - var err error - config, _, err = operator.SchedulerGetConfiguration(nil) - r.Check(err) - }) - require.True(config.SchedulerConfig.PreemptionConfig.SystemSchedulerEnabled) - - // Change a config setting - newConf := &SchedulerConfiguration{PreemptionConfig: PreemptionConfig{SystemSchedulerEnabled: false}} - resp, wm, err := operator.SchedulerSetConfiguration(newConf, nil) - require.Nil(err) - require.NotZero(wm.LastIndex) - require.False(resp.Updated) - - config, _, err = operator.SchedulerGetConfiguration(nil) - require.Nil(err) - require.False(config.SchedulerConfig.PreemptionConfig.SystemSchedulerEnabled) -} - -func TestAPI_OperatorSchedulerCASConfiguration(t *testing.T) { - t.Parallel() - require := require.New(t) - c, s := makeClient(t, nil, nil) - defer s.Stop() - - operator := c.Operator() - var config *SchedulerConfigurationResponse - retry.Run(t, func(r *retry.R) { - var err error - config, _, err = operator.SchedulerGetConfiguration(nil) - r.Check(err) - }) - require.True(config.SchedulerConfig.PreemptionConfig.SystemSchedulerEnabled) - - // Pass an invalid ModifyIndex - { - newConf := &SchedulerConfiguration{ - PreemptionConfig: PreemptionConfig{SystemSchedulerEnabled: false}, - ModifyIndex: config.SchedulerConfig.ModifyIndex - 1, - } - resp, wm, err := operator.SchedulerCASConfiguration(newConf, nil) - require.Nil(err) - require.NotZero(wm.LastIndex) - require.False(resp.Updated) - } - - // Pass a valid ModifyIndex - { - newConf := &SchedulerConfiguration{ - PreemptionConfig: PreemptionConfig{SystemSchedulerEnabled: false}, - ModifyIndex: config.SchedulerConfig.ModifyIndex, - } - resp, wm, err := operator.SchedulerCASConfiguration(newConf, nil) - require.Nil(err) - require.NotZero(wm.LastIndex) - require.True(resp.Updated) - } -} diff --git a/api/regions_test.go b/api/regions_test.go index 502ab4525..efa1d4871 100644 --- a/api/regions_test.go +++ b/api/regions_test.go @@ -4,7 +4,7 @@ import ( "fmt" "testing" - "github.com/hashicorp/nomad/testutil" + "github.com/hashicorp/nomad/api/internal/testutil" ) func TestRegionsList(t *testing.T) { diff --git a/api/tasks_test.go b/api/tasks_test.go index 92bd9f020..8ebea0585 100644 --- a/api/tasks_test.go +++ b/api/tasks_test.go @@ -6,7 +6,6 @@ import ( "testing" "time" - "github.com/hashicorp/nomad/nomad/structs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -392,167 +391,6 @@ func TestTaskGroup_Canonicalize_Update(t *testing.T) { assert.Nil(t, tg.Update) } -// Verifies that reschedule policy is merged correctly -func TestTaskGroup_Canonicalize_ReschedulePolicy(t *testing.T) { - type testCase struct { - desc string - jobReschedulePolicy *ReschedulePolicy - taskReschedulePolicy *ReschedulePolicy - expected *ReschedulePolicy - } - - testCases := []testCase{ - { - desc: "Default", - jobReschedulePolicy: nil, - taskReschedulePolicy: nil, - expected: &ReschedulePolicy{ - Attempts: intToPtr(structs.DefaultBatchJobReschedulePolicy.Attempts), - Interval: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Interval), - Delay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Delay), - DelayFunction: stringToPtr(structs.DefaultBatchJobReschedulePolicy.DelayFunction), - MaxDelay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.MaxDelay), - Unlimited: boolToPtr(structs.DefaultBatchJobReschedulePolicy.Unlimited), - }, - }, - { - desc: "Empty job reschedule policy", - jobReschedulePolicy: &ReschedulePolicy{ - Attempts: intToPtr(0), - Interval: timeToPtr(0), - Delay: timeToPtr(0), - MaxDelay: timeToPtr(0), - DelayFunction: stringToPtr(""), - Unlimited: boolToPtr(false), - }, - taskReschedulePolicy: nil, - expected: &ReschedulePolicy{ - Attempts: intToPtr(0), - Interval: timeToPtr(0), - Delay: timeToPtr(0), - MaxDelay: timeToPtr(0), - DelayFunction: stringToPtr(""), - Unlimited: boolToPtr(false), - }, - }, - { - desc: "Inherit from job", - jobReschedulePolicy: &ReschedulePolicy{ - Attempts: intToPtr(1), - Interval: timeToPtr(20 * time.Second), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(10 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - taskReschedulePolicy: nil, - expected: &ReschedulePolicy{ - Attempts: intToPtr(1), - Interval: timeToPtr(20 * time.Second), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(10 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - }, - { - desc: "Set in task", - jobReschedulePolicy: nil, - taskReschedulePolicy: &ReschedulePolicy{ - Attempts: intToPtr(5), - Interval: timeToPtr(2 * time.Minute), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(10 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - expected: &ReschedulePolicy{ - Attempts: intToPtr(5), - Interval: timeToPtr(2 * time.Minute), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(10 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - }, - { - desc: "Merge from job", - jobReschedulePolicy: &ReschedulePolicy{ - Attempts: intToPtr(1), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(10 * time.Minute), - }, - taskReschedulePolicy: &ReschedulePolicy{ - Interval: timeToPtr(5 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - expected: &ReschedulePolicy{ - Attempts: intToPtr(1), - Interval: timeToPtr(5 * time.Minute), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(10 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - }, - { - desc: "Override from group", - jobReschedulePolicy: &ReschedulePolicy{ - Attempts: intToPtr(1), - MaxDelay: timeToPtr(10 * time.Second), - }, - taskReschedulePolicy: &ReschedulePolicy{ - Attempts: intToPtr(5), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(20 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - expected: &ReschedulePolicy{ - Attempts: intToPtr(5), - Interval: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Interval), - Delay: timeToPtr(20 * time.Second), - MaxDelay: timeToPtr(20 * time.Minute), - DelayFunction: stringToPtr("constant"), - Unlimited: boolToPtr(false), - }, - }, - { - desc: "Attempts from job, default interval", - jobReschedulePolicy: &ReschedulePolicy{ - Attempts: intToPtr(1), - }, - taskReschedulePolicy: nil, - expected: &ReschedulePolicy{ - Attempts: intToPtr(1), - Interval: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Interval), - Delay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Delay), - DelayFunction: stringToPtr(structs.DefaultBatchJobReschedulePolicy.DelayFunction), - MaxDelay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.MaxDelay), - Unlimited: boolToPtr(structs.DefaultBatchJobReschedulePolicy.Unlimited), - }, - }, - } - - for _, tc := range testCases { - t.Run(tc.desc, func(t *testing.T) { - job := &Job{ - ID: stringToPtr("test"), - Reschedule: tc.jobReschedulePolicy, - Type: stringToPtr(JobTypeBatch), - } - job.Canonicalize() - tg := &TaskGroup{ - Name: stringToPtr("foo"), - ReschedulePolicy: tc.taskReschedulePolicy, - } - tg.Canonicalize(job) - assert.Equal(t, tc.expected, tg.ReschedulePolicy) - }) - } -} - // Verifies that migrate strategy is merged correctly func TestTaskGroup_Canonicalize_MigrateStrategy(t *testing.T) { type testCase struct { diff --git a/internal/testing/apitests/api_test.go b/internal/testing/apitests/api_test.go new file mode 100644 index 000000000..dcac8a63f --- /dev/null +++ b/internal/testing/apitests/api_test.go @@ -0,0 +1,56 @@ +package apitests + +import ( + "testing" + + "github.com/hashicorp/nomad/api" + "github.com/hashicorp/nomad/testutil" +) + +type configCallback func(c *api.Config) + +// seen is used to track which tests we have already marked as parallel +var seen map[*testing.T]struct{} + +func init() { + seen = make(map[*testing.T]struct{}) +} + +func makeACLClient(t *testing.T, cb1 configCallback, + cb2 testutil.ServerConfigCallback) (*api.Client, *testutil.TestServer, *api.ACLToken) { + client, server := makeClient(t, cb1, func(c *testutil.TestServerConfig) { + c.ACL.Enabled = true + if cb2 != nil { + cb2(c) + } + }) + + // Get the root token + root, _, err := client.ACLTokens().Bootstrap(nil) + if err != nil { + t.Fatalf("failed to bootstrap ACLs: %v", err) + } + client.SetSecretID(root.SecretID) + return client, server, root +} + +func makeClient(t *testing.T, cb1 configCallback, + cb2 testutil.ServerConfigCallback) (*api.Client, *testutil.TestServer) { + // Make client config + conf := api.DefaultConfig() + if cb1 != nil { + cb1(conf) + } + + // Create server + server := testutil.NewTestServer(t, cb2) + conf.Address = "http://" + server.HTTPAddr + + // Create client + client, err := api.NewClient(conf) + if err != nil { + t.Fatalf("err: %v", err) + } + + return client, server +} diff --git a/internal/testing/apitests/jobs_test.go b/internal/testing/apitests/jobs_test.go new file mode 100644 index 000000000..fd7001930 --- /dev/null +++ b/internal/testing/apitests/jobs_test.go @@ -0,0 +1,85 @@ +package apitests + +import ( + "testing" + + "github.com/hashicorp/nomad/api" + "github.com/hashicorp/nomad/nomad/mock" + "github.com/stretchr/testify/assert" +) + +func TestJobs_Parse(t *testing.T) { + t.Parallel() + c, s := makeClient(t, nil, nil) + defer s.Stop() + + jobs := c.Jobs() + + checkJob := func(job *api.Job, expectedRegion string) { + if job == nil { + t.Fatal("job should not be nil") + } + + region := job.Region + + if region == nil { + if expectedRegion != "" { + t.Fatalf("expected job region to be '%s' but was unset", expectedRegion) + } + } else { + if expectedRegion != *region { + t.Fatalf("expected job region '%s', but got '%s'", expectedRegion, *region) + } + } + } + job, err := jobs.ParseHCL(mock.HCL(), true) + if err != nil { + t.Fatalf("err: %s", err) + } + checkJob(job, "global") + + job, err = jobs.ParseHCL(mock.HCL(), false) + if err != nil { + t.Fatalf("err: %s", err) + } + checkJob(job, "") +} + +func TestJobs_Summary_WithACL(t *testing.T) { + t.Parallel() + assert := assert.New(t) + + c, s, root := makeACLClient(t, nil, nil) + defer s.Stop() + jobs := c.Jobs() + + invalidToken := mock.ACLToken() + + // Registering with an invalid token should fail + c.SetSecretID(invalidToken.SecretID) + job := testJob() + _, _, err := jobs.Register(job, nil) + assert.NotNil(err) + + // Register with token should succeed + c.SetSecretID(root.SecretID) + resp2, wm, err := jobs.Register(job, nil) + assert.Nil(err) + assert.NotNil(resp2) + assert.NotEqual("", resp2.EvalID) + assertWriteMeta(t, wm) + + // Query the job summary with an invalid token should fail + c.SetSecretID(invalidToken.SecretID) + result, _, err := jobs.Summary(*job.ID, nil) + assert.NotNil(err) + + // Query the job summary with a valid token should succeed + c.SetSecretID(root.SecretID) + result, qm, err := jobs.Summary(*job.ID, nil) + assert.Nil(err) + assertQueryMeta(t, qm) + + // Check that the result is what we expect + assert.Equal(*job.ID, result.JobID) +} diff --git a/internal/testing/apitests/nodes_test.go b/internal/testing/apitests/nodes_test.go new file mode 100644 index 000000000..2bc67b0c9 --- /dev/null +++ b/internal/testing/apitests/nodes_test.go @@ -0,0 +1,33 @@ +package apitests + +import ( + "testing" + + "github.com/hashicorp/nomad/helper/uuid" + "github.com/hashicorp/nomad/nomad/structs" + "github.com/stretchr/testify/require" +) + +func TestNodes_GC(t *testing.T) { + t.Parallel() + require := require.New(t) + c, s := makeClient(t, nil, nil) + defer s.Stop() + nodes := c.Nodes() + + err := nodes.GC(uuid.Generate(), nil) + require.NotNil(err) + require.True(structs.IsErrUnknownNode(err)) +} + +func TestNodes_GcAlloc(t *testing.T) { + t.Parallel() + require := require.New(t) + c, s := makeClient(t, nil, nil) + defer s.Stop() + nodes := c.Nodes() + + err := nodes.GcAlloc(uuid.Generate(), nil) + require.NotNil(err) + require.True(structs.IsErrUnknownAllocation(err)) +} diff --git a/api/operator_autopilot_test.go b/internal/testing/apitests/operator_autopilot_test.go similarity index 88% rename from api/operator_autopilot_test.go rename to internal/testing/apitests/operator_autopilot_test.go index fe2176a48..c1d45ca6d 100644 --- a/api/operator_autopilot_test.go +++ b/internal/testing/apitests/operator_autopilot_test.go @@ -1,4 +1,4 @@ -package api +package apitests import ( "testing" @@ -6,6 +6,7 @@ import ( "fmt" "github.com/hashicorp/consul/testutil/retry" + "github.com/hashicorp/nomad/api" "github.com/hashicorp/nomad/testutil" "github.com/stretchr/testify/require" ) @@ -17,7 +18,7 @@ func TestAPI_OperatorAutopilotGetSetConfiguration(t *testing.T) { defer s.Stop() operator := c.Operator() - var config *AutopilotConfiguration + var config *api.AutopilotConfiguration retry.Run(t, func(r *retry.R) { var err error config, _, err = operator.AutopilotGetConfiguration(nil) @@ -26,7 +27,7 @@ func TestAPI_OperatorAutopilotGetSetConfiguration(t *testing.T) { require.True(config.CleanupDeadServers) // Change a config setting - newConf := &AutopilotConfiguration{CleanupDeadServers: false} + newConf := &api.AutopilotConfiguration{CleanupDeadServers: false} _, err := operator.AutopilotSetConfiguration(newConf, nil) require.Nil(err) @@ -42,7 +43,7 @@ func TestAPI_OperatorAutopilotCASConfiguration(t *testing.T) { defer s.Stop() operator := c.Operator() - var config *AutopilotConfiguration + var config *api.AutopilotConfiguration retry.Run(t, func(r *retry.R) { var err error config, _, err = operator.AutopilotGetConfiguration(nil) @@ -52,7 +53,7 @@ func TestAPI_OperatorAutopilotCASConfiguration(t *testing.T) { // Pass an invalid ModifyIndex { - newConf := &AutopilotConfiguration{ + newConf := &api.AutopilotConfiguration{ CleanupDeadServers: false, ModifyIndex: config.ModifyIndex - 1, } @@ -63,7 +64,7 @@ func TestAPI_OperatorAutopilotCASConfiguration(t *testing.T) { // Pass a valid ModifyIndex { - newConf := &AutopilotConfiguration{ + newConf := &api.AutopilotConfiguration{ CleanupDeadServers: false, ModifyIndex: config.ModifyIndex, } diff --git a/internal/testing/apitests/operator_test.go b/internal/testing/apitests/operator_test.go new file mode 100644 index 000000000..636d8264b --- /dev/null +++ b/internal/testing/apitests/operator_test.go @@ -0,0 +1,76 @@ +package apitests + +import ( + "testing" + + "github.com/hashicorp/consul/testutil/retry" + "github.com/hashicorp/nomad/api" + "github.com/stretchr/testify/require" +) + +func TestAPI_OperatorSchedulerGetSetConfiguration(t *testing.T) { + t.Parallel() + require := require.New(t) + c, s := makeClient(t, nil, nil) + defer s.Stop() + + operator := c.Operator() + var config *api.SchedulerConfigurationResponse + retry.Run(t, func(r *retry.R) { + var err error + config, _, err = operator.SchedulerGetConfiguration(nil) + r.Check(err) + }) + require.True(config.SchedulerConfig.PreemptionConfig.SystemSchedulerEnabled) + + // Change a config setting + newConf := &api.SchedulerConfiguration{PreemptionConfig: api.PreemptionConfig{SystemSchedulerEnabled: false}} + resp, wm, err := operator.SchedulerSetConfiguration(newConf, nil) + require.Nil(err) + require.NotZero(wm.LastIndex) + require.False(resp.Updated) + + config, _, err = operator.SchedulerGetConfiguration(nil) + require.Nil(err) + require.False(config.SchedulerConfig.PreemptionConfig.SystemSchedulerEnabled) +} + +func TestAPI_OperatorSchedulerCASConfiguration(t *testing.T) { + t.Parallel() + require := require.New(t) + c, s := makeClient(t, nil, nil) + defer s.Stop() + + operator := c.Operator() + var config *api.SchedulerConfigurationResponse + retry.Run(t, func(r *retry.R) { + var err error + config, _, err = operator.SchedulerGetConfiguration(nil) + r.Check(err) + }) + require.True(config.SchedulerConfig.PreemptionConfig.SystemSchedulerEnabled) + + // Pass an invalid ModifyIndex + { + newConf := &api.SchedulerConfiguration{ + PreemptionConfig: api.PreemptionConfig{SystemSchedulerEnabled: false}, + ModifyIndex: config.SchedulerConfig.ModifyIndex - 1, + } + resp, wm, err := operator.SchedulerCASConfiguration(newConf, nil) + require.Nil(err) + require.NotZero(wm.LastIndex) + require.False(resp.Updated) + } + + // Pass a valid ModifyIndex + { + newConf := &api.SchedulerConfiguration{ + PreemptionConfig: api.PreemptionConfig{SystemSchedulerEnabled: false}, + ModifyIndex: config.SchedulerConfig.ModifyIndex, + } + resp, wm, err := operator.SchedulerCASConfiguration(newConf, nil) + require.Nil(err) + require.NotZero(wm.LastIndex) + require.True(resp.Updated) + } +} diff --git a/api/structsync_test.go b/internal/testing/apitests/structsync_test.go similarity index 88% rename from api/structsync_test.go rename to internal/testing/apitests/structsync_test.go index 2cb2ebc94..6a3858c41 100644 --- a/api/structsync_test.go +++ b/internal/testing/apitests/structsync_test.go @@ -1,9 +1,10 @@ -package api +package apitests import ( "encoding/json" "testing" + "github.com/hashicorp/nomad/api" "github.com/hashicorp/nomad/nomad/structs" "github.com/stretchr/testify/require" ) @@ -15,7 +16,7 @@ import ( // such dependency without affecting api clients. func TestDefaultResourcesAreInSync(t *testing.T) { - apiR := DefaultResources() + apiR := api.DefaultResources() structsR := structs.DefaultResources() require.EqualValues(t, *structsR, toStructsResource(t, apiR)) @@ -27,7 +28,7 @@ func TestDefaultResourcesAreInSync(t *testing.T) { } func TestMinResourcesAreInSync(t *testing.T) { - apiR := MinResources() + apiR := api.MinResources() structsR := structs.MinResources() require.EqualValues(t, *structsR, toStructsResource(t, apiR)) @@ -50,7 +51,7 @@ func TestNewDefaultRescheulePolicyInSync(t *testing.T) { for _, c := range cases { t.Run(c.typ, func(t *testing.T) { - apiP := NewDefaultReschedulePolicy(c.typ) + apiP := api.NewDefaultReschedulePolicy(c.typ) var found structs.ReschedulePolicy toStructs(t, &found, apiP) @@ -72,8 +73,8 @@ func TestNewDefaultRestartPolicyInSync(t *testing.T) { for _, c := range cases { t.Run(c.typ, func(t *testing.T) { - job := Job{Type: &c.typ} - var tg TaskGroup + job := api.Job{Type: &c.typ} + var tg api.TaskGroup tg.Canonicalize(&job) apiP := tg.RestartPolicy @@ -86,7 +87,7 @@ func TestNewDefaultRestartPolicyInSync(t *testing.T) { } } -func toStructsResource(t *testing.T, in *Resources) structs.Resources { +func toStructsResource(t *testing.T, in *api.Resources) structs.Resources { var out structs.Resources toStructs(t, &out, in) return out diff --git a/internal/testing/apitests/tasks_test.go b/internal/testing/apitests/tasks_test.go new file mode 100644 index 000000000..7c9a45d80 --- /dev/null +++ b/internal/testing/apitests/tasks_test.go @@ -0,0 +1,171 @@ +package apitests + +import ( + "testing" + "time" + + "github.com/hashicorp/nomad/api" + "github.com/hashicorp/nomad/nomad/structs" + "github.com/stretchr/testify/assert" +) + +// Verifies that reschedule policy is merged correctly +func TestTaskGroup_Canonicalize_ReschedulePolicy(t *testing.T) { + type testCase struct { + desc string + jobReschedulePolicy *api.ReschedulePolicy + taskReschedulePolicy *api.ReschedulePolicy + expected *api.ReschedulePolicy + } + + testCases := []testCase{ + { + desc: "Default", + jobReschedulePolicy: nil, + taskReschedulePolicy: nil, + expected: &api.ReschedulePolicy{ + Attempts: intToPtr(structs.DefaultBatchJobReschedulePolicy.Attempts), + Interval: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Interval), + Delay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Delay), + DelayFunction: stringToPtr(structs.DefaultBatchJobReschedulePolicy.DelayFunction), + MaxDelay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.MaxDelay), + Unlimited: boolToPtr(structs.DefaultBatchJobReschedulePolicy.Unlimited), + }, + }, + { + desc: "Empty job reschedule policy", + jobReschedulePolicy: &api.ReschedulePolicy{ + Attempts: intToPtr(0), + Interval: timeToPtr(0), + Delay: timeToPtr(0), + MaxDelay: timeToPtr(0), + DelayFunction: stringToPtr(""), + Unlimited: boolToPtr(false), + }, + taskReschedulePolicy: nil, + expected: &api.ReschedulePolicy{ + Attempts: intToPtr(0), + Interval: timeToPtr(0), + Delay: timeToPtr(0), + MaxDelay: timeToPtr(0), + DelayFunction: stringToPtr(""), + Unlimited: boolToPtr(false), + }, + }, + { + desc: "Inherit from job", + jobReschedulePolicy: &api.ReschedulePolicy{ + Attempts: intToPtr(1), + Interval: timeToPtr(20 * time.Second), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(10 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + taskReschedulePolicy: nil, + expected: &api.ReschedulePolicy{ + Attempts: intToPtr(1), + Interval: timeToPtr(20 * time.Second), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(10 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + }, + { + desc: "Set in task", + jobReschedulePolicy: nil, + taskReschedulePolicy: &api.ReschedulePolicy{ + Attempts: intToPtr(5), + Interval: timeToPtr(2 * time.Minute), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(10 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + expected: &api.ReschedulePolicy{ + Attempts: intToPtr(5), + Interval: timeToPtr(2 * time.Minute), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(10 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + }, + { + desc: "Merge from job", + jobReschedulePolicy: &api.ReschedulePolicy{ + Attempts: intToPtr(1), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(10 * time.Minute), + }, + taskReschedulePolicy: &api.ReschedulePolicy{ + Interval: timeToPtr(5 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + expected: &api.ReschedulePolicy{ + Attempts: intToPtr(1), + Interval: timeToPtr(5 * time.Minute), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(10 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + }, + { + desc: "Override from group", + jobReschedulePolicy: &api.ReschedulePolicy{ + Attempts: intToPtr(1), + MaxDelay: timeToPtr(10 * time.Second), + }, + taskReschedulePolicy: &api.ReschedulePolicy{ + Attempts: intToPtr(5), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(20 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + expected: &api.ReschedulePolicy{ + Attempts: intToPtr(5), + Interval: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Interval), + Delay: timeToPtr(20 * time.Second), + MaxDelay: timeToPtr(20 * time.Minute), + DelayFunction: stringToPtr("constant"), + Unlimited: boolToPtr(false), + }, + }, + { + desc: "Attempts from job, default interval", + jobReschedulePolicy: &api.ReschedulePolicy{ + Attempts: intToPtr(1), + }, + taskReschedulePolicy: nil, + expected: &api.ReschedulePolicy{ + Attempts: intToPtr(1), + Interval: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Interval), + Delay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.Delay), + DelayFunction: stringToPtr(structs.DefaultBatchJobReschedulePolicy.DelayFunction), + MaxDelay: timeToPtr(structs.DefaultBatchJobReschedulePolicy.MaxDelay), + Unlimited: boolToPtr(structs.DefaultBatchJobReschedulePolicy.Unlimited), + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + job := &api.Job{ + ID: stringToPtr("test"), + Reschedule: tc.jobReschedulePolicy, + Type: stringToPtr(api.JobTypeBatch), + } + job.Canonicalize() + tg := &api.TaskGroup{ + Name: stringToPtr("foo"), + ReschedulePolicy: tc.taskReschedulePolicy, + } + tg.Canonicalize(job) + assert.Equal(t, tc.expected, tg.ReschedulePolicy) + }) + } +} diff --git a/internal/testing/apitests/util_test.go b/internal/testing/apitests/util_test.go new file mode 100644 index 000000000..62941d36e --- /dev/null +++ b/internal/testing/apitests/util_test.go @@ -0,0 +1,83 @@ +package apitests + +import ( + "testing" + "time" + + "github.com/hashicorp/nomad/api" +) + +// boolToPtr returns the pointer to a boolean +func boolToPtr(b bool) *bool { + return &b +} + +// intToPtr returns the pointer to an int +func intToPtr(i int) *int { + return &i +} + +// timeToPtr returns the pointer to a time stamp +func timeToPtr(t time.Duration) *time.Duration { + return &t +} + +// stringToPtr returns the pointer to a string +func stringToPtr(str string) *string { + return &str +} + +func assertQueryMeta(t *testing.T, qm *api.QueryMeta) { + t.Helper() + if qm.LastIndex == 0 { + t.Fatalf("bad index: %d", qm.LastIndex) + } + if !qm.KnownLeader { + t.Fatalf("expected known leader, got none") + } +} + +func assertWriteMeta(t *testing.T, wm *api.WriteMeta) { + t.Helper() + if wm.LastIndex == 0 { + t.Fatalf("bad index: %d", wm.LastIndex) + } +} + +func testJob() *api.Job { + task := api.NewTask("task1", "exec"). + SetConfig("command", "/bin/sleep"). + Require(&api.Resources{ + CPU: intToPtr(100), + MemoryMB: intToPtr(256), + }). + SetLogConfig(&api.LogConfig{ + MaxFiles: intToPtr(1), + MaxFileSizeMB: intToPtr(2), + }) + + group := api.NewTaskGroup("group1", 1). + AddTask(task). + RequireDisk(&api.EphemeralDisk{ + SizeMB: intToPtr(25), + }) + + job := api.NewBatchJob("job1", "redis", "region1", 1). + AddDatacenter("dc1"). + AddTaskGroup(group) + + return job +} + +// conversions utils only used for testing +// added here to avoid linter warning + +// int64ToPtr returns the pointer to an int +func int64ToPtr(i int64) *int64 { + return &i +} + +// float64ToPtr returns the pointer to an float64 +func float64ToPtr(f float64) *float64 { + return &f +} diff --git a/vendor/github.com/hashicorp/go-uuid/README.md b/vendor/github.com/hashicorp/go-uuid/README.md index 02565c8c4..fbde8b9ae 100644 --- a/vendor/github.com/hashicorp/go-uuid/README.md +++ b/vendor/github.com/hashicorp/go-uuid/README.md @@ -1,6 +1,6 @@ # uuid [![Build Status](https://travis-ci.org/hashicorp/go-uuid.svg?branch=master)](https://travis-ci.org/hashicorp/go-uuid) -Generates UUID-format strings using high quality, purely random bytes. It can also parse UUID-format strings into their component bytes. +Generates UUID-format strings using high quality, _purely random_ bytes. It is **not** intended to be RFC compliant, merely to use a well-understood string representation of a 128-bit value. It can also parse UUID-format strings into their component bytes. Documentation ============= diff --git a/vendor/github.com/hashicorp/go-uuid/go.mod b/vendor/github.com/hashicorp/go-uuid/go.mod new file mode 100644 index 000000000..dd57f9d21 --- /dev/null +++ b/vendor/github.com/hashicorp/go-uuid/go.mod @@ -0,0 +1 @@ +module github.com/hashicorp/go-uuid diff --git a/vendor/github.com/hashicorp/go-uuid/uuid.go b/vendor/github.com/hashicorp/go-uuid/uuid.go index ff9364c40..911227f61 100644 --- a/vendor/github.com/hashicorp/go-uuid/uuid.go +++ b/vendor/github.com/hashicorp/go-uuid/uuid.go @@ -15,9 +15,11 @@ func GenerateRandomBytes(size int) ([]byte, error) { return buf, nil } +const uuidLen = 16 + // GenerateUUID is used to generate a random UUID func GenerateUUID() (string, error) { - buf, err := GenerateRandomBytes(16) + buf, err := GenerateRandomBytes(uuidLen) if err != nil { return "", err } @@ -25,11 +27,11 @@ func GenerateUUID() (string, error) { } func FormatUUID(buf []byte) (string, error) { - if len(buf) != 16 { - return "", fmt.Errorf("wrong length byte slice (%d)", len(buf)) + if buflen := len(buf); buflen != uuidLen { + return "", fmt.Errorf("wrong length byte slice (%d)", buflen) } - return fmt.Sprintf("%08x-%04x-%04x-%04x-%12x", + return fmt.Sprintf("%x-%x-%x-%x-%x", buf[0:4], buf[4:6], buf[6:8], @@ -38,16 +40,14 @@ func FormatUUID(buf []byte) (string, error) { } func ParseUUID(uuid string) ([]byte, error) { - if len(uuid) != 36 { + if len(uuid) != 2 * uuidLen + 4 { return nil, fmt.Errorf("uuid string is wrong length") } - hyph := []byte("-") - - if uuid[8] != hyph[0] || - uuid[13] != hyph[0] || - uuid[18] != hyph[0] || - uuid[23] != hyph[0] { + if uuid[8] != '-' || + uuid[13] != '-' || + uuid[18] != '-' || + uuid[23] != '-' { return nil, fmt.Errorf("uuid is improperly formatted") } @@ -57,7 +57,7 @@ func ParseUUID(uuid string) ([]byte, error) { if err != nil { return nil, err } - if len(ret) != 16 { + if len(ret) != uuidLen { return nil, fmt.Errorf("decoded hex is the wrong length") } diff --git a/vendor/vendor.json b/vendor/vendor.json index f8f968d03..e742b8cfe 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -200,7 +200,7 @@ {"path":"github.com/hashicorp/go-sockaddr","checksumSHA1":"J47ySO1q0gcnmoMnir1q1loKzCk=","revision":"6d291a969b86c4b633730bfc6b8b9d64c3aafed9","revisionTime":"2018-03-20T11:50:54Z"}, {"path":"github.com/hashicorp/go-sockaddr/template","checksumSHA1":"PDp9DVLvf3KWxhs4G4DpIwauMSU=","revision":"6d291a969b86c4b633730bfc6b8b9d64c3aafed9","revisionTime":"2018-03-20T11:50:54Z"}, {"path":"github.com/hashicorp/go-syslog","checksumSHA1":"xZ7Ban1x//6uUIU1xtrTbCYNHBc=","revision":"42a2b573b664dbf281bd48c3cc12c086b17a39ba"}, - {"path":"github.com/hashicorp/go-uuid","checksumSHA1":"mAkPa/RLuIwN53GbwIEMATexams=","revision":"64130c7a86d732268a38cb04cfbaf0cc987fda98","revisionTime":"2016-07-17T02:21:40Z"}, + {"path":"github.com/hashicorp/go-uuid","checksumSHA1":"5AxXPtBqAKyFGcttFzxT5hp/3Tk=","revision":"4f571afc59f3043a65f8fe6bf46d887b10a01d43","revisionTime":"2018-11-28T13:14:45Z"}, {"path":"github.com/hashicorp/go-version","checksumSHA1":"r0pj5dMHCghpaQZ3f1BRGoKiSWw=","revision":"b5a281d3160aa11950a6182bd9a9dc2cb1e02d50","revisionTime":"2018-08-24T00:43:55Z"}, {"path":"github.com/hashicorp/golang-lru","checksumSHA1":"d9PxF1XQGLMJZRct2R8qVM/eYlE=","revision":"a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4","revisionTime":"2016-02-07T21:47:19Z"}, {"path":"github.com/hashicorp/golang-lru/simplelru","checksumSHA1":"2nOpYjx8Sn57bqlZq17yM4YJuM4=","revision":"a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"},