github.com/blixtra/nomad@v0.7.2-0.20171221000451-da9a1d7bb050/command/agent/search_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  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestHTTP_SearchWithIllegalMethod(t *testing.T) {
    14  	assert := assert.New(t)
    15  	t.Parallel()
    16  	httpTest(t, nil, func(s *TestAgent) {
    17  		req, err := http.NewRequest("DELETE", "/v1/search", nil)
    18  		assert.Nil(err)
    19  		respW := httptest.NewRecorder()
    20  
    21  		_, err = s.Server.SearchRequest(respW, req)
    22  		assert.NotNil(err, "HTTP DELETE should not be accepted for this endpoint")
    23  	})
    24  }
    25  
    26  func createJobForTest(jobID string, s *TestAgent, t *testing.T) {
    27  	assert := assert.New(t)
    28  
    29  	job := mock.Job()
    30  	job.ID = jobID
    31  	job.TaskGroups[0].Count = 1
    32  
    33  	state := s.Agent.server.State()
    34  	err := state.UpsertJob(1000, job)
    35  	assert.Nil(err)
    36  }
    37  
    38  func TestHTTP_Search_POST(t *testing.T) {
    39  	assert := assert.New(t)
    40  
    41  	testJob := "aaaaaaaa-e8f7-fd38-c855-ab94ceb89706"
    42  	testJobPrefix := "aaaaaaaa-e8f7-fd38"
    43  	t.Parallel()
    44  	httpTest(t, nil, func(s *TestAgent) {
    45  		createJobForTest(testJob, s, t)
    46  
    47  		data := structs.SearchRequest{Prefix: testJobPrefix, Context: structs.Jobs}
    48  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
    49  		assert.Nil(err)
    50  
    51  		respW := httptest.NewRecorder()
    52  
    53  		resp, err := s.Server.SearchRequest(respW, req)
    54  		assert.Nil(err)
    55  
    56  		res := resp.(structs.SearchResponse)
    57  
    58  		assert.Equal(1, len(res.Matches))
    59  
    60  		j := res.Matches[structs.Jobs]
    61  
    62  		assert.Equal(1, len(j))
    63  		assert.Equal(j[0], testJob)
    64  
    65  		assert.Equal(res.Truncations[structs.Jobs], false)
    66  		assert.NotEqual("0", respW.HeaderMap.Get("X-Nomad-Index"))
    67  	})
    68  }
    69  
    70  func TestHTTP_Search_PUT(t *testing.T) {
    71  	assert := assert.New(t)
    72  
    73  	testJob := "aaaaaaaa-e8f7-fd38-c855-ab94ceb89706"
    74  	testJobPrefix := "aaaaaaaa-e8f7-fd38"
    75  	t.Parallel()
    76  	httpTest(t, nil, func(s *TestAgent) {
    77  		createJobForTest(testJob, s, t)
    78  
    79  		data := structs.SearchRequest{Prefix: testJobPrefix, Context: structs.Jobs}
    80  		req, err := http.NewRequest("PUT", "/v1/search", encodeReq(data))
    81  		assert.Nil(err)
    82  
    83  		respW := httptest.NewRecorder()
    84  
    85  		resp, err := s.Server.SearchRequest(respW, req)
    86  		assert.Nil(err)
    87  
    88  		res := resp.(structs.SearchResponse)
    89  
    90  		assert.Equal(1, len(res.Matches))
    91  
    92  		j := res.Matches[structs.Jobs]
    93  
    94  		assert.Equal(1, len(j))
    95  		assert.Equal(j[0], testJob)
    96  
    97  		assert.Equal(res.Truncations[structs.Jobs], false)
    98  		assert.NotEqual("0", respW.HeaderMap.Get("X-Nomad-Index"))
    99  	})
   100  }
   101  
   102  func TestHTTP_Search_MultipleJobs(t *testing.T) {
   103  	assert := assert.New(t)
   104  
   105  	testJobA := "aaaaaaaa-e8f7-fd38-c855-ab94ceb89706"
   106  	testJobB := "aaaaaaaa-e8f7-fd38-c855-ab94ceb89707"
   107  	testJobC := "bbbbbbbb-e8f7-fd38-c855-ab94ceb89707"
   108  
   109  	testJobPrefix := "aaaaaaaa-e8f7-fd38"
   110  
   111  	t.Parallel()
   112  	httpTest(t, nil, func(s *TestAgent) {
   113  		createJobForTest(testJobA, s, t)
   114  		createJobForTest(testJobB, s, t)
   115  		createJobForTest(testJobC, s, t)
   116  
   117  		data := structs.SearchRequest{Prefix: testJobPrefix, Context: structs.Jobs}
   118  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
   119  		assert.Nil(err)
   120  
   121  		respW := httptest.NewRecorder()
   122  
   123  		resp, err := s.Server.SearchRequest(respW, req)
   124  		assert.Nil(err)
   125  
   126  		res := resp.(structs.SearchResponse)
   127  
   128  		assert.Equal(1, len(res.Matches))
   129  
   130  		j := res.Matches[structs.Jobs]
   131  
   132  		assert.Equal(2, len(j))
   133  		assert.Contains(j, testJobA)
   134  		assert.Contains(j, testJobB)
   135  		assert.NotContains(j, testJobC)
   136  
   137  		assert.Equal(res.Truncations[structs.Jobs], false)
   138  		assert.NotEqual("0", respW.HeaderMap.Get("X-Nomad-Index"))
   139  	})
   140  }
   141  
   142  func TestHTTP_Search_Evaluation(t *testing.T) {
   143  	assert := assert.New(t)
   144  
   145  	t.Parallel()
   146  	httpTest(t, nil, func(s *TestAgent) {
   147  		state := s.Agent.server.State()
   148  		eval1 := mock.Eval()
   149  		eval2 := mock.Eval()
   150  		err := state.UpsertEvals(9000,
   151  			[]*structs.Evaluation{eval1, eval2})
   152  		assert.Nil(err)
   153  
   154  		prefix := eval1.ID[:len(eval1.ID)-2]
   155  		data := structs.SearchRequest{Prefix: prefix, Context: structs.Evals}
   156  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
   157  		assert.Nil(err)
   158  
   159  		respW := httptest.NewRecorder()
   160  
   161  		resp, err := s.Server.SearchRequest(respW, req)
   162  		assert.Nil(err)
   163  
   164  		res := resp.(structs.SearchResponse)
   165  
   166  		assert.Equal(1, len(res.Matches))
   167  
   168  		j := res.Matches[structs.Evals]
   169  		assert.Equal(1, len(j))
   170  		assert.Contains(j, eval1.ID)
   171  		assert.NotContains(j, eval2.ID)
   172  
   173  		assert.Equal(res.Truncations[structs.Evals], false)
   174  		assert.Equal("9000", respW.HeaderMap.Get("X-Nomad-Index"))
   175  	})
   176  }
   177  
   178  func TestHTTP_Search_Allocations(t *testing.T) {
   179  	assert := assert.New(t)
   180  
   181  	t.Parallel()
   182  	httpTest(t, nil, func(s *TestAgent) {
   183  		state := s.Agent.server.State()
   184  		alloc := mock.Alloc()
   185  		err := state.UpsertAllocs(7000, []*structs.Allocation{alloc})
   186  		assert.Nil(err)
   187  
   188  		prefix := alloc.ID[:len(alloc.ID)-2]
   189  		data := structs.SearchRequest{Prefix: prefix, Context: structs.Allocs}
   190  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
   191  		assert.Nil(err)
   192  
   193  		respW := httptest.NewRecorder()
   194  
   195  		resp, err := s.Server.SearchRequest(respW, req)
   196  		assert.Nil(err)
   197  
   198  		res := resp.(structs.SearchResponse)
   199  
   200  		assert.Equal(1, len(res.Matches))
   201  
   202  		a := res.Matches[structs.Allocs]
   203  		assert.Equal(1, len(a))
   204  		assert.Contains(a, alloc.ID)
   205  
   206  		assert.Equal(res.Truncations[structs.Allocs], false)
   207  		assert.Equal("7000", respW.HeaderMap.Get("X-Nomad-Index"))
   208  	})
   209  }
   210  
   211  func TestHTTP_Search_Nodes(t *testing.T) {
   212  	assert := assert.New(t)
   213  
   214  	t.Parallel()
   215  	httpTest(t, nil, func(s *TestAgent) {
   216  		state := s.Agent.server.State()
   217  		node := mock.Node()
   218  		err := state.UpsertNode(6000, node)
   219  		assert.Nil(err)
   220  
   221  		prefix := node.ID[:len(node.ID)-2]
   222  		data := structs.SearchRequest{Prefix: prefix, Context: structs.Nodes}
   223  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
   224  		assert.Nil(err)
   225  
   226  		respW := httptest.NewRecorder()
   227  
   228  		resp, err := s.Server.SearchRequest(respW, req)
   229  		assert.Nil(err)
   230  
   231  		res := resp.(structs.SearchResponse)
   232  
   233  		assert.Equal(1, len(res.Matches))
   234  
   235  		n := res.Matches[structs.Nodes]
   236  		assert.Equal(1, len(n))
   237  		assert.Contains(n, node.ID)
   238  
   239  		assert.Equal(res.Truncations[structs.Nodes], false)
   240  		assert.Equal("6000", respW.HeaderMap.Get("X-Nomad-Index"))
   241  	})
   242  }
   243  
   244  func TestHTTP_Search_Deployments(t *testing.T) {
   245  	assert := assert.New(t)
   246  
   247  	t.Parallel()
   248  	httpTest(t, nil, func(s *TestAgent) {
   249  		state := s.Agent.server.State()
   250  		deployment := mock.Deployment()
   251  		assert.Nil(state.UpsertDeployment(999, deployment), "UpsertDeployment")
   252  
   253  		prefix := deployment.ID[:len(deployment.ID)-2]
   254  		data := structs.SearchRequest{Prefix: prefix, Context: structs.Deployments}
   255  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
   256  		assert.Nil(err)
   257  
   258  		respW := httptest.NewRecorder()
   259  
   260  		resp, err := s.Server.SearchRequest(respW, req)
   261  		assert.Nil(err)
   262  
   263  		res := resp.(structs.SearchResponse)
   264  
   265  		assert.Equal(1, len(res.Matches))
   266  
   267  		n := res.Matches[structs.Deployments]
   268  		assert.Equal(1, len(n))
   269  		assert.Contains(n, deployment.ID)
   270  
   271  		assert.Equal("999", respW.HeaderMap.Get("X-Nomad-Index"))
   272  	})
   273  }
   274  
   275  func TestHTTP_Search_NoJob(t *testing.T) {
   276  	assert := assert.New(t)
   277  
   278  	t.Parallel()
   279  	httpTest(t, nil, func(s *TestAgent) {
   280  		data := structs.SearchRequest{Prefix: "12345", Context: structs.Jobs}
   281  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
   282  		assert.Nil(err)
   283  
   284  		respW := httptest.NewRecorder()
   285  
   286  		resp, err := s.Server.SearchRequest(respW, req)
   287  		assert.Nil(err)
   288  
   289  		res := resp.(structs.SearchResponse)
   290  
   291  		assert.Equal(1, len(res.Matches))
   292  		assert.Equal(0, len(res.Matches[structs.Jobs]))
   293  
   294  		assert.Equal("0", respW.HeaderMap.Get("X-Nomad-Index"))
   295  	})
   296  }
   297  
   298  func TestHTTP_Search_AllContext(t *testing.T) {
   299  	assert := assert.New(t)
   300  
   301  	testJobID := "aaaaaaaa-e8f7-fd38-c855-ab94ceb89706"
   302  	testJobPrefix := "aaaaaaaa-e8f7-fd38"
   303  	t.Parallel()
   304  	httpTest(t, nil, func(s *TestAgent) {
   305  		createJobForTest(testJobID, s, t)
   306  
   307  		state := s.Agent.server.State()
   308  		eval1 := mock.Eval()
   309  		eval1.ID = testJobID
   310  		err := state.UpsertEvals(8000, []*structs.Evaluation{eval1})
   311  		assert.Nil(err)
   312  
   313  		data := structs.SearchRequest{Prefix: testJobPrefix, Context: structs.All}
   314  		req, err := http.NewRequest("POST", "/v1/search", encodeReq(data))
   315  		assert.Nil(err)
   316  
   317  		respW := httptest.NewRecorder()
   318  
   319  		resp, err := s.Server.SearchRequest(respW, req)
   320  		assert.Nil(err)
   321  
   322  		res := resp.(structs.SearchResponse)
   323  
   324  		matchedJobs := res.Matches[structs.Jobs]
   325  		matchedEvals := res.Matches[structs.Evals]
   326  
   327  		assert.Equal(1, len(matchedJobs))
   328  		assert.Equal(1, len(matchedEvals))
   329  
   330  		assert.Equal(matchedJobs[0], testJobID)
   331  		assert.Equal(matchedEvals[0], eval1.ID)
   332  
   333  		assert.Equal("8000", respW.HeaderMap.Get("X-Nomad-Index"))
   334  	})
   335  }