github.com/kardianos/nomad@v0.1.3-0.20151022182107-b13df73ee850/command/agent/node_endpoint_test.go (about)

     1  package agent
     2  
     3  import (
     4  	"net/http"
     5  	"net/http/httptest"
     6  	"testing"
     7  
     8  	"github.com/hashicorp/nomad/nomad/mock"
     9  	"github.com/hashicorp/nomad/nomad/structs"
    10  )
    11  
    12  func TestHTTP_NodesList(t *testing.T) {
    13  	httpTest(t, nil, func(s *TestServer) {
    14  		for i := 0; i < 3; i++ {
    15  			// Create the node
    16  			node := mock.Node()
    17  			args := structs.NodeRegisterRequest{
    18  				Node:         node,
    19  				WriteRequest: structs.WriteRequest{Region: "global"},
    20  			}
    21  			var resp structs.NodeUpdateResponse
    22  			if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
    23  				t.Fatalf("err: %v", err)
    24  			}
    25  		}
    26  
    27  		// Make the HTTP request
    28  		req, err := http.NewRequest("GET", "/v1/nodes", nil)
    29  		if err != nil {
    30  			t.Fatalf("err: %v", err)
    31  		}
    32  		respW := httptest.NewRecorder()
    33  
    34  		// Make the request
    35  		obj, err := s.Server.NodesRequest(respW, req)
    36  		if err != nil {
    37  			t.Fatalf("err: %v", err)
    38  		}
    39  
    40  		// Check for the index
    41  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
    42  			t.Fatalf("missing index")
    43  		}
    44  		if respW.HeaderMap.Get("X-Nomad-KnownLeader") != "true" {
    45  			t.Fatalf("missing known leader")
    46  		}
    47  		if respW.HeaderMap.Get("X-Nomad-LastContact") == "" {
    48  			t.Fatalf("missing last contact")
    49  		}
    50  
    51  		// Check the job
    52  		n := obj.([]*structs.NodeListStub)
    53  		if len(n) < 3 { // Maybe 4 including client
    54  			t.Fatalf("bad: %#v", n)
    55  		}
    56  	})
    57  }
    58  
    59  func TestHTTP_NodeForceEval(t *testing.T) {
    60  	httpTest(t, nil, func(s *TestServer) {
    61  		// Create the node
    62  		node := mock.Node()
    63  		args := structs.NodeRegisterRequest{
    64  			Node:         node,
    65  			WriteRequest: structs.WriteRequest{Region: "global"},
    66  		}
    67  		var resp structs.NodeUpdateResponse
    68  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
    69  			t.Fatalf("err: %v", err)
    70  		}
    71  
    72  		// Directly manipulate the state
    73  		state := s.Agent.server.State()
    74  		alloc1 := mock.Alloc()
    75  		alloc1.NodeID = node.ID
    76  		err := state.UpsertAllocs(1000, []*structs.Allocation{alloc1})
    77  		if err != nil {
    78  			t.Fatalf("err: %v", err)
    79  		}
    80  
    81  		// Make the HTTP request
    82  		req, err := http.NewRequest("POST", "/v1/node/"+node.ID+"/evaluate", nil)
    83  		if err != nil {
    84  			t.Fatalf("err: %v", err)
    85  		}
    86  		respW := httptest.NewRecorder()
    87  
    88  		// Make the request
    89  		obj, err := s.Server.NodeSpecificRequest(respW, req)
    90  		if err != nil {
    91  			t.Fatalf("err: %v", err)
    92  		}
    93  
    94  		// Check for the index
    95  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
    96  			t.Fatalf("missing index")
    97  		}
    98  
    99  		// Check the response
   100  		upd := obj.(structs.NodeUpdateResponse)
   101  		if len(upd.EvalIDs) == 0 {
   102  			t.Fatalf("bad: %v", upd)
   103  		}
   104  	})
   105  }
   106  
   107  func TestHTTP_NodeAllocations(t *testing.T) {
   108  	httpTest(t, nil, func(s *TestServer) {
   109  		// Create the job
   110  		node := mock.Node()
   111  		args := structs.NodeRegisterRequest{
   112  			Node:         node,
   113  			WriteRequest: structs.WriteRequest{Region: "global"},
   114  		}
   115  		var resp structs.NodeUpdateResponse
   116  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
   117  			t.Fatalf("err: %v", err)
   118  		}
   119  
   120  		// Directly manipulate the state
   121  		state := s.Agent.server.State()
   122  		alloc1 := mock.Alloc()
   123  		alloc1.NodeID = node.ID
   124  		err := state.UpsertAllocs(1000, []*structs.Allocation{alloc1})
   125  		if err != nil {
   126  			t.Fatalf("err: %v", err)
   127  		}
   128  
   129  		// Make the HTTP request
   130  		req, err := http.NewRequest("GET", "/v1/node/"+node.ID+"/allocations", nil)
   131  		if err != nil {
   132  			t.Fatalf("err: %v", err)
   133  		}
   134  		respW := httptest.NewRecorder()
   135  
   136  		// Make the request
   137  		obj, err := s.Server.NodeSpecificRequest(respW, req)
   138  		if err != nil {
   139  			t.Fatalf("err: %v", err)
   140  		}
   141  
   142  		// Check for the index
   143  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
   144  			t.Fatalf("missing index")
   145  		}
   146  		if respW.HeaderMap.Get("X-Nomad-KnownLeader") != "true" {
   147  			t.Fatalf("missing known leader")
   148  		}
   149  		if respW.HeaderMap.Get("X-Nomad-LastContact") == "" {
   150  			t.Fatalf("missing last contact")
   151  		}
   152  
   153  		// Check the node
   154  		allocs := obj.([]*structs.Allocation)
   155  		if len(allocs) != 1 || allocs[0].ID != alloc1.ID {
   156  			t.Fatalf("bad: %#v", allocs)
   157  		}
   158  	})
   159  }
   160  
   161  func TestHTTP_NodeDrain(t *testing.T) {
   162  	httpTest(t, nil, func(s *TestServer) {
   163  		// Create the node
   164  		node := mock.Node()
   165  		args := structs.NodeRegisterRequest{
   166  			Node:         node,
   167  			WriteRequest: structs.WriteRequest{Region: "global"},
   168  		}
   169  		var resp structs.NodeUpdateResponse
   170  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
   171  			t.Fatalf("err: %v", err)
   172  		}
   173  
   174  		// Directly manipulate the state
   175  		state := s.Agent.server.State()
   176  		alloc1 := mock.Alloc()
   177  		alloc1.NodeID = node.ID
   178  		err := state.UpsertAllocs(1000, []*structs.Allocation{alloc1})
   179  		if err != nil {
   180  			t.Fatalf("err: %v", err)
   181  		}
   182  
   183  		// Make the HTTP request
   184  		req, err := http.NewRequest("POST", "/v1/node/"+node.ID+"/drain?enable=1", nil)
   185  		if err != nil {
   186  			t.Fatalf("err: %v", err)
   187  		}
   188  		respW := httptest.NewRecorder()
   189  
   190  		// Make the request
   191  		obj, err := s.Server.NodeSpecificRequest(respW, req)
   192  		if err != nil {
   193  			t.Fatalf("err: %v", err)
   194  		}
   195  
   196  		// Check for the index
   197  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
   198  			t.Fatalf("missing index")
   199  		}
   200  
   201  		// Check the response
   202  		upd := obj.(structs.NodeDrainUpdateResponse)
   203  		if len(upd.EvalIDs) == 0 {
   204  			t.Fatalf("bad: %v", upd)
   205  		}
   206  	})
   207  }
   208  
   209  func TestHTTP_NodeQuery(t *testing.T) {
   210  	httpTest(t, nil, func(s *TestServer) {
   211  		// Create the job
   212  		node := mock.Node()
   213  		args := structs.NodeRegisterRequest{
   214  			Node:         node,
   215  			WriteRequest: structs.WriteRequest{Region: "global"},
   216  		}
   217  		var resp structs.NodeUpdateResponse
   218  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
   219  			t.Fatalf("err: %v", err)
   220  		}
   221  
   222  		// Make the HTTP request
   223  		req, err := http.NewRequest("GET", "/v1/node/"+node.ID, nil)
   224  		if err != nil {
   225  			t.Fatalf("err: %v", err)
   226  		}
   227  		respW := httptest.NewRecorder()
   228  
   229  		// Make the request
   230  		obj, err := s.Server.NodeSpecificRequest(respW, req)
   231  		if err != nil {
   232  			t.Fatalf("err: %v", err)
   233  		}
   234  
   235  		// Check for the index
   236  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
   237  			t.Fatalf("missing index")
   238  		}
   239  		if respW.HeaderMap.Get("X-Nomad-KnownLeader") != "true" {
   240  			t.Fatalf("missing known leader")
   241  		}
   242  		if respW.HeaderMap.Get("X-Nomad-LastContact") == "" {
   243  			t.Fatalf("missing last contact")
   244  		}
   245  
   246  		// Check the node
   247  		n := obj.(*structs.Node)
   248  		if n.ID != node.ID {
   249  			t.Fatalf("bad: %#v", n)
   250  		}
   251  	})
   252  }