github.com/hashicorp/nomad/api@v0.0.0-20240306165712-3193ac204f65/deployments_test.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package api
     5  
     6  import (
     7  	"fmt"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/hashicorp/nomad/api/internal/testutil"
    12  	"github.com/shoenig/test/must"
    13  	"github.com/shoenig/test/wait"
    14  )
    15  
    16  func TestDeployments_List(t *testing.T) {
    17  	testutil.Parallel(t)
    18  
    19  	c, s := makeClient(t, nil, nil)
    20  	defer s.Stop()
    21  	deployments := c.Deployments()
    22  	jobs := c.Jobs()
    23  
    24  	// Create a job of type service
    25  	job := testServiceJob()
    26  
    27  	// Initially there should be no deployment
    28  	resp0, _, err := deployments.List(nil)
    29  	must.NoError(t, err)
    30  	must.Len(t, 0, resp0)
    31  
    32  	// Register
    33  	resp1, wm, err := jobs.Register(job, nil)
    34  	must.NoError(t, err)
    35  	must.NotNil(t, resp1)
    36  	must.UUIDv4(t, resp1.EvalID)
    37  	assertWriteMeta(t, wm)
    38  
    39  	// Query the jobs back out again
    40  	resp2, qm, err := jobs.List(nil)
    41  	assertQueryMeta(t, qm)
    42  	must.NoError(t, err)
    43  	must.Len(t, 1, resp2)
    44  
    45  	f := func() error {
    46  		// List the deployment
    47  		resp3, _, err := deployments.List(nil)
    48  		if err != nil {
    49  			return err
    50  		}
    51  		if len(resp3) != 1 {
    52  			return fmt.Errorf(fmt.Sprintf("expected 1 deployment, found %v", len(resp3)))
    53  		}
    54  		return nil
    55  	}
    56  	must.Wait(t, wait.InitialSuccess(
    57  		wait.ErrorFunc(f),
    58  		wait.Timeout(3*time.Second),
    59  		wait.Gap(100*time.Millisecond),
    60  	))
    61  }
    62  
    63  func TestDeployments_PrefixList(t *testing.T) {
    64  	testutil.Parallel(t)
    65  
    66  	c, s := makeClient(t, nil, nil)
    67  	defer s.Stop()
    68  	deployments := c.Deployments()
    69  	jobs := c.Jobs()
    70  
    71  	// Initially there should be no deployment
    72  	resp, _, err := deployments.PrefixList("b1")
    73  	must.NoError(t, err)
    74  	must.Len(t, 0, resp)
    75  
    76  	// Create a job of type service
    77  	job := testServiceJob()
    78  
    79  	// Register the job
    80  	resp2, wm, err := jobs.Register(job, nil)
    81  	must.NoError(t, err)
    82  	must.NotNil(t, resp2)
    83  	must.UUIDv4(t, resp2.EvalID)
    84  	assertWriteMeta(t, wm)
    85  
    86  	// Query the jobs back out again
    87  	resp3, qm, err := jobs.List(nil)
    88  	assertQueryMeta(t, qm)
    89  	must.NoError(t, err)
    90  	must.Len(t, 1, resp3)
    91  
    92  	f := func() error {
    93  		// List the deployment
    94  		resp4, _, err := jobs.Deployments(resp3[0].ID, true, nil)
    95  		if len(resp4) != 1 {
    96  			return fmt.Errorf("expected 1 deployment, found %v", len(resp4))
    97  		}
    98  
    99  		// Prefix List
   100  		resp5, _, err := deployments.PrefixList(resp4[0].ID)
   101  		if err != nil {
   102  			return err
   103  		}
   104  		if len(resp5) != 1 {
   105  			return fmt.Errorf(fmt.Sprintf("expected 1 deployment, found %v", len(resp5)))
   106  		}
   107  		return nil
   108  	}
   109  	must.Wait(t, wait.InitialSuccess(
   110  		wait.ErrorFunc(f),
   111  		wait.Timeout(3*time.Second),
   112  		wait.Gap(100*time.Millisecond),
   113  	))
   114  }
   115  
   116  func TestDeployments_Info(t *testing.T) {
   117  	testutil.Parallel(t)
   118  
   119  	c, s := makeClient(t, nil, nil)
   120  	defer s.Stop()
   121  	deployments := c.Deployments()
   122  	jobs := c.Jobs()
   123  
   124  	// Create a job of type service
   125  	job := testServiceJob()
   126  
   127  	// Register
   128  	resp, wm, err := jobs.Register(job, nil)
   129  	must.NoError(t, err)
   130  	must.NotNil(t, resp)
   131  	must.UUIDv4(t, resp.EvalID)
   132  	assertWriteMeta(t, wm)
   133  
   134  	// Query the jobs
   135  	resp2, qm, err := jobs.List(nil)
   136  	assertQueryMeta(t, qm)
   137  	must.NoError(t, err)
   138  	must.Len(t, 1, resp2)
   139  
   140  	f := func() error {
   141  		// Get the deploymentID for Info
   142  		resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil)
   143  		if len(resp3) != 1 {
   144  			return fmt.Errorf("expected 1 deployment, found %v", len(resp3))
   145  		}
   146  
   147  		// Get Info using deployment ID
   148  		resp4, _, err := deployments.Info(resp3[0].ID, nil)
   149  		if err != nil {
   150  			return err
   151  		}
   152  		if resp4.JobID != resp2[0].ID {
   153  			return fmt.Errorf(fmt.Sprintf("expected job id: %v, found %v", resp4.JobID, resp2[0].ID))
   154  		}
   155  		if resp4.Namespace != resp2[0].Namespace {
   156  			return fmt.Errorf(fmt.Sprintf("expected deployment namespace: %v, found %v", resp4.Namespace, resp2[0].Namespace))
   157  		}
   158  		return nil
   159  	}
   160  	must.Wait(t, wait.InitialSuccess(
   161  		wait.ErrorFunc(f),
   162  		wait.Timeout(3*time.Second),
   163  		wait.Gap(100*time.Millisecond),
   164  	))
   165  }
   166  
   167  func TestDeployments_Allocations(t *testing.T) {
   168  	testutil.Parallel(t)
   169  
   170  	c, s := makeClient(t, nil, nil)
   171  	defer s.Stop()
   172  	deployments := c.Deployments()
   173  	jobs := c.Jobs()
   174  
   175  	// Create a job of type service
   176  	job := testServiceJob()
   177  
   178  	// Register
   179  	resp, wm, err := jobs.Register(job, nil)
   180  	must.NoError(t, err)
   181  	must.NotNil(t, resp)
   182  	must.UUIDv4(t, resp.EvalID)
   183  	assertWriteMeta(t, wm)
   184  
   185  	// Query the jobs
   186  	resp2, qm, err := jobs.List(nil)
   187  	assertQueryMeta(t, qm)
   188  	must.NoError(t, err)
   189  	must.Len(t, 1, resp2)
   190  
   191  	f := func() error {
   192  		// Get the deploymentID for Allocations
   193  		resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil)
   194  		if len(resp3) != 1 {
   195  			return fmt.Errorf("expected 1 deployment, found %v", len(resp3))
   196  		}
   197  
   198  		// Query deployment list
   199  		resp4, _, err := deployments.List(nil)
   200  		if err != nil {
   201  			return err
   202  		}
   203  		if len(resp4) != 1 {
   204  			return fmt.Errorf("expected 1 deployment, found %v", len(resp4))
   205  		}
   206  
   207  		// Get Allocations
   208  		resp5, _, err := deployments.Allocations(resp3[0].ID, nil)
   209  		if err != nil {
   210  			return err
   211  		}
   212  		if len(resp5) != 0 {
   213  			return fmt.Errorf("expected 0 Allocations, found %v", len(resp5))
   214  		}
   215  		return nil
   216  	}
   217  	must.Wait(t, wait.InitialSuccess(
   218  		wait.ErrorFunc(f),
   219  		wait.Timeout(3*time.Second),
   220  		wait.Gap(100*time.Millisecond),
   221  	))
   222  }
   223  
   224  func TestDeployments_Fail(t *testing.T) {
   225  	testutil.Parallel(t)
   226  
   227  	c, s := makeClient(t, nil, nil)
   228  	defer s.Stop()
   229  	deployments := c.Deployments()
   230  	jobs := c.Jobs()
   231  
   232  	// Create a job of type service
   233  	job := testServiceJob()
   234  
   235  	// Register
   236  	resp, wm, err := jobs.Register(job, nil)
   237  	must.NoError(t, err)
   238  	must.NotNil(t, resp)
   239  	must.UUIDv4(t, resp.EvalID)
   240  	assertWriteMeta(t, wm)
   241  
   242  	// Query the jobs
   243  	resp2, qm, err := jobs.List(nil)
   244  	assertQueryMeta(t, qm)
   245  	must.NoError(t, err)
   246  	must.Len(t, 1, resp2)
   247  
   248  	f := func() error {
   249  		// Get the deploymentID for Failing
   250  		resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil)
   251  		if len(resp3) != 1 {
   252  			return fmt.Errorf("expected 1 deployment, found %v", len(resp3))
   253  		}
   254  
   255  		// Fail Deployment
   256  		_, _, err = deployments.Fail(resp3[0].ID, nil)
   257  		if err != nil {
   258  			return err
   259  		}
   260  
   261  		// Query Info to check the status
   262  		resp4, _, err := deployments.Info(resp3[0].ID, nil)
   263  		if err != nil {
   264  			return err
   265  		}
   266  		if resp4.Status != "failed" {
   267  			return fmt.Errorf("expected failed status, got %v", resp4.Status)
   268  		}
   269  		return nil
   270  	}
   271  	must.Wait(t, wait.InitialSuccess(
   272  		wait.ErrorFunc(f),
   273  		wait.Timeout(3*time.Second),
   274  		wait.Gap(100*time.Millisecond),
   275  	))
   276  }
   277  
   278  func TestDeployments_Pause(t *testing.T) {
   279  	testutil.Parallel(t)
   280  
   281  	c, s := makeClient(t, nil, nil)
   282  	defer s.Stop()
   283  	deployments := c.Deployments()
   284  	jobs := c.Jobs()
   285  
   286  	// Create a job of type service
   287  	job := testServiceJob()
   288  
   289  	// Register
   290  	resp, wm, err := jobs.Register(job, nil)
   291  	must.NoError(t, err)
   292  	must.NotNil(t, resp)
   293  	must.UUIDv4(t, resp.EvalID)
   294  	assertWriteMeta(t, wm)
   295  
   296  	// Query the jobs
   297  	resp2, qm, err := jobs.List(nil)
   298  	assertQueryMeta(t, qm)
   299  	must.NoError(t, err)
   300  	must.Len(t, 1, resp2)
   301  
   302  	f := func() error {
   303  		// Get the deploymentID for pausing
   304  		resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil)
   305  		if len(resp3) != 1 {
   306  			return fmt.Errorf("expected 1 deployment, found %v", len(resp3))
   307  		}
   308  
   309  		// Pause Deployment
   310  		_, _, err = deployments.Pause(resp3[0].ID, true, nil)
   311  		if err != nil {
   312  			return err
   313  		}
   314  
   315  		// Query Info to check the status
   316  		resp4, _, err := deployments.Info(resp3[0].ID, nil)
   317  		if err != nil {
   318  			return err
   319  		}
   320  		if resp4.Status != "paused" {
   321  			return fmt.Errorf("expected paused status, got %v", resp4.Status)
   322  		}
   323  		return nil
   324  	}
   325  	must.Wait(t, wait.InitialSuccess(
   326  		wait.ErrorFunc(f),
   327  		wait.Timeout(3*time.Second),
   328  		wait.Gap(100*time.Millisecond),
   329  	))
   330  }
   331  
   332  func TestDeployments_Unpause(t *testing.T) {
   333  	testutil.Parallel(t)
   334  
   335  	c, s := makeClient(t, nil, nil)
   336  	defer s.Stop()
   337  	deployments := c.Deployments()
   338  	jobs := c.Jobs()
   339  
   340  	// Create a job of type service
   341  	job := testServiceJob()
   342  
   343  	// Register
   344  	resp, wm, err := jobs.Register(job, nil)
   345  	must.NoError(t, err)
   346  	must.NotNil(t, resp)
   347  	must.UUIDv4(t, resp.EvalID)
   348  	assertWriteMeta(t, wm)
   349  
   350  	// Query the jobs
   351  	resp2, qm, err := jobs.List(nil)
   352  	assertQueryMeta(t, qm)
   353  	must.NoError(t, err)
   354  	must.Len(t, 1, resp2)
   355  
   356  	f := func() error {
   357  		// Get the deploymentID for un-pausing
   358  		resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil)
   359  		if len(resp3) != 1 {
   360  			return fmt.Errorf("expected 1 deployment, found %v", len(resp3))
   361  		}
   362  
   363  		// Pause Deployment
   364  		_, _, err = deployments.Pause(resp3[0].ID, true, nil)
   365  		if err != nil {
   366  			return err
   367  		}
   368  
   369  		// Query Info to check the status
   370  		resp4, _, err := deployments.Info(resp3[0].ID, nil)
   371  		if err != nil {
   372  			return err
   373  		}
   374  		if resp4.Status != "paused" {
   375  			return fmt.Errorf("expected paused status, got %v", resp4.Status)
   376  		}
   377  
   378  		// UnPause the deployment
   379  		_, _, err = deployments.Pause(resp3[0].ID, false, nil)
   380  		must.NoError(t, err)
   381  
   382  		// Query Info again to check the status
   383  		resp5, _, err := deployments.Info(resp3[0].ID, nil)
   384  		if err != nil {
   385  			return err
   386  		}
   387  		if resp5.Status != "running" {
   388  			return fmt.Errorf("expected running status, got %v", resp5.Status)
   389  		}
   390  		return nil
   391  	}
   392  	must.Wait(t, wait.InitialSuccess(
   393  		wait.ErrorFunc(f),
   394  		wait.Timeout(3*time.Second),
   395  		wait.Gap(100*time.Millisecond),
   396  	))
   397  }