github.com/iqoqo/nomad@v0.11.3-0.20200911112621-d7021c74d101/client/allocrunner/network_manager_linux_test.go (about)

     1  package allocrunner
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/hashicorp/nomad/client/pluginmanager"
     7  	"github.com/hashicorp/nomad/nomad/structs"
     8  	"github.com/hashicorp/nomad/plugins/drivers"
     9  	"github.com/hashicorp/nomad/plugins/drivers/testutils"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  var mockDrivers = map[string]drivers.DriverPlugin{
    14  	"hostonly": &testutils.MockDriver{
    15  		CapabilitiesF: func() (*drivers.Capabilities, error) {
    16  			return &drivers.Capabilities{
    17  				NetIsolationModes: []drivers.NetIsolationMode{drivers.NetIsolationModeHost},
    18  			}, nil
    19  		},
    20  	},
    21  	"group1": &testutils.MockDriver{
    22  		CapabilitiesF: func() (*drivers.Capabilities, error) {
    23  			return &drivers.Capabilities{
    24  				NetIsolationModes: []drivers.NetIsolationMode{
    25  					drivers.NetIsolationModeHost, drivers.NetIsolationModeGroup},
    26  			}, nil
    27  		},
    28  	},
    29  	"group2": &testutils.MockDriver{
    30  		CapabilitiesF: func() (*drivers.Capabilities, error) {
    31  			return &drivers.Capabilities{
    32  				NetIsolationModes: []drivers.NetIsolationMode{
    33  					drivers.NetIsolationModeHost, drivers.NetIsolationModeGroup},
    34  			}, nil
    35  		},
    36  	},
    37  	"mustinit1": &testutils.MockDriver{
    38  		CapabilitiesF: func() (*drivers.Capabilities, error) {
    39  			return &drivers.Capabilities{
    40  				NetIsolationModes: []drivers.NetIsolationMode{
    41  					drivers.NetIsolationModeHost, drivers.NetIsolationModeGroup},
    42  				MustInitiateNetwork: true,
    43  			}, nil
    44  		},
    45  	},
    46  	"mustinit2": &testutils.MockDriver{
    47  		CapabilitiesF: func() (*drivers.Capabilities, error) {
    48  			return &drivers.Capabilities{
    49  				NetIsolationModes: []drivers.NetIsolationMode{
    50  					drivers.NetIsolationModeHost, drivers.NetIsolationModeGroup},
    51  				MustInitiateNetwork: true,
    52  			}, nil
    53  		},
    54  	},
    55  }
    56  
    57  type mockDriverManager struct {
    58  	pluginmanager.MockPluginManager
    59  }
    60  
    61  func (m *mockDriverManager) Dispense(driver string) (drivers.DriverPlugin, error) {
    62  	return mockDrivers[driver], nil
    63  }
    64  
    65  func TestNewNetworkManager(t *testing.T) {
    66  	for _, tc := range []struct {
    67  		name        string
    68  		alloc       *structs.Allocation
    69  		err         bool
    70  		mustInit    bool
    71  		errContains string
    72  	}{
    73  		{
    74  			name: "defaults/backwards compat",
    75  			alloc: &structs.Allocation{
    76  				TaskGroup: "group",
    77  				Job: &structs.Job{
    78  					TaskGroups: []*structs.TaskGroup{
    79  						{
    80  							Name:     "group",
    81  							Networks: []*structs.NetworkResource{},
    82  							Tasks: []*structs.Task{
    83  								{
    84  									Name:      "task1",
    85  									Driver:    "group1",
    86  									Resources: &structs.Resources{},
    87  								},
    88  								{
    89  									Name:      "task2",
    90  									Driver:    "group2",
    91  									Resources: &structs.Resources{},
    92  								},
    93  								{
    94  									Name:      "task3",
    95  									Driver:    "mustinit1",
    96  									Resources: &structs.Resources{},
    97  								},
    98  							},
    99  						},
   100  					},
   101  				},
   102  			},
   103  		},
   104  		{
   105  			name: "driver /w must init network",
   106  			alloc: &structs.Allocation{
   107  				TaskGroup: "group",
   108  				Job: &structs.Job{
   109  					TaskGroups: []*structs.TaskGroup{
   110  						{
   111  							Name: "group",
   112  							Networks: []*structs.NetworkResource{
   113  								{
   114  									Mode: "bridge",
   115  								},
   116  							},
   117  							Tasks: []*structs.Task{
   118  								{
   119  									Name:      "task1",
   120  									Driver:    "group1",
   121  									Resources: &structs.Resources{},
   122  								},
   123  								{
   124  									Name:      "task2",
   125  									Driver:    "mustinit2",
   126  									Resources: &structs.Resources{},
   127  								},
   128  							},
   129  						},
   130  					},
   131  				},
   132  			},
   133  			mustInit: true,
   134  		},
   135  		{
   136  			name: "multiple mustinit",
   137  			alloc: &structs.Allocation{
   138  				TaskGroup: "group",
   139  				Job: &structs.Job{
   140  					TaskGroups: []*structs.TaskGroup{
   141  						{
   142  							Name: "group",
   143  							Networks: []*structs.NetworkResource{
   144  								{
   145  									Mode: "bridge",
   146  								},
   147  							},
   148  							Tasks: []*structs.Task{
   149  								{
   150  									Name:      "task1",
   151  									Driver:    "mustinit1",
   152  									Resources: &structs.Resources{},
   153  								},
   154  								{
   155  									Name:      "task2",
   156  									Driver:    "mustinit2",
   157  									Resources: &structs.Resources{},
   158  								},
   159  							},
   160  						},
   161  					},
   162  				},
   163  			},
   164  			err:         true,
   165  			errContains: "want to initiate networking but only one",
   166  		},
   167  	} {
   168  		t.Run(tc.name, func(t *testing.T) {
   169  			require := require.New(t)
   170  			nm, err := newNetworkManager(tc.alloc, &mockDriverManager{})
   171  			if tc.err {
   172  				require.Error(err)
   173  				require.Contains(err.Error(), tc.errContains)
   174  			} else {
   175  				require.NoError(err)
   176  			}
   177  
   178  			if tc.mustInit {
   179  				_, ok := nm.(*testutils.MockDriver)
   180  				require.True(ok)
   181  			} else if tc.err {
   182  				require.Nil(nm)
   183  			} else {
   184  				_, ok := nm.(*defaultNetworkManager)
   185  				require.True(ok)
   186  			}
   187  		})
   188  	}
   189  
   190  }