github.com/anth0d/nomad@v0.0.0-20221214183521-ae3a0a2cad06/nomad/structs/job_test.go (about)

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