github.com/diptanu/nomad@v0.5.7-0.20170516172507-d72e86cbe3d9/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 nodes
    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_NodesPrefixList(t *testing.T) {
    60  	httpTest(t, nil, func(s *TestServer) {
    61  		ids := []string{
    62  			"12345678-abcd-efab-cdef-123456789abc",
    63  			"12345678-aaaa-efab-cdef-123456789abc",
    64  			"1234aaaa-abcd-efab-cdef-123456789abc",
    65  			"1234bbbb-abcd-efab-cdef-123456789abc",
    66  			"1234cccc-abcd-efab-cdef-123456789abc",
    67  			"1234dddd-abcd-efab-cdef-123456789abc",
    68  		}
    69  		for i := 0; i < 5; i++ {
    70  			// Create the node
    71  			node := mock.Node()
    72  			node.ID = ids[i]
    73  			args := structs.NodeRegisterRequest{
    74  				Node:         node,
    75  				WriteRequest: structs.WriteRequest{Region: "global"},
    76  			}
    77  			var resp structs.NodeUpdateResponse
    78  			if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
    79  				t.Fatalf("err: %v", err)
    80  			}
    81  		}
    82  
    83  		// Make the HTTP request
    84  		req, err := http.NewRequest("GET", "/v1/nodes?prefix=12345678", nil)
    85  		if err != nil {
    86  			t.Fatalf("err: %v", err)
    87  		}
    88  		respW := httptest.NewRecorder()
    89  
    90  		// Make the request
    91  		obj, err := s.Server.NodesRequest(respW, req)
    92  		if err != nil {
    93  			t.Fatalf("err: %v", err)
    94  		}
    95  
    96  		// Check for the index
    97  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
    98  			t.Fatalf("missing index")
    99  		}
   100  		if respW.HeaderMap.Get("X-Nomad-KnownLeader") != "true" {
   101  			t.Fatalf("missing known leader")
   102  		}
   103  		if respW.HeaderMap.Get("X-Nomad-LastContact") == "" {
   104  			t.Fatalf("missing last contact")
   105  		}
   106  
   107  		// Check the nodes
   108  		n := obj.([]*structs.NodeListStub)
   109  		if len(n) != 2 {
   110  			t.Fatalf("bad: %#v", n)
   111  		}
   112  	})
   113  }
   114  
   115  func TestHTTP_NodeForceEval(t *testing.T) {
   116  	httpTest(t, nil, func(s *TestServer) {
   117  		// Create the node
   118  		node := mock.Node()
   119  		args := structs.NodeRegisterRequest{
   120  			Node:         node,
   121  			WriteRequest: structs.WriteRequest{Region: "global"},
   122  		}
   123  		var resp structs.NodeUpdateResponse
   124  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
   125  			t.Fatalf("err: %v", err)
   126  		}
   127  
   128  		// Directly manipulate the state
   129  		state := s.Agent.server.State()
   130  		alloc1 := mock.Alloc()
   131  		alloc1.NodeID = node.ID
   132  		if err := state.UpsertJobSummary(999, mock.JobSummary(alloc1.JobID)); err != nil {
   133  			t.Fatal(err)
   134  		}
   135  		err := state.UpsertAllocs(1000, []*structs.Allocation{alloc1})
   136  		if err != nil {
   137  			t.Fatalf("err: %v", err)
   138  		}
   139  
   140  		// Make the HTTP request
   141  		req, err := http.NewRequest("POST", "/v1/node/"+node.ID+"/evaluate", nil)
   142  		if err != nil {
   143  			t.Fatalf("err: %v", err)
   144  		}
   145  		respW := httptest.NewRecorder()
   146  
   147  		// Make the request
   148  		obj, err := s.Server.NodeSpecificRequest(respW, req)
   149  		if err != nil {
   150  			t.Fatalf("err: %v", err)
   151  		}
   152  
   153  		// Check for the index
   154  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
   155  			t.Fatalf("missing index")
   156  		}
   157  
   158  		// Check the response
   159  		upd := obj.(structs.NodeUpdateResponse)
   160  		if len(upd.EvalIDs) == 0 {
   161  			t.Fatalf("bad: %v", upd)
   162  		}
   163  	})
   164  }
   165  
   166  func TestHTTP_NodeAllocations(t *testing.T) {
   167  	httpTest(t, nil, func(s *TestServer) {
   168  		// Create the job
   169  		node := mock.Node()
   170  		args := structs.NodeRegisterRequest{
   171  			Node:         node,
   172  			WriteRequest: structs.WriteRequest{Region: "global"},
   173  		}
   174  		var resp structs.NodeUpdateResponse
   175  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
   176  			t.Fatalf("err: %v", err)
   177  		}
   178  
   179  		// Directly manipulate the state
   180  		state := s.Agent.server.State()
   181  		alloc1 := mock.Alloc()
   182  		alloc1.NodeID = node.ID
   183  		if err := state.UpsertJobSummary(999, mock.JobSummary(alloc1.JobID)); err != nil {
   184  			t.Fatal(err)
   185  		}
   186  		err := state.UpsertAllocs(1000, []*structs.Allocation{alloc1})
   187  		if err != nil {
   188  			t.Fatalf("err: %v", err)
   189  		}
   190  
   191  		// Make the HTTP request
   192  		req, err := http.NewRequest("GET", "/v1/node/"+node.ID+"/allocations", nil)
   193  		if err != nil {
   194  			t.Fatalf("err: %v", err)
   195  		}
   196  		respW := httptest.NewRecorder()
   197  
   198  		// Make the request
   199  		obj, err := s.Server.NodeSpecificRequest(respW, req)
   200  		if err != nil {
   201  			t.Fatalf("err: %v", err)
   202  		}
   203  
   204  		// Check for the index
   205  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
   206  			t.Fatalf("missing index")
   207  		}
   208  		if respW.HeaderMap.Get("X-Nomad-KnownLeader") != "true" {
   209  			t.Fatalf("missing known leader")
   210  		}
   211  		if respW.HeaderMap.Get("X-Nomad-LastContact") == "" {
   212  			t.Fatalf("missing last contact")
   213  		}
   214  
   215  		// Check the node
   216  		allocs := obj.([]*structs.Allocation)
   217  		if len(allocs) != 1 || allocs[0].ID != alloc1.ID {
   218  			t.Fatalf("bad: %#v", allocs)
   219  		}
   220  	})
   221  }
   222  
   223  func TestHTTP_NodeDrain(t *testing.T) {
   224  	httpTest(t, nil, func(s *TestServer) {
   225  		// Create the node
   226  		node := mock.Node()
   227  		args := structs.NodeRegisterRequest{
   228  			Node:         node,
   229  			WriteRequest: structs.WriteRequest{Region: "global"},
   230  		}
   231  		var resp structs.NodeUpdateResponse
   232  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
   233  			t.Fatalf("err: %v", err)
   234  		}
   235  
   236  		// Directly manipulate the state
   237  		state := s.Agent.server.State()
   238  		alloc1 := mock.Alloc()
   239  		alloc1.NodeID = node.ID
   240  		if err := state.UpsertJobSummary(999, mock.JobSummary(alloc1.JobID)); err != nil {
   241  			t.Fatal(err)
   242  		}
   243  		err := state.UpsertAllocs(1000, []*structs.Allocation{alloc1})
   244  		if err != nil {
   245  			t.Fatalf("err: %v", err)
   246  		}
   247  
   248  		// Make the HTTP request
   249  		req, err := http.NewRequest("POST", "/v1/node/"+node.ID+"/drain?enable=1", nil)
   250  		if err != nil {
   251  			t.Fatalf("err: %v", err)
   252  		}
   253  		respW := httptest.NewRecorder()
   254  
   255  		// Make the request
   256  		obj, err := s.Server.NodeSpecificRequest(respW, req)
   257  		if err != nil {
   258  			t.Fatalf("err: %v", err)
   259  		}
   260  
   261  		// Check for the index
   262  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
   263  			t.Fatalf("missing index")
   264  		}
   265  
   266  		// Check the response
   267  		upd := obj.(structs.NodeDrainUpdateResponse)
   268  		if len(upd.EvalIDs) == 0 {
   269  			t.Fatalf("bad: %v", upd)
   270  		}
   271  	})
   272  }
   273  
   274  func TestHTTP_NodeQuery(t *testing.T) {
   275  	httpTest(t, nil, func(s *TestServer) {
   276  		// Create the job
   277  		node := mock.Node()
   278  		args := structs.NodeRegisterRequest{
   279  			Node:         node,
   280  			WriteRequest: structs.WriteRequest{Region: "global"},
   281  		}
   282  		var resp structs.NodeUpdateResponse
   283  		if err := s.Agent.RPC("Node.Register", &args, &resp); err != nil {
   284  			t.Fatalf("err: %v", err)
   285  		}
   286  
   287  		// Make the HTTP request
   288  		req, err := http.NewRequest("GET", "/v1/node/"+node.ID, nil)
   289  		if err != nil {
   290  			t.Fatalf("err: %v", err)
   291  		}
   292  		respW := httptest.NewRecorder()
   293  
   294  		// Make the request
   295  		obj, err := s.Server.NodeSpecificRequest(respW, req)
   296  		if err != nil {
   297  			t.Fatalf("err: %v", err)
   298  		}
   299  
   300  		// Check for the index
   301  		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
   302  			t.Fatalf("missing index")
   303  		}
   304  		if respW.HeaderMap.Get("X-Nomad-KnownLeader") != "true" {
   305  			t.Fatalf("missing known leader")
   306  		}
   307  		if respW.HeaderMap.Get("X-Nomad-LastContact") == "" {
   308  			t.Fatalf("missing last contact")
   309  		}
   310  
   311  		// Check the node
   312  		n := obj.(*structs.Node)
   313  		if n.ID != node.ID {
   314  			t.Fatalf("bad: %#v", n)
   315  		}
   316  	})
   317  }