github.com/hernad/nomad@v1.6.112/nomad/structs/job_test.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package structs
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/hashicorp/go-set"
    10  	"github.com/shoenig/test/must"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  func TestServiceRegistrationsRequest_StaleReadSupport(t *testing.T) {
    15  	req := &AllocServiceRegistrationsRequest{}
    16  	require.True(t, req.IsRead())
    17  }
    18  
    19  func TestJob_RequiresNativeServiceDiscovery(t *testing.T) {
    20  	testCases := []struct {
    21  		name      string
    22  		inputJob  *Job
    23  		expBasic  []string
    24  		expChecks []string
    25  	}{
    26  		{
    27  			name: "multiple group services with Nomad provider",
    28  			inputJob: &Job{
    29  				TaskGroups: []*TaskGroup{
    30  					{
    31  						Name: "group1",
    32  						Services: []*Service{
    33  							{Provider: "nomad"},
    34  							{Provider: "nomad"},
    35  						},
    36  					},
    37  					{
    38  						Name: "group2",
    39  						Services: []*Service{
    40  							{Provider: "nomad"},
    41  							{Provider: "nomad"},
    42  						},
    43  					},
    44  				},
    45  			},
    46  			expBasic:  []string{"group1", "group2"},
    47  			expChecks: nil,
    48  		},
    49  		{
    50  			name: "multiple group services with Nomad provider with checks",
    51  			inputJob: &Job{
    52  				TaskGroups: []*TaskGroup{
    53  					{
    54  						Name: "group1",
    55  						Services: []*Service{
    56  							{Provider: "nomad", Checks: []*ServiceCheck{{Name: "c1"}}},
    57  							{Provider: "nomad"},
    58  						},
    59  					},
    60  					{
    61  						Name: "group2",
    62  						Services: []*Service{
    63  							{Provider: "nomad"},
    64  						},
    65  					},
    66  					{
    67  						Name: "group3",
    68  						Services: []*Service{
    69  							{Provider: "nomad"},
    70  							{Provider: "nomad", Checks: []*ServiceCheck{{Name: "c2"}}},
    71  						},
    72  					},
    73  				},
    74  			},
    75  			expBasic:  []string{"group1", "group2", "group3"},
    76  			expChecks: []string{"group1", "group3"},
    77  		},
    78  		{
    79  			name: "multiple task services with Nomad provider",
    80  			inputJob: &Job{
    81  				TaskGroups: []*TaskGroup{
    82  					{
    83  						Name: "group1",
    84  						Tasks: []*Task{
    85  							{
    86  								Services: []*Service{
    87  									{Provider: "nomad"},
    88  									{Provider: "nomad"},
    89  								},
    90  							},
    91  							{
    92  								Services: []*Service{
    93  									{Provider: "nomad"},
    94  									{Provider: "nomad"},
    95  								},
    96  							},
    97  						},
    98  					},
    99  					{
   100  						Name: "group2",
   101  						Tasks: []*Task{
   102  							{
   103  								Services: []*Service{
   104  									{Provider: "nomad"},
   105  									{Provider: "nomad"},
   106  								},
   107  							},
   108  							{
   109  								Services: []*Service{
   110  									{Provider: "nomad"},
   111  									{Provider: "nomad", Checks: []*ServiceCheck{{Name: "c1"}}},
   112  								},
   113  							},
   114  						},
   115  					},
   116  				},
   117  			},
   118  			expBasic:  []string{"group1", "group2"},
   119  			expChecks: []string{"group2"},
   120  		},
   121  		{
   122  			name: "multiple group services with Consul provider",
   123  			inputJob: &Job{
   124  				TaskGroups: []*TaskGroup{
   125  					{
   126  						Name: "group1",
   127  						Services: []*Service{
   128  							{Provider: "consul"},
   129  							{Provider: "consul"},
   130  						},
   131  					},
   132  					{
   133  						Name: "group2",
   134  						Services: []*Service{
   135  							{Provider: "consul"},
   136  							{Provider: "consul"},
   137  						},
   138  					},
   139  				},
   140  			},
   141  			expBasic:  nil,
   142  			expChecks: nil,
   143  		},
   144  		{
   145  			name: "multiple task services with Consul provider",
   146  			inputJob: &Job{
   147  				TaskGroups: []*TaskGroup{
   148  					{
   149  						Name: "group1",
   150  						Tasks: []*Task{
   151  							{
   152  								Services: []*Service{
   153  									{Provider: "consul"},
   154  									{Provider: "consul"},
   155  								},
   156  							},
   157  							{
   158  								Services: []*Service{
   159  									{Provider: "consul"},
   160  									{Provider: "consul"},
   161  								},
   162  							},
   163  						},
   164  					},
   165  					{
   166  						Name: "group2",
   167  						Tasks: []*Task{
   168  							{
   169  								Services: []*Service{
   170  									{Provider: "consul"},
   171  									{Provider: "consul"},
   172  								},
   173  							},
   174  							{
   175  								Services: []*Service{
   176  									{Provider: "consul"},
   177  									{Provider: "consul"},
   178  								},
   179  							},
   180  						},
   181  					},
   182  				},
   183  			},
   184  			expBasic:  nil,
   185  			expChecks: nil,
   186  		},
   187  	}
   188  
   189  	for _, tc := range testCases {
   190  		t.Run(tc.name, func(t *testing.T) {
   191  			nsdUsage := tc.inputJob.RequiredNativeServiceDiscovery()
   192  			must.Equal(t, set.From(tc.expBasic), nsdUsage.Basic)
   193  			must.Equal(t, set.From(tc.expChecks), nsdUsage.Checks)
   194  		})
   195  	}
   196  }
   197  
   198  func TestJob_RequiredConsulServiceDiscovery(t *testing.T) {
   199  	testCases := []struct {
   200  		inputJob       *Job
   201  		expectedOutput map[string]bool
   202  		name           string
   203  	}{
   204  		{
   205  			inputJob: &Job{
   206  				TaskGroups: []*TaskGroup{
   207  					{
   208  						Name: "group1",
   209  						Services: []*Service{
   210  							{Provider: "consul"},
   211  							{Provider: "consul"},
   212  						},
   213  					},
   214  					{
   215  						Name: "group2",
   216  						Services: []*Service{
   217  							{Provider: "consul"},
   218  							{Provider: "consul"},
   219  						},
   220  					},
   221  				},
   222  			},
   223  			expectedOutput: map[string]bool{"group1": true, "group2": true},
   224  			name:           "multiple group services with Consul provider",
   225  		},
   226  		{
   227  			inputJob: &Job{
   228  				TaskGroups: []*TaskGroup{
   229  					{
   230  						Name: "group1",
   231  						Tasks: []*Task{
   232  							{
   233  								Services: []*Service{
   234  									{Provider: "consul"},
   235  									{Provider: "consul"},
   236  								},
   237  							},
   238  							{
   239  								Services: []*Service{
   240  									{Provider: "consul"},
   241  									{Provider: "consul"},
   242  								},
   243  							},
   244  						},
   245  					},
   246  					{
   247  						Name: "group2",
   248  						Tasks: []*Task{
   249  							{
   250  								Services: []*Service{
   251  									{Provider: "consul"},
   252  									{Provider: "consul"},
   253  								},
   254  							},
   255  							{
   256  								Services: []*Service{
   257  									{Provider: "consul"},
   258  									{Provider: "consul"},
   259  								},
   260  							},
   261  						},
   262  					},
   263  				},
   264  			},
   265  			expectedOutput: map[string]bool{"group1": true, "group2": true},
   266  			name:           "multiple task services with Consul provider",
   267  		},
   268  		{
   269  			inputJob: &Job{
   270  				TaskGroups: []*TaskGroup{
   271  					{
   272  						Name: "group1",
   273  						Services: []*Service{
   274  							{Provider: "nomad"},
   275  							{Provider: "nomad"},
   276  						},
   277  					},
   278  					{
   279  						Name: "group2",
   280  						Services: []*Service{
   281  							{Provider: "nomad"},
   282  							{Provider: "nomad"},
   283  						},
   284  					},
   285  				},
   286  			},
   287  			expectedOutput: map[string]bool{},
   288  			name:           "multiple group services with Nomad provider",
   289  		},
   290  		{
   291  			inputJob: &Job{
   292  				TaskGroups: []*TaskGroup{
   293  					{
   294  						Name: "group1",
   295  						Tasks: []*Task{
   296  							{
   297  								Services: []*Service{
   298  									{Provider: "nomad"},
   299  									{Provider: "nomad"},
   300  								},
   301  							},
   302  							{
   303  								Services: []*Service{
   304  									{Provider: "nomad"},
   305  									{Provider: "nomad"},
   306  								},
   307  							},
   308  						},
   309  					},
   310  					{
   311  						Name: "group2",
   312  						Tasks: []*Task{
   313  							{
   314  								Services: []*Service{
   315  									{Provider: "nomad"},
   316  									{Provider: "nomad"},
   317  								},
   318  							},
   319  							{
   320  								Services: []*Service{
   321  									{Provider: "nomad"},
   322  									{Provider: "nomad"},
   323  								},
   324  							},
   325  						},
   326  					},
   327  				},
   328  			},
   329  			expectedOutput: map[string]bool{},
   330  			name:           "multiple task services with Nomad provider",
   331  		},
   332  	}
   333  
   334  	for _, tc := range testCases {
   335  		t.Run(tc.name, func(t *testing.T) {
   336  			actualOutput := tc.inputJob.RequiredConsulServiceDiscovery()
   337  			require.Equal(t, tc.expectedOutput, actualOutput)
   338  		})
   339  	}
   340  }