package agent

import (
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/hashicorp/nomad/nomad/mock"
	"github.com/hashicorp/nomad/nomad/structs"
)

func TestHTTP_ScalingPoliciesList(t *testing.T) {
	t.Parallel()
	httpTest(t, nil, func(s *TestAgent) {
		for i := 0; i < 3; i++ {
			// Create the job
			job, _ := mock.JobWithScalingPolicy()

			args := structs.JobRegisterRequest{
				Job: job,
				WriteRequest: structs.WriteRequest{
					Region:    "global",
					Namespace: structs.DefaultNamespace,
				},
			}
			var resp structs.JobRegisterResponse
			if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
				t.Fatalf("err: %v", err)
			}
		}

		// Make the HTTP request
		req, err := http.NewRequest("GET", "/v1/scaling/policies", nil)
		if err != nil {
			t.Fatalf("err: %v", err)
		}
		respW := httptest.NewRecorder()

		// Make the request
		obj, err := s.Server.ScalingPoliciesRequest(respW, req)
		if err != nil {
			t.Fatalf("err: %v", err)
		}

		// Check for the index
		if respW.Header().Get("X-Nomad-Index") == "" {
			t.Fatalf("missing index")
		}
		if respW.Header().Get("X-Nomad-KnownLeader") != "true" {
			t.Fatalf("missing known leader")
		}
		if respW.Header().Get("X-Nomad-LastContact") == "" {
			t.Fatalf("missing last contact")
		}

		// Check the list
		l := obj.([]*structs.ScalingPolicyListStub)
		if len(l) != 3 {
			t.Fatalf("bad: %#v", l)
		}
	})
}

func TestHTTP_ScalingPolicyGet(t *testing.T) {
	t.Parallel()
	require := require.New(t)
	httpTest(t, nil, func(s *TestAgent) {
		// Create the job
		job, p := mock.JobWithScalingPolicy()
		args := structs.JobRegisterRequest{
			Job: job,
			WriteRequest: structs.WriteRequest{
				Region:    "global",
				Namespace: structs.DefaultNamespace,
			},
		}
		var resp structs.JobRegisterResponse
		err := s.Agent.RPC("Job.Register", &args, &resp)
		require.NoError(err)

		// Make the HTTP request
		req, err := http.NewRequest("GET", "/v1/scaling/policy/"+p.ID, nil)
		require.NoError(err)
		respW := httptest.NewRecorder()

		// Make the request
		obj, err := s.Server.ScalingPolicySpecificRequest(respW, req)
		require.NoError(err)

		// Check for the index
		if respW.Header().Get("X-Nomad-Index") == "" {
			t.Fatalf("missing index")
		}
		if respW.Header().Get("X-Nomad-KnownLeader") != "true" {
			t.Fatalf("missing known leader")
		}
		if respW.Header().Get("X-Nomad-LastContact") == "" {
			t.Fatalf("missing last contact")
		}

		// Check the policy
		require.Equal(p.ID, obj.(*structs.ScalingPolicy).ID)
	})
}

// func TestHTTP_JobQuery_Payload(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := mock.Job()
//
// 		// Insert Payload compressed
// 		expected := []byte("hello world")
// 		compressed := snappy.Encode(nil, expected)
// 		job.Payload = compressed
//
// 		// Directly manipulate the state
// 		state := s.Agent.server.State()
// 		if err := state.UpsertJob(1000, job); err != nil {
// 			t.Fatalf("Failed to upsert job: %v", err)
// 		}
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("GET", "/v1/job/"+job.ID, nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 		if respW.Header().Get("X-Nomad-KnownLeader") != "true" {
// 			t.Fatalf("missing known leader")
// 		}
// 		if respW.Header().Get("X-Nomad-LastContact") == "" {
// 			t.Fatalf("missing last contact")
// 		}
//
// 		// Check the job
// 		j := obj.(*structs.Job)
// 		if j.ID != job.ID {
// 			t.Fatalf("bad: %#v", j)
// 		}
//
// 		// Check the payload is decompressed
// 		if !reflect.DeepEqual(j.Payload, expected) {
// 			t.Fatalf("Payload not decompressed properly; got %#v; want %#v", j.Payload, expected)
// 		}
// 	})
// }
//
// func TestHTTP_JobUpdate(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := MockJob()
// 		args := api.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: api.WriteRequest{
// 				Region:    "global",
// 				Namespace: api.DefaultNamespace,
// 			},
// 		}
// 		buf := encodeReq(args)
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("PUT", "/v1/job/"+*job.ID, buf)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		dereg := obj.(structs.JobRegisterResponse)
// 		if dereg.EvalID == "" {
// 			t.Fatalf("bad: %v", dereg)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
//
// 		// Check the job is registered
// 		getReq := structs.JobSpecificRequest{
// 			JobID: *job.ID,
// 			QueryOptions: structs.QueryOptions{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var getResp structs.SingleJobResponse
// 		if err := s.Agent.RPC("Job.GetJob", &getReq, &getResp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		if getResp.Job == nil {
// 			t.Fatalf("job does not exist")
// 		}
// 	})
// }
//
// func TestHTTP_JobUpdateRegion(t *testing.T) {
// 	t.Parallel()
//
// 	cases := []struct {
// 		Name           string
// 		ConfigRegion   string
// 		APIRegion      string
// 		ExpectedRegion string
// 	}{
// 		{
// 			Name:           "api region takes precedence",
// 			ConfigRegion:   "not-global",
// 			APIRegion:      "north-america",
// 			ExpectedRegion: "north-america",
// 		},
// 		{
// 			Name:           "config region is set",
// 			ConfigRegion:   "north-america",
// 			APIRegion:      "",
// 			ExpectedRegion: "north-america",
// 		},
// 		{
// 			Name:           "api region is set",
// 			ConfigRegion:   "",
// 			APIRegion:      "north-america",
// 			ExpectedRegion: "north-america",
// 		},
// 		{
// 			Name:           "defaults to node region global if no region is provided",
// 			ConfigRegion:   "",
// 			APIRegion:      "",
// 			ExpectedRegion: "global",
// 		},
// 		{
// 			Name:           "defaults to node region not-global if no region is provided",
// 			ConfigRegion:   "",
// 			APIRegion:      "",
// 			ExpectedRegion: "not-global",
// 		},
// 	}
//
// 	for _, tc := range cases {
// 		t.Run(tc.Name, func(t *testing.T) {
// 			httpTest(t, func(c *Config) { c.Region = tc.ExpectedRegion }, func(s *TestAgent) {
// 				// Create the job
// 				job := MockRegionalJob()
//
// 				if tc.ConfigRegion == "" {
// 					job.Region = nil
// 				} else {
// 					job.Region = &tc.ConfigRegion
// 				}
//
// 				args := api.JobRegisterRequest{
// 					Job: job,
// 					WriteRequest: api.WriteRequest{
// 						Namespace: api.DefaultNamespace,
// 						Region:    tc.APIRegion,
// 					},
// 				}
//
// 				buf := encodeReq(args)
//
// 				// Make the HTTP request
// 				url := "/v1/job/" + *job.ID
//
// 				req, err := http.NewRequest("PUT", url, buf)
// 				require.NoError(t, err)
// 				respW := httptest.NewRecorder()
//
// 				// Make the request
// 				obj, err := s.Server.JobSpecificRequest(respW, req)
// 				require.NoError(t, err)
//
// 				// Check the response
// 				dereg := obj.(structs.JobRegisterResponse)
// 				require.NotEmpty(t, dereg.EvalID)
//
// 				// Check for the index
// 				require.NotEmpty(t, respW.Header().Get("X-Nomad-Index"), "missing index")
//
// 				// Check the job is registered
// 				getReq := structs.JobSpecificRequest{
// 					JobID: *job.ID,
// 					QueryOptions: structs.QueryOptions{
// 						Region:    tc.ExpectedRegion,
// 						Namespace: structs.DefaultNamespace,
// 					},
// 				}
// 				var getResp structs.SingleJobResponse
// 				err = s.Agent.RPC("Job.GetJob", &getReq, &getResp)
// 				require.NoError(t, err)
// 				require.NotNil(t, getResp.Job, "job does not exist")
// 				require.Equal(t, tc.ExpectedRegion, getResp.Job.Region)
// 			})
// 		})
// 	}
// }
//
// func TestHTTP_JobDelete(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := mock.Job()
// 		args := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Make the HTTP request to do a soft delete
// 		req, err := http.NewRequest("DELETE", "/v1/job/"+job.ID, nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		dereg := obj.(structs.JobDeregisterResponse)
// 		if dereg.EvalID == "" {
// 			t.Fatalf("bad: %v", dereg)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
//
// 		// Check the job is still queryable
// 		getReq1 := structs.JobSpecificRequest{
// 			JobID: job.ID,
// 			QueryOptions: structs.QueryOptions{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var getResp1 structs.SingleJobResponse
// 		if err := s.Agent.RPC("Job.GetJob", &getReq1, &getResp1); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		if getResp1.Job == nil {
// 			t.Fatalf("job doesn't exists")
// 		}
// 		if !getResp1.Job.Stop {
// 			t.Fatalf("job should be marked as stop")
// 		}
//
// 		// Make the HTTP request to do a purge delete
// 		req2, err := http.NewRequest("DELETE", "/v1/job/"+job.ID+"?purge=true", nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW.Flush()
//
// 		// Make the request
// 		obj, err = s.Server.JobSpecificRequest(respW, req2)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		dereg = obj.(structs.JobDeregisterResponse)
// 		if dereg.EvalID == "" {
// 			t.Fatalf("bad: %v", dereg)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
//
// 		// Check the job is gone
// 		getReq2 := structs.JobSpecificRequest{
// 			JobID: job.ID,
// 			QueryOptions: structs.QueryOptions{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var getResp2 structs.SingleJobResponse
// 		if err := s.Agent.RPC("Job.GetJob", &getReq2, &getResp2); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		if getResp2.Job != nil {
// 			t.Fatalf("job still exists")
// 		}
// 	})
// }
//
// func TestHTTP_JobForceEvaluate(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := mock.Job()
// 		args := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("POST", "/v1/job/"+job.ID+"/evaluate", nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		reg := obj.(structs.JobRegisterResponse)
// 		if reg.EvalID == "" {
// 			t.Fatalf("bad: %v", reg)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 	})
// }
//
// func TestHTTP_JobEvaluate_ForceReschedule(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := mock.Job()
// 		args := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		jobEvalReq := api.JobEvaluateRequest{
// 			JobID: job.ID,
// 			EvalOptions: api.EvalOptions{
// 				ForceReschedule: true,
// 			},
// 		}
//
// 		buf := encodeReq(jobEvalReq)
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("POST", "/v1/job/"+job.ID+"/evaluate", buf)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		reg := obj.(structs.JobRegisterResponse)
// 		if reg.EvalID == "" {
// 			t.Fatalf("bad: %v", reg)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 	})
// }
//
// func TestHTTP_JobEvaluations(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := mock.Job()
// 		args := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("GET", "/v1/job/"+job.ID+"/evaluations", nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		evals := obj.([]*structs.Evaluation)
// 		// Can be multiple evals, use the last one, since they are in order
// 		idx := len(evals) - 1
// 		if len(evals) < 0 || evals[idx].ID != resp.EvalID {
// 			t.Fatalf("bad: %v", evals)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 		if respW.Header().Get("X-Nomad-KnownLeader") != "true" {
// 			t.Fatalf("missing known leader")
// 		}
// 		if respW.Header().Get("X-Nomad-LastContact") == "" {
// 			t.Fatalf("missing last contact")
// 		}
// 	})
// }
//
// func TestHTTP_JobAllocations(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		alloc1 := mock.Alloc()
// 		args := structs.JobRegisterRequest{
// 			Job: alloc1.Job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Directly manipulate the state
// 		expectedDisplayMsg := "test message"
// 		testEvent := structs.NewTaskEvent("test event").SetMessage(expectedDisplayMsg)
// 		var events []*structs.TaskEvent
// 		events = append(events, testEvent)
// 		taskState := &structs.TaskState{Events: events}
// 		alloc1.TaskStates = make(map[string]*structs.TaskState)
// 		alloc1.TaskStates["test"] = taskState
// 		state := s.Agent.server.State()
// 		err := state.UpsertAllocs(1000, []*structs.Allocation{alloc1})
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("GET", "/v1/job/"+alloc1.Job.ID+"/allocations?all=true", nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		allocs := obj.([]*structs.AllocListStub)
// 		if len(allocs) != 1 && allocs[0].ID != alloc1.ID {
// 			t.Fatalf("bad: %v", allocs)
// 		}
// 		displayMsg := allocs[0].TaskStates["test"].Events[0].DisplayMessage
// 		assert.Equal(t, expectedDisplayMsg, displayMsg)
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 		if respW.Header().Get("X-Nomad-KnownLeader") != "true" {
// 			t.Fatalf("missing known leader")
// 		}
// 		if respW.Header().Get("X-Nomad-LastContact") == "" {
// 			t.Fatalf("missing last contact")
// 		}
// 	})
// }
//
// func TestHTTP_JobDeployments(t *testing.T) {
// 	assert := assert.New(t)
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		j := mock.Job()
// 		args := structs.JobRegisterRequest{
// 			Job: j,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		assert.Nil(s.Agent.RPC("Job.Register", &args, &resp), "JobRegister")
//
// 		// Directly manipulate the state
// 		state := s.Agent.server.State()
// 		d := mock.Deployment()
// 		d.JobID = j.ID
// 		d.JobCreateIndex = resp.JobModifyIndex
//
// 		assert.Nil(state.UpsertDeployment(1000, d), "UpsertDeployment")
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("GET", "/v1/job/"+j.ID+"/deployments", nil)
// 		assert.Nil(err, "HTTP")
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		assert.Nil(err, "JobSpecificRequest")
//
// 		// Check the response
// 		deploys := obj.([]*structs.Deployment)
// 		assert.Len(deploys, 1, "deployments")
// 		assert.Equal(d.ID, deploys[0].ID, "deployment id")
//
// 		assert.NotZero(respW.Header().Get("X-Nomad-Index"), "missing index")
// 		assert.Equal("true", respW.Header().Get("X-Nomad-KnownLeader"), "missing known leader")
// 		assert.NotZero(respW.Header().Get("X-Nomad-LastContact"), "missing last contact")
// 	})
// }
//
// func TestHTTP_JobDeployment(t *testing.T) {
// 	assert := assert.New(t)
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		j := mock.Job()
// 		args := structs.JobRegisterRequest{
// 			Job: j,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		assert.Nil(s.Agent.RPC("Job.Register", &args, &resp), "JobRegister")
//
// 		// Directly manipulate the state
// 		state := s.Agent.server.State()
// 		d := mock.Deployment()
// 		d.JobID = j.ID
// 		d.JobCreateIndex = resp.JobModifyIndex
// 		assert.Nil(state.UpsertDeployment(1000, d), "UpsertDeployment")
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("GET", "/v1/job/"+j.ID+"/deployment", nil)
// 		assert.Nil(err, "HTTP")
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		assert.Nil(err, "JobSpecificRequest")
//
// 		// Check the response
// 		out := obj.(*structs.Deployment)
// 		assert.NotNil(out, "deployment")
// 		assert.Equal(d.ID, out.ID, "deployment id")
//
// 		assert.NotZero(respW.Header().Get("X-Nomad-Index"), "missing index")
// 		assert.Equal("true", respW.Header().Get("X-Nomad-KnownLeader"), "missing known leader")
// 		assert.NotZero(respW.Header().Get("X-Nomad-LastContact"), "missing last contact")
// 	})
// }
//
// func TestHTTP_JobVersions(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := mock.Job()
// 		args := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		job2 := mock.Job()
// 		job2.ID = job.ID
// 		job2.Priority = 100
//
// 		args2 := structs.JobRegisterRequest{
// 			Job: job2,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp2 structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args2, &resp2); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("GET", "/v1/job/"+job.ID+"/versions?diffs=true", nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		vResp := obj.(structs.JobVersionsResponse)
// 		versions := vResp.Versions
// 		if len(versions) != 2 {
// 			t.Fatalf("got %d versions; want 2", len(versions))
// 		}
//
// 		if v := versions[0]; v.Version != 1 || v.Priority != 100 {
// 			t.Fatalf("bad %v", v)
// 		}
//
// 		if v := versions[1]; v.Version != 0 {
// 			t.Fatalf("bad %v", v)
// 		}
//
// 		if len(vResp.Diffs) != 1 {
// 			t.Fatalf("bad %v", vResp)
// 		}
//
// 		// Check for the index
// 		if respW.Header().Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 		if respW.Header().Get("X-Nomad-KnownLeader") != "true" {
// 			t.Fatalf("missing known leader")
// 		}
// 		if respW.Header().Get("X-Nomad-LastContact") == "" {
// 			t.Fatalf("missing last contact")
// 		}
// 	})
// }
//
// func TestHTTP_PeriodicForce(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create and register a periodic job.
// 		job := mock.PeriodicJob()
// 		args := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("POST", "/v1/job/"+job.ID+"/periodic/force", nil)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check for the index
// 		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
//
// 		// Check the response
// 		r := obj.(structs.PeriodicForceResponse)
// 		if r.EvalID == "" {
// 			t.Fatalf("bad: %#v", r)
// 		}
// 	})
// }
//
// func TestHTTP_JobPlan(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := MockJob()
// 		args := api.JobPlanRequest{
// 			Job:  job,
// 			Diff: true,
// 			WriteRequest: api.WriteRequest{
// 				Region:    "global",
// 				Namespace: api.DefaultNamespace,
// 			},
// 		}
// 		buf := encodeReq(args)
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("PUT", "/v1/job/"+*job.ID+"/plan", buf)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		plan := obj.(structs.JobPlanResponse)
// 		if plan.Annotations == nil {
// 			t.Fatalf("bad: %v", plan)
// 		}
//
// 		if plan.Diff == nil {
// 			t.Fatalf("bad: %v", plan)
// 		}
// 	})
// }
//
// func TestHTTP_JobPlanRegion(t *testing.T) {
// 	t.Parallel()
//
// 	cases := []struct {
// 		Name           string
// 		ConfigRegion   string
// 		APIRegion      string
// 		ExpectedRegion string
// 	}{
// 		{
// 			Name:           "api region takes precedence",
// 			ConfigRegion:   "not-global",
// 			APIRegion:      "north-america",
// 			ExpectedRegion: "north-america",
// 		},
// 		{
// 			Name:           "config region is set",
// 			ConfigRegion:   "north-america",
// 			APIRegion:      "",
// 			ExpectedRegion: "north-america",
// 		},
// 		{
// 			Name:           "api region is set",
// 			ConfigRegion:   "",
// 			APIRegion:      "north-america",
// 			ExpectedRegion: "north-america",
// 		},
// 		{
// 			Name:           "falls back to default if no region is provided",
// 			ConfigRegion:   "",
// 			APIRegion:      "",
// 			ExpectedRegion: "global",
// 		},
// 	}
//
// 	for _, tc := range cases {
// 		t.Run(tc.Name, func(t *testing.T) {
// 			httpTest(t, func(c *Config) { c.Region = tc.ExpectedRegion }, func(s *TestAgent) {
// 				// Create the job
// 				job := MockRegionalJob()
//
// 				if tc.ConfigRegion == "" {
// 					job.Region = nil
// 				} else {
// 					job.Region = &tc.ConfigRegion
// 				}
//
// 				args := api.JobPlanRequest{
// 					Job:  job,
// 					Diff: true,
// 					WriteRequest: api.WriteRequest{
// 						Region:    tc.APIRegion,
// 						Namespace: api.DefaultNamespace,
// 					},
// 				}
// 				buf := encodeReq(args)
//
// 				// Make the HTTP request
// 				req, err := http.NewRequest("PUT", "/v1/job/"+*job.ID+"/plan", buf)
// 				require.NoError(t, err)
// 				respW := httptest.NewRecorder()
//
// 				// Make the request
// 				obj, err := s.Server.JobSpecificRequest(respW, req)
// 				require.NoError(t, err)
//
// 				// Check the response
// 				plan := obj.(structs.JobPlanResponse)
// 				require.NotNil(t, plan.Annotations)
// 				require.NotNil(t, plan.Diff)
// 			})
// 		})
// 	}
// }
//
// func TestHTTP_JobDispatch(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the parameterized job
// 		job := mock.BatchJob()
// 		job.ParameterizedJob = &structs.ParameterizedJobConfig{}
//
// 		args := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var resp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &args, &resp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Make the request
// 		respW := httptest.NewRecorder()
// 		args2 := structs.JobDispatchRequest{
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		buf := encodeReq(args2)
//
// 		// Make the HTTP request
// 		req2, err := http.NewRequest("PUT", "/v1/job/"+job.ID+"/dispatch", buf)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW.Flush()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req2)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		dispatch := obj.(structs.JobDispatchResponse)
// 		if dispatch.EvalID == "" {
// 			t.Fatalf("bad: %v", dispatch)
// 		}
//
// 		if dispatch.DispatchedJobID == "" {
// 			t.Fatalf("bad: %v", dispatch)
// 		}
// 	})
// }
//
// func TestHTTP_JobRevert(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job and register it twice
// 		job := mock.Job()
// 		regReq := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var regResp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &regReq, &regResp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Change the job to get a new version
// 		job.Datacenters = append(job.Datacenters, "foo")
// 		if err := s.Agent.RPC("Job.Register", &regReq, &regResp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		args := structs.JobRevertRequest{
// 			JobID:      job.ID,
// 			JobVersion: 0,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		buf := encodeReq(args)
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("PUT", "/v1/job/"+job.ID+"/revert", buf)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		revertResp := obj.(structs.JobRegisterResponse)
// 		if revertResp.EvalID == "" {
// 			t.Fatalf("bad: %v", revertResp)
// 		}
//
// 		// Check for the index
// 		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 	})
// }
//
// func TestHTTP_JobStable(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job and register it twice
// 		job := mock.Job()
// 		regReq := structs.JobRegisterRequest{
// 			Job: job,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		var regResp structs.JobRegisterResponse
// 		if err := s.Agent.RPC("Job.Register", &regReq, &regResp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		if err := s.Agent.RPC("Job.Register", &regReq, &regResp); err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		args := structs.JobStabilityRequest{
// 			JobID:      job.ID,
// 			JobVersion: 0,
// 			Stable:     true,
// 			WriteRequest: structs.WriteRequest{
// 				Region:    "global",
// 				Namespace: structs.DefaultNamespace,
// 			},
// 		}
// 		buf := encodeReq(args)
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("PUT", "/v1/job/"+job.ID+"/stable", buf)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.JobSpecificRequest(respW, req)
// 		if err != nil {
// 			t.Fatalf("err: %v", err)
// 		}
//
// 		// Check the response
// 		stableResp := obj.(structs.JobStabilityResponse)
// 		if stableResp.Index == 0 {
// 			t.Fatalf("bad: %v", stableResp)
// 		}
//
// 		// Check for the index
// 		if respW.HeaderMap.Get("X-Nomad-Index") == "" {
// 			t.Fatalf("missing index")
// 		}
// 	})
// }
//
// func TestJobs_ApiJobToStructsJob(t *testing.T) {
// 	apiJob := &api.Job{
// 		Stop:        helper.BoolToPtr(true),
// 		Region:      helper.StringToPtr("global"),
// 		Namespace:   helper.StringToPtr("foo"),
// 		ID:          helper.StringToPtr("foo"),
// 		ParentID:    helper.StringToPtr("lol"),
// 		Name:        helper.StringToPtr("name"),
// 		Type:        helper.StringToPtr("service"),
// 		Priority:    helper.IntToPtr(50),
// 		AllAtOnce:   helper.BoolToPtr(true),
// 		Datacenters: []string{"dc1", "dc2"},
// 		Constraints: []*api.Constraint{
// 			{
// 				LTarget: "a",
// 				RTarget: "b",
// 				Operand: "c",
// 			},
// 		},
// 		Affinities: []*api.Affinity{
// 			{
// 				LTarget: "a",
// 				RTarget: "b",
// 				Operand: "c",
// 				Weight:  helper.Int8ToPtr(50),
// 			},
// 		},
// 		Update: &api.UpdateStrategy{
// 			Stagger:          helper.TimeToPtr(1 * time.Second),
// 			MaxParallel:      helper.IntToPtr(5),
// 			HealthCheck:      helper.StringToPtr(structs.UpdateStrategyHealthCheck_Manual),
// 			MinHealthyTime:   helper.TimeToPtr(1 * time.Minute),
// 			HealthyDeadline:  helper.TimeToPtr(3 * time.Minute),
// 			ProgressDeadline: helper.TimeToPtr(3 * time.Minute),
// 			AutoRevert:       helper.BoolToPtr(false),
// 			Canary:           helper.IntToPtr(1),
// 		},
// 		Spreads: []*api.Spread{
// 			{
// 				Attribute: "${meta.rack}",
// 				Weight:    helper.Int8ToPtr(100),
// 				SpreadTarget: []*api.SpreadTarget{
// 					{
// 						Value:   "r1",
// 						Percent: 50,
// 					},
// 				},
// 			},
// 		},
// 		Periodic: &api.PeriodicConfig{
// 			Enabled:         helper.BoolToPtr(true),
// 			Spec:            helper.StringToPtr("spec"),
// 			SpecType:        helper.StringToPtr("cron"),
// 			ProhibitOverlap: helper.BoolToPtr(true),
// 			TimeZone:        helper.StringToPtr("test zone"),
// 		},
// 		ParameterizedJob: &api.ParameterizedJobConfig{
// 			Payload:      "payload",
// 			MetaRequired: []string{"a", "b"},
// 			MetaOptional: []string{"c", "d"},
// 		},
// 		Payload: []byte("payload"),
// 		Meta: map[string]string{
// 			"foo": "bar",
// 		},
// 		TaskGroups: []*api.TaskGroup{
// 			{
// 				Name:  helper.StringToPtr("group1"),
// 				Count: helper.IntToPtr(5),
// 				Constraints: []*api.Constraint{
// 					{
// 						LTarget: "x",
// 						RTarget: "y",
// 						Operand: "z",
// 					},
// 				},
// 				Affinities: []*api.Affinity{
// 					{
// 						LTarget: "x",
// 						RTarget: "y",
// 						Operand: "z",
// 						Weight:  helper.Int8ToPtr(100),
// 					},
// 				},
// 				RestartPolicy: &api.RestartPolicy{
// 					Interval: helper.TimeToPtr(1 * time.Second),
// 					Attempts: helper.IntToPtr(5),
// 					Delay:    helper.TimeToPtr(10 * time.Second),
// 					Mode:     helper.StringToPtr("delay"),
// 				},
// 				ReschedulePolicy: &api.ReschedulePolicy{
// 					Interval:      helper.TimeToPtr(12 * time.Hour),
// 					Attempts:      helper.IntToPtr(5),
// 					DelayFunction: helper.StringToPtr("constant"),
// 					Delay:         helper.TimeToPtr(30 * time.Second),
// 					Unlimited:     helper.BoolToPtr(true),
// 					MaxDelay:      helper.TimeToPtr(20 * time.Minute),
// 				},
// 				Migrate: &api.MigrateStrategy{
// 					MaxParallel:     helper.IntToPtr(12),
// 					HealthCheck:     helper.StringToPtr("task_events"),
// 					MinHealthyTime:  helper.TimeToPtr(12 * time.Hour),
// 					HealthyDeadline: helper.TimeToPtr(12 * time.Hour),
// 				},
// 				Spreads: []*api.Spread{
// 					{
// 						Attribute: "${node.datacenter}",
// 						Weight:    helper.Int8ToPtr(100),
// 						SpreadTarget: []*api.SpreadTarget{
// 							{
// 								Value:   "dc1",
// 								Percent: 100,
// 							},
// 						},
// 					},
// 				},
// 				EphemeralDisk: &api.EphemeralDisk{
// 					SizeMB:  helper.IntToPtr(100),
// 					Sticky:  helper.BoolToPtr(true),
// 					Migrate: helper.BoolToPtr(true),
// 				},
// 				Update: &api.UpdateStrategy{
// 					HealthCheck:      helper.StringToPtr(structs.UpdateStrategyHealthCheck_Checks),
// 					MinHealthyTime:   helper.TimeToPtr(2 * time.Minute),
// 					HealthyDeadline:  helper.TimeToPtr(5 * time.Minute),
// 					ProgressDeadline: helper.TimeToPtr(5 * time.Minute),
// 					AutoRevert:       helper.BoolToPtr(true),
// 				},
// 				Meta: map[string]string{
// 					"key": "value",
// 				},
// 				Services: []*api.Service{
// 					{
// 						Name:       "groupserviceA",
// 						Tags:       []string{"a", "b"},
// 						CanaryTags: []string{"d", "e"},
// 						PortLabel:  "1234",
// 						Meta: map[string]string{
// 							"servicemeta": "foobar",
// 						},
// 						CheckRestart: &api.CheckRestart{
// 							Limit: 4,
// 							Grace: helper.TimeToPtr(11 * time.Second),
// 						},
// 						Checks: []api.ServiceCheck{
// 							{
// 								Id:            "hello",
// 								Name:          "bar",
// 								Type:          "http",
// 								Command:       "foo",
// 								Args:          []string{"a", "b"},
// 								Path:          "/check",
// 								Protocol:      "http",
// 								PortLabel:     "foo",
// 								AddressMode:   "driver",
// 								GRPCService:   "foo.Bar",
// 								GRPCUseTLS:    true,
// 								Interval:      4 * time.Second,
// 								Timeout:       2 * time.Second,
// 								InitialStatus: "ok",
// 								CheckRestart: &api.CheckRestart{
// 									Limit:          3,
// 									IgnoreWarnings: true,
// 								},
// 								TaskName: "task1",
// 							},
// 						},
// 						Connect: &api.ConsulConnect{
// 							Native: false,
// 							SidecarService: &api.ConsulSidecarService{
// 								Tags: []string{"f", "g"},
// 								Port: "9000",
// 							},
// 						},
// 					},
// 				},
// 				Tasks: []*api.Task{
// 					{
// 						Name:   "task1",
// 						Leader: true,
// 						Driver: "docker",
// 						User:   "mary",
// 						Config: map[string]interface{}{
// 							"lol": "code",
// 						},
// 						Env: map[string]string{
// 							"hello": "world",
// 						},
// 						Constraints: []*api.Constraint{
// 							{
// 								LTarget: "x",
// 								RTarget: "y",
// 								Operand: "z",
// 							},
// 						},
// 						Affinities: []*api.Affinity{
// 							{
// 								LTarget: "a",
// 								RTarget: "b",
// 								Operand: "c",
// 								Weight:  helper.Int8ToPtr(50),
// 							},
// 						},
//
// 						Services: []*api.Service{
// 							{
// 								Id:         "id",
// 								Name:       "serviceA",
// 								Tags:       []string{"1", "2"},
// 								CanaryTags: []string{"3", "4"},
// 								PortLabel:  "foo",
// 								Meta: map[string]string{
// 									"servicemeta": "foobar",
// 								},
// 								CheckRestart: &api.CheckRestart{
// 									Limit: 4,
// 									Grace: helper.TimeToPtr(11 * time.Second),
// 								},
// 								Checks: []api.ServiceCheck{
// 									{
// 										Id:            "hello",
// 										Name:          "bar",
// 										Type:          "http",
// 										Command:       "foo",
// 										Args:          []string{"a", "b"},
// 										Path:          "/check",
// 										Protocol:      "http",
// 										PortLabel:     "foo",
// 										AddressMode:   "driver",
// 										GRPCService:   "foo.Bar",
// 										GRPCUseTLS:    true,
// 										Interval:      4 * time.Second,
// 										Timeout:       2 * time.Second,
// 										InitialStatus: "ok",
// 										CheckRestart: &api.CheckRestart{
// 											Limit:          3,
// 											IgnoreWarnings: true,
// 										},
// 									},
// 									{
// 										Id:        "check2id",
// 										Name:      "check2",
// 										Type:      "tcp",
// 										PortLabel: "foo",
// 										Interval:  4 * time.Second,
// 										Timeout:   2 * time.Second,
// 									},
// 								},
// 							},
// 						},
// 						Resources: &api.Resources{
// 							CPU:      helper.IntToPtr(100),
// 							MemoryMB: helper.IntToPtr(10),
// 							Networks: []*api.NetworkResource{
// 								{
// 									IP:    "10.10.11.1",
// 									MBits: helper.IntToPtr(10),
// 									ReservedPorts: []api.Port{
// 										{
// 											Label: "http",
// 											Value: 80,
// 										},
// 									},
// 									DynamicPorts: []api.Port{
// 										{
// 											Label: "ssh",
// 											Value: 2000,
// 										},
// 									},
// 								},
// 							},
// 							Devices: []*api.RequestedDevice{
// 								{
// 									Name:  "nvidia/gpu",
// 									Count: helper.Uint64ToPtr(4),
// 									Constraints: []*api.Constraint{
// 										{
// 											LTarget: "x",
// 											RTarget: "y",
// 											Operand: "z",
// 										},
// 									},
// 									Affinities: []*api.Affinity{
// 										{
// 											LTarget: "a",
// 											RTarget: "b",
// 											Operand: "c",
// 											Weight:  helper.Int8ToPtr(50),
// 										},
// 									},
// 								},
// 								{
// 									Name:  "gpu",
// 									Count: nil,
// 								},
// 							},
// 						},
// 						Meta: map[string]string{
// 							"lol": "code",
// 						},
// 						KillTimeout: helper.TimeToPtr(10 * time.Second),
// 						KillSignal:  "SIGQUIT",
// 						LogConfig: &api.LogConfig{
// 							MaxFiles:      helper.IntToPtr(10),
// 							MaxFileSizeMB: helper.IntToPtr(100),
// 						},
// 						Artifacts: []*api.TaskArtifact{
// 							{
// 								GetterSource: helper.StringToPtr("source"),
// 								GetterOptions: map[string]string{
// 									"a": "b",
// 								},
// 								GetterMode:   helper.StringToPtr("dir"),
// 								RelativeDest: helper.StringToPtr("dest"),
// 							},
// 						},
// 						Vault: &api.Vault{
// 							Policies:     []string{"a", "b", "c"},
// 							Env:          helper.BoolToPtr(true),
// 							ChangeMode:   helper.StringToPtr("c"),
// 							ChangeSignal: helper.StringToPtr("sighup"),
// 						},
// 						Templates: []*api.Template{
// 							{
// 								SourcePath:   helper.StringToPtr("source"),
// 								DestPath:     helper.StringToPtr("dest"),
// 								EmbeddedTmpl: helper.StringToPtr("embedded"),
// 								ChangeMode:   helper.StringToPtr("change"),
// 								ChangeSignal: helper.StringToPtr("signal"),
// 								Splay:        helper.TimeToPtr(1 * time.Minute),
// 								Perms:        helper.StringToPtr("666"),
// 								LeftDelim:    helper.StringToPtr("abc"),
// 								RightDelim:   helper.StringToPtr("def"),
// 								Envvars:      helper.BoolToPtr(true),
// 								VaultGrace:   helper.TimeToPtr(3 * time.Second),
// 							},
// 						},
// 						DispatchPayload: &api.DispatchPayloadConfig{
// 							File: "fileA",
// 						},
// 					},
// 				},
// 			},
// 		},
// 		VaultToken:        helper.StringToPtr("token"),
// 		Status:            helper.StringToPtr("status"),
// 		StatusDescription: helper.StringToPtr("status_desc"),
// 		Version:           helper.Uint64ToPtr(10),
// 		CreateIndex:       helper.Uint64ToPtr(1),
// 		ModifyIndex:       helper.Uint64ToPtr(3),
// 		JobModifyIndex:    helper.Uint64ToPtr(5),
// 	}
//
// 	expected := &structs.Job{
// 		Stop:        true,
// 		Region:      "global",
// 		Namespace:   "foo",
// 		ID:          "foo",
// 		ParentID:    "lol",
// 		Name:        "name",
// 		Type:        "service",
// 		Priority:    50,
// 		AllAtOnce:   true,
// 		Datacenters: []string{"dc1", "dc2"},
// 		Constraints: []*structs.Constraint{
// 			{
// 				LTarget: "a",
// 				RTarget: "b",
// 				Operand: "c",
// 			},
// 		},
// 		Affinities: []*structs.Affinity{
// 			{
// 				LTarget: "a",
// 				RTarget: "b",
// 				Operand: "c",
// 				Weight:  50,
// 			},
// 		},
// 		Spreads: []*structs.Spread{
// 			{
// 				Attribute: "${meta.rack}",
// 				Weight:    100,
// 				SpreadTarget: []*structs.SpreadTarget{
// 					{
// 						Value:   "r1",
// 						Percent: 50,
// 					},
// 				},
// 			},
// 		},
// 		Update: structs.UpdateStrategy{
// 			Stagger:     1 * time.Second,
// 			MaxParallel: 5,
// 		},
// 		Periodic: &structs.PeriodicConfig{
// 			Enabled:         true,
// 			Spec:            "spec",
// 			SpecType:        "cron",
// 			ProhibitOverlap: true,
// 			TimeZone:        "test zone",
// 		},
// 		ParameterizedJob: &structs.ParameterizedJobConfig{
// 			Payload:      "payload",
// 			MetaRequired: []string{"a", "b"},
// 			MetaOptional: []string{"c", "d"},
// 		},
// 		Payload: []byte("payload"),
// 		Meta: map[string]string{
// 			"foo": "bar",
// 		},
// 		TaskGroups: []*structs.TaskGroup{
// 			{
// 				Name:  "group1",
// 				Count: 5,
// 				Constraints: []*structs.Constraint{
// 					{
// 						LTarget: "x",
// 						RTarget: "y",
// 						Operand: "z",
// 					},
// 				},
// 				Affinities: []*structs.Affinity{
// 					{
// 						LTarget: "x",
// 						RTarget: "y",
// 						Operand: "z",
// 						Weight:  100,
// 					},
// 				},
// 				RestartPolicy: &structs.RestartPolicy{
// 					Interval: 1 * time.Second,
// 					Attempts: 5,
// 					Delay:    10 * time.Second,
// 					Mode:     "delay",
// 				},
// 				Spreads: []*structs.Spread{
// 					{
// 						Attribute: "${node.datacenter}",
// 						Weight:    100,
// 						SpreadTarget: []*structs.SpreadTarget{
// 							{
// 								Value:   "dc1",
// 								Percent: 100,
// 							},
// 						},
// 					},
// 				},
// 				ReschedulePolicy: &structs.ReschedulePolicy{
// 					Interval:      12 * time.Hour,
// 					Attempts:      5,
// 					DelayFunction: "constant",
// 					Delay:         30 * time.Second,
// 					Unlimited:     true,
// 					MaxDelay:      20 * time.Minute,
// 				},
// 				Migrate: &structs.MigrateStrategy{
// 					MaxParallel:     12,
// 					HealthCheck:     "task_events",
// 					MinHealthyTime:  12 * time.Hour,
// 					HealthyDeadline: 12 * time.Hour,
// 				},
// 				EphemeralDisk: &structs.EphemeralDisk{
// 					SizeMB:  100,
// 					Sticky:  true,
// 					Migrate: true,
// 				},
// 				Update: &structs.UpdateStrategy{
// 					Stagger:          1 * time.Second,
// 					MaxParallel:      5,
// 					HealthCheck:      structs.UpdateStrategyHealthCheck_Checks,
// 					MinHealthyTime:   2 * time.Minute,
// 					HealthyDeadline:  5 * time.Minute,
// 					ProgressDeadline: 5 * time.Minute,
// 					AutoRevert:       true,
// 					AutoPromote:      false,
// 					Canary:           1,
// 				},
// 				Meta: map[string]string{
// 					"key": "value",
// 				},
// 				Services: []*structs.Service{
// 					{
// 						Name:        "groupserviceA",
// 						Tags:        []string{"a", "b"},
// 						CanaryTags:  []string{"d", "e"},
// 						PortLabel:   "1234",
// 						AddressMode: "auto",
// 						Meta: map[string]string{
// 							"servicemeta": "foobar",
// 						},
// 						Checks: []*structs.ServiceCheck{
// 							{
// 								Name:          "bar",
// 								Type:          "http",
// 								Command:       "foo",
// 								Args:          []string{"a", "b"},
// 								Path:          "/check",
// 								Protocol:      "http",
// 								PortLabel:     "foo",
// 								AddressMode:   "driver",
// 								GRPCService:   "foo.Bar",
// 								GRPCUseTLS:    true,
// 								Interval:      4 * time.Second,
// 								Timeout:       2 * time.Second,
// 								InitialStatus: "ok",
// 								CheckRestart: &structs.CheckRestart{
// 									Grace:          11 * time.Second,
// 									Limit:          3,
// 									IgnoreWarnings: true,
// 								},
// 								TaskName: "task1",
// 							},
// 						},
// 						Connect: &structs.ConsulConnect{
// 							Native: false,
// 							SidecarService: &structs.ConsulSidecarService{
// 								Tags: []string{"f", "g"},
// 								Port: "9000",
// 							},
// 						},
// 					},
// 				},
// 				Tasks: []*structs.Task{
// 					{
// 						Name:   "task1",
// 						Driver: "docker",
// 						Leader: true,
// 						User:   "mary",
// 						Config: map[string]interface{}{
// 							"lol": "code",
// 						},
// 						Constraints: []*structs.Constraint{
// 							{
// 								LTarget: "x",
// 								RTarget: "y",
// 								Operand: "z",
// 							},
// 						},
// 						Affinities: []*structs.Affinity{
// 							{
// 								LTarget: "a",
// 								RTarget: "b",
// 								Operand: "c",
// 								Weight:  50,
// 							},
// 						},
// 						Env: map[string]string{
// 							"hello": "world",
// 						},
// 						Services: []*structs.Service{
// 							{
// 								Name:        "serviceA",
// 								Tags:        []string{"1", "2"},
// 								CanaryTags:  []string{"3", "4"},
// 								PortLabel:   "foo",
// 								AddressMode: "auto",
// 								Meta: map[string]string{
// 									"servicemeta": "foobar",
// 								},
// 								Checks: []*structs.ServiceCheck{
// 									{
// 										Name:          "bar",
// 										Type:          "http",
// 										Command:       "foo",
// 										Args:          []string{"a", "b"},
// 										Path:          "/check",
// 										Protocol:      "http",
// 										PortLabel:     "foo",
// 										AddressMode:   "driver",
// 										Interval:      4 * time.Second,
// 										Timeout:       2 * time.Second,
// 										InitialStatus: "ok",
// 										GRPCService:   "foo.Bar",
// 										GRPCUseTLS:    true,
// 										CheckRestart: &structs.CheckRestart{
// 											Limit:          3,
// 											Grace:          11 * time.Second,
// 											IgnoreWarnings: true,
// 										},
// 									},
// 									{
// 										Name:      "check2",
// 										Type:      "tcp",
// 										PortLabel: "foo",
// 										Interval:  4 * time.Second,
// 										Timeout:   2 * time.Second,
// 										CheckRestart: &structs.CheckRestart{
// 											Limit: 4,
// 											Grace: 11 * time.Second,
// 										},
// 									},
// 								},
// 							},
// 						},
// 						Resources: &structs.Resources{
// 							CPU:      100,
// 							MemoryMB: 10,
// 							Networks: []*structs.NetworkResource{
// 								{
// 									IP:    "10.10.11.1",
// 									MBits: 10,
// 									ReservedPorts: []structs.Port{
// 										{
// 											Label: "http",
// 											Value: 80,
// 										},
// 									},
// 									DynamicPorts: []structs.Port{
// 										{
// 											Label: "ssh",
// 											Value: 2000,
// 										},
// 									},
// 								},
// 							},
// 							Devices: []*structs.RequestedDevice{
// 								{
// 									Name:  "nvidia/gpu",
// 									Count: 4,
// 									Constraints: []*structs.Constraint{
// 										{
// 											LTarget: "x",
// 											RTarget: "y",
// 											Operand: "z",
// 										},
// 									},
// 									Affinities: []*structs.Affinity{
// 										{
// 											LTarget: "a",
// 											RTarget: "b",
// 											Operand: "c",
// 											Weight:  50,
// 										},
// 									},
// 								},
// 								{
// 									Name:  "gpu",
// 									Count: 1,
// 								},
// 							},
// 						},
// 						Meta: map[string]string{
// 							"lol": "code",
// 						},
// 						KillTimeout: 10 * time.Second,
// 						KillSignal:  "SIGQUIT",
// 						LogConfig: &structs.LogConfig{
// 							MaxFiles:      10,
// 							MaxFileSizeMB: 100,
// 						},
// 						Artifacts: []*structs.TaskArtifact{
// 							{
// 								GetterSource: "source",
// 								GetterOptions: map[string]string{
// 									"a": "b",
// 								},
// 								GetterMode:   "dir",
// 								RelativeDest: "dest",
// 							},
// 						},
// 						Vault: &structs.Vault{
// 							Policies:     []string{"a", "b", "c"},
// 							Env:          true,
// 							ChangeMode:   "c",
// 							ChangeSignal: "sighup",
// 						},
// 						Templates: []*structs.Template{
// 							{
// 								SourcePath:   "source",
// 								DestPath:     "dest",
// 								EmbeddedTmpl: "embedded",
// 								ChangeMode:   "change",
// 								ChangeSignal: "SIGNAL",
// 								Splay:        1 * time.Minute,
// 								Perms:        "666",
// 								LeftDelim:    "abc",
// 								RightDelim:   "def",
// 								Envvars:      true,
// 								VaultGrace:   3 * time.Second,
// 							},
// 						},
// 						DispatchPayload: &structs.DispatchPayloadConfig{
// 							File: "fileA",
// 						},
// 					},
// 				},
// 			},
// 		},
//
// 		VaultToken: "token",
// 	}
//
// 	structsJob := ApiJobToStructJob(apiJob)
//
// 	if diff := pretty.Diff(expected, structsJob); len(diff) > 0 {
// 		t.Fatalf("bad:\n%s", strings.Join(diff, "\n"))
// 	}
//
// 	systemAPIJob := &api.Job{
// 		Stop:        helper.BoolToPtr(true),
// 		Region:      helper.StringToPtr("global"),
// 		Namespace:   helper.StringToPtr("foo"),
// 		ID:          helper.StringToPtr("foo"),
// 		ParentID:    helper.StringToPtr("lol"),
// 		Name:        helper.StringToPtr("name"),
// 		Type:        helper.StringToPtr("system"),
// 		Priority:    helper.IntToPtr(50),
// 		AllAtOnce:   helper.BoolToPtr(true),
// 		Datacenters: []string{"dc1", "dc2"},
// 		Constraints: []*api.Constraint{
// 			{
// 				LTarget: "a",
// 				RTarget: "b",
// 				Operand: "c",
// 			},
// 		},
// 		TaskGroups: []*api.TaskGroup{
// 			{
// 				Name:  helper.StringToPtr("group1"),
// 				Count: helper.IntToPtr(5),
// 				Constraints: []*api.Constraint{
// 					{
// 						LTarget: "x",
// 						RTarget: "y",
// 						Operand: "z",
// 					},
// 				},
// 				RestartPolicy: &api.RestartPolicy{
// 					Interval: helper.TimeToPtr(1 * time.Second),
// 					Attempts: helper.IntToPtr(5),
// 					Delay:    helper.TimeToPtr(10 * time.Second),
// 					Mode:     helper.StringToPtr("delay"),
// 				},
// 				EphemeralDisk: &api.EphemeralDisk{
// 					SizeMB:  helper.IntToPtr(100),
// 					Sticky:  helper.BoolToPtr(true),
// 					Migrate: helper.BoolToPtr(true),
// 				},
// 				Meta: map[string]string{
// 					"key": "value",
// 				},
// 				Tasks: []*api.Task{
// 					{
// 						Name:   "task1",
// 						Leader: true,
// 						Driver: "docker",
// 						User:   "mary",
// 						Config: map[string]interface{}{
// 							"lol": "code",
// 						},
// 						Env: map[string]string{
// 							"hello": "world",
// 						},
// 						Constraints: []*api.Constraint{
// 							{
// 								LTarget: "x",
// 								RTarget: "y",
// 								Operand: "z",
// 							},
// 						},
// 						Resources: &api.Resources{
// 							CPU:      helper.IntToPtr(100),
// 							MemoryMB: helper.IntToPtr(10),
// 							Networks: []*api.NetworkResource{
// 								{
// 									IP:    "10.10.11.1",
// 									MBits: helper.IntToPtr(10),
// 									ReservedPorts: []api.Port{
// 										{
// 											Label: "http",
// 											Value: 80,
// 										},
// 									},
// 									DynamicPorts: []api.Port{
// 										{
// 											Label: "ssh",
// 											Value: 2000,
// 										},
// 									},
// 								},
// 							},
// 						},
// 						Meta: map[string]string{
// 							"lol": "code",
// 						},
// 						KillTimeout: helper.TimeToPtr(10 * time.Second),
// 						KillSignal:  "SIGQUIT",
// 						LogConfig: &api.LogConfig{
// 							MaxFiles:      helper.IntToPtr(10),
// 							MaxFileSizeMB: helper.IntToPtr(100),
// 						},
// 						Artifacts: []*api.TaskArtifact{
// 							{
// 								GetterSource: helper.StringToPtr("source"),
// 								GetterOptions: map[string]string{
// 									"a": "b",
// 								},
// 								GetterMode:   helper.StringToPtr("dir"),
// 								RelativeDest: helper.StringToPtr("dest"),
// 							},
// 						},
// 						DispatchPayload: &api.DispatchPayloadConfig{
// 							File: "fileA",
// 						},
// 					},
// 				},
// 			},
// 		},
// 		Status:            helper.StringToPtr("status"),
// 		StatusDescription: helper.StringToPtr("status_desc"),
// 		Version:           helper.Uint64ToPtr(10),
// 		CreateIndex:       helper.Uint64ToPtr(1),
// 		ModifyIndex:       helper.Uint64ToPtr(3),
// 		JobModifyIndex:    helper.Uint64ToPtr(5),
// 	}
//
// 	expectedSystemJob := &structs.Job{
// 		Stop:        true,
// 		Region:      "global",
// 		Namespace:   "foo",
// 		ID:          "foo",
// 		ParentID:    "lol",
// 		Name:        "name",
// 		Type:        "system",
// 		Priority:    50,
// 		AllAtOnce:   true,
// 		Datacenters: []string{"dc1", "dc2"},
// 		Constraints: []*structs.Constraint{
// 			{
// 				LTarget: "a",
// 				RTarget: "b",
// 				Operand: "c",
// 			},
// 		},
// 		TaskGroups: []*structs.TaskGroup{
// 			{
// 				Name:  "group1",
// 				Count: 5,
// 				Constraints: []*structs.Constraint{
// 					{
// 						LTarget: "x",
// 						RTarget: "y",
// 						Operand: "z",
// 					},
// 				},
// 				RestartPolicy: &structs.RestartPolicy{
// 					Interval: 1 * time.Second,
// 					Attempts: 5,
// 					Delay:    10 * time.Second,
// 					Mode:     "delay",
// 				},
// 				EphemeralDisk: &structs.EphemeralDisk{
// 					SizeMB:  100,
// 					Sticky:  true,
// 					Migrate: true,
// 				},
// 				Meta: map[string]string{
// 					"key": "value",
// 				},
// 				Tasks: []*structs.Task{
// 					{
// 						Name:   "task1",
// 						Driver: "docker",
// 						Leader: true,
// 						User:   "mary",
// 						Config: map[string]interface{}{
// 							"lol": "code",
// 						},
// 						Constraints: []*structs.Constraint{
// 							{
// 								LTarget: "x",
// 								RTarget: "y",
// 								Operand: "z",
// 							},
// 						},
// 						Env: map[string]string{
// 							"hello": "world",
// 						},
// 						Resources: &structs.Resources{
// 							CPU:      100,
// 							MemoryMB: 10,
// 							Networks: []*structs.NetworkResource{
// 								{
// 									IP:    "10.10.11.1",
// 									MBits: 10,
// 									ReservedPorts: []structs.Port{
// 										{
// 											Label: "http",
// 											Value: 80,
// 										},
// 									},
// 									DynamicPorts: []structs.Port{
// 										{
// 											Label: "ssh",
// 											Value: 2000,
// 										},
// 									},
// 								},
// 							},
// 						},
// 						Meta: map[string]string{
// 							"lol": "code",
// 						},
// 						KillTimeout: 10 * time.Second,
// 						KillSignal:  "SIGQUIT",
// 						LogConfig: &structs.LogConfig{
// 							MaxFiles:      10,
// 							MaxFileSizeMB: 100,
// 						},
// 						Artifacts: []*structs.TaskArtifact{
// 							{
// 								GetterSource: "source",
// 								GetterOptions: map[string]string{
// 									"a": "b",
// 								},
// 								GetterMode:   "dir",
// 								RelativeDest: "dest",
// 							},
// 						},
// 						DispatchPayload: &structs.DispatchPayloadConfig{
// 							File: "fileA",
// 						},
// 					},
// 				},
// 			},
// 		},
// 	}
//
// 	systemStructsJob := ApiJobToStructJob(systemAPIJob)
//
// 	if diff := pretty.Diff(expectedSystemJob, systemStructsJob); len(diff) > 0 {
// 		t.Fatalf("bad:\n%s", strings.Join(diff, "\n"))
// 	}
// }
//
// func TestJobs_ApiJobToStructsJobUpdate(t *testing.T) {
// 	apiJob := &api.Job{
// 		Update: &api.UpdateStrategy{
// 			Stagger:          helper.TimeToPtr(1 * time.Second),
// 			MaxParallel:      helper.IntToPtr(5),
// 			HealthCheck:      helper.StringToPtr(structs.UpdateStrategyHealthCheck_Manual),
// 			MinHealthyTime:   helper.TimeToPtr(1 * time.Minute),
// 			HealthyDeadline:  helper.TimeToPtr(3 * time.Minute),
// 			ProgressDeadline: helper.TimeToPtr(3 * time.Minute),
// 			AutoRevert:       helper.BoolToPtr(false),
// 			AutoPromote:      nil,
// 			Canary:           helper.IntToPtr(1),
// 		},
// 		TaskGroups: []*api.TaskGroup{
// 			{
// 				Update: &api.UpdateStrategy{
// 					Canary:     helper.IntToPtr(2),
// 					AutoRevert: helper.BoolToPtr(true),
// 				},
// 			}, {
// 				Update: &api.UpdateStrategy{
// 					Canary:      helper.IntToPtr(3),
// 					AutoPromote: helper.BoolToPtr(true),
// 				},
// 			},
// 		},
// 	}
//
// 	structsJob := ApiJobToStructJob(apiJob)
//
// 	// Update has been moved from job down to the groups
// 	jobUpdate := structs.UpdateStrategy{
// 		Stagger:          1000000000,
// 		MaxParallel:      5,
// 		HealthCheck:      "",
// 		MinHealthyTime:   0,
// 		HealthyDeadline:  0,
// 		ProgressDeadline: 0,
// 		AutoRevert:       false,
// 		AutoPromote:      false,
// 		Canary:           0,
// 	}
//
// 	// But the groups inherit settings from the job update
// 	group1 := structs.UpdateStrategy{
// 		Stagger:          1000000000,
// 		MaxParallel:      5,
// 		HealthCheck:      "manual",
// 		MinHealthyTime:   60000000000,
// 		HealthyDeadline:  180000000000,
// 		ProgressDeadline: 180000000000,
// 		AutoRevert:       true,
// 		AutoPromote:      false,
// 		Canary:           2,
// 	}
//
// 	group2 := structs.UpdateStrategy{
// 		Stagger:          1000000000,
// 		MaxParallel:      5,
// 		HealthCheck:      "manual",
// 		MinHealthyTime:   60000000000,
// 		HealthyDeadline:  180000000000,
// 		ProgressDeadline: 180000000000,
// 		AutoRevert:       false,
// 		AutoPromote:      true,
// 		Canary:           3,
// 	}
//
// 	require.Equal(t, jobUpdate, structsJob.Update)
// 	require.Equal(t, group1, *structsJob.TaskGroups[0].Update)
// 	require.Equal(t, group2, *structsJob.TaskGroups[1].Update)
// }
//
// // TestHTTP_JobValidate_SystemMigrate asserts that a system job with a migrate
// // stanza fails to validate but does not panic (see #5477).
// func TestHTTP_JobValidate_SystemMigrate(t *testing.T) {
// 	t.Parallel()
// 	httpTest(t, nil, func(s *TestAgent) {
// 		// Create the job
// 		job := &api.Job{
// 			Region:      helper.StringToPtr("global"),
// 			Datacenters: []string{"dc1"},
// 			ID:          helper.StringToPtr("systemmigrate"),
// 			Name:        helper.StringToPtr("systemmigrate"),
// 			TaskGroups: []*api.TaskGroup{
// 				{Name: helper.StringToPtr("web")},
// 			},
//
// 			// System job...
// 			Type: helper.StringToPtr("system"),
//
// 			// ...with an empty migrate stanza
// 			Migrate: &api.MigrateStrategy{},
// 		}
//
// 		args := api.JobValidateRequest{
// 			Job:          job,
// 			WriteRequest: api.WriteRequest{Region: "global"},
// 		}
// 		buf := encodeReq(args)
//
// 		// Make the HTTP request
// 		req, err := http.NewRequest("PUT", "/v1/validate/job", buf)
// 		require.NoError(t, err)
// 		respW := httptest.NewRecorder()
//
// 		// Make the request
// 		obj, err := s.Server.ValidateJobRequest(respW, req)
// 		require.NoError(t, err)
//
// 		// Check the response
// 		resp := obj.(structs.JobValidateResponse)
// 		require.Contains(t, resp.Error, `Job type "system" does not allow migrate block`)
// 	})
// }