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

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package config
     5  
     6  import (
     7  	"fmt"
     8  	"testing"
     9  
    10  	"github.com/hernad/nomad/ci"
    11  	"github.com/hernad/nomad/helper/pointer"
    12  	"github.com/shoenig/test/must"
    13  )
    14  
    15  func TestDrainConfig_Copy(t *testing.T) {
    16  	ci.Parallel(t)
    17  
    18  	testCases := []struct {
    19  		name             string
    20  		inputDrainConfig *DrainConfig
    21  		expectedOutput   *DrainConfig
    22  	}{
    23  		{
    24  			name:             "nil config",
    25  			inputDrainConfig: nil,
    26  			expectedOutput:   nil,
    27  		},
    28  		{
    29  			name: "partial config",
    30  			inputDrainConfig: &DrainConfig{
    31  				Deadline:         pointer.Of("5m"),
    32  				IgnoreSystemJobs: nil,
    33  				Force:            nil,
    34  			},
    35  			expectedOutput: &DrainConfig{
    36  				Deadline:         pointer.Of("5m"),
    37  				IgnoreSystemJobs: nil,
    38  				Force:            nil,
    39  			},
    40  		},
    41  		{
    42  			name: "full config",
    43  			inputDrainConfig: &DrainConfig{
    44  				Deadline:         pointer.Of("5m"),
    45  				IgnoreSystemJobs: pointer.Of(false),
    46  				Force:            pointer.Of(true),
    47  			},
    48  			expectedOutput: &DrainConfig{
    49  				Deadline:         pointer.Of("5m"),
    50  				IgnoreSystemJobs: pointer.Of(false),
    51  				Force:            pointer.Of(true),
    52  			},
    53  		},
    54  	}
    55  
    56  	for _, tc := range testCases {
    57  		t.Run(tc.name, func(t *testing.T) {
    58  			actualOutput := tc.inputDrainConfig.Copy()
    59  			must.Eq(t, tc.expectedOutput, actualOutput)
    60  
    61  			if tc.inputDrainConfig != nil {
    62  				must.NotEq(t, fmt.Sprintf("%p", tc.inputDrainConfig), fmt.Sprintf("%p", actualOutput))
    63  			}
    64  		})
    65  	}
    66  }
    67  
    68  func TestDrainConfig_Merge(t *testing.T) {
    69  	ci.Parallel(t)
    70  
    71  	testCases := []struct {
    72  		name             string
    73  		inputDrainConfig *DrainConfig
    74  		mergeDrainConfig *DrainConfig
    75  		expectedOutput   *DrainConfig
    76  	}{
    77  		{
    78  			name:             "nil",
    79  			inputDrainConfig: nil,
    80  			mergeDrainConfig: nil,
    81  			expectedOutput:   nil,
    82  		},
    83  		{
    84  			name:             "nil input",
    85  			inputDrainConfig: nil,
    86  			mergeDrainConfig: &DrainConfig{
    87  				Deadline:         pointer.Of("5m"),
    88  				IgnoreSystemJobs: pointer.Of(false),
    89  				Force:            pointer.Of(true),
    90  			},
    91  			expectedOutput: &DrainConfig{
    92  				Deadline:         pointer.Of("5m"),
    93  				IgnoreSystemJobs: pointer.Of(false),
    94  				Force:            pointer.Of(true),
    95  			},
    96  		},
    97  		{
    98  			name: "nil merge",
    99  			inputDrainConfig: &DrainConfig{
   100  				Deadline:         pointer.Of("5m"),
   101  				IgnoreSystemJobs: pointer.Of(false),
   102  				Force:            pointer.Of(true),
   103  			},
   104  			mergeDrainConfig: nil,
   105  			expectedOutput: &DrainConfig{
   106  				Deadline:         pointer.Of("5m"),
   107  				IgnoreSystemJobs: pointer.Of(false),
   108  				Force:            pointer.Of(true),
   109  			},
   110  		},
   111  		{
   112  			name: "partial",
   113  			inputDrainConfig: &DrainConfig{
   114  				Deadline:         pointer.Of("5m"),
   115  				IgnoreSystemJobs: pointer.Of(false),
   116  				Force:            nil,
   117  			},
   118  			mergeDrainConfig: &DrainConfig{
   119  				Deadline:         nil,
   120  				IgnoreSystemJobs: nil,
   121  				Force:            pointer.Of(true),
   122  			},
   123  			expectedOutput: &DrainConfig{
   124  				Deadline:         pointer.Of("5m"),
   125  				IgnoreSystemJobs: pointer.Of(false),
   126  				Force:            pointer.Of(true),
   127  			},
   128  		},
   129  	}
   130  
   131  	for _, tc := range testCases {
   132  		t.Run(tc.name, func(t *testing.T) {
   133  			actualOutput := tc.inputDrainConfig.Merge(tc.mergeDrainConfig)
   134  			must.Eq(t, tc.expectedOutput, actualOutput)
   135  		})
   136  	}
   137  }