github.com/rawahars/moby@v24.0.4+incompatible/libnetwork/drvregistry/drvregistry_test.go (about)

     1  package drvregistry
     2  
     3  import (
     4  	"runtime"
     5  	"sort"
     6  	"testing"
     7  
     8  	"github.com/docker/docker/libnetwork/datastore"
     9  	"github.com/docker/docker/libnetwork/driverapi"
    10  	"github.com/docker/docker/libnetwork/ipamapi"
    11  	builtinIpam "github.com/docker/docker/libnetwork/ipams/builtin"
    12  	nullIpam "github.com/docker/docker/libnetwork/ipams/null"
    13  	remoteIpam "github.com/docker/docker/libnetwork/ipams/remote"
    14  	"gotest.tools/v3/assert"
    15  	is "gotest.tools/v3/assert/cmp"
    16  )
    17  
    18  const mockDriverName = "mock-driver"
    19  
    20  type mockDriver struct {
    21  	driverapi.Driver
    22  }
    23  
    24  var mockDriverCaps = driverapi.Capability{DataScope: datastore.LocalScope}
    25  
    26  var md = mockDriver{}
    27  
    28  func mockDriverInit(reg driverapi.DriverCallback, opt map[string]interface{}) error {
    29  	return reg.RegisterDriver(mockDriverName, &md, mockDriverCaps)
    30  }
    31  
    32  func (m *mockDriver) Type() string {
    33  	return mockDriverName
    34  }
    35  
    36  func (m *mockDriver) IsBuiltIn() bool {
    37  	return true
    38  }
    39  
    40  func getNew(t *testing.T) *DrvRegistry {
    41  	reg, err := New(nil, nil, nil, nil, nil)
    42  	if err != nil {
    43  		t.Fatal(err)
    44  	}
    45  
    46  	err = initIPAMDrivers(reg)
    47  	if err != nil {
    48  		t.Fatal(err)
    49  	}
    50  	return reg
    51  }
    52  
    53  func initIPAMDrivers(r *DrvRegistry) error {
    54  	for _, fn := range [](func(ipamapi.Callback, interface{}, interface{}) error){
    55  		builtinIpam.Init, //nolint:staticcheck
    56  		remoteIpam.Init,  //nolint:staticcheck
    57  		nullIpam.Init,    //nolint:staticcheck
    58  	} {
    59  		if err := fn(r, nil, nil); err != nil {
    60  			return err
    61  		}
    62  	}
    63  
    64  	return nil
    65  }
    66  func TestNew(t *testing.T) {
    67  	getNew(t)
    68  }
    69  
    70  func TestAddDriver(t *testing.T) {
    71  	reg := getNew(t)
    72  
    73  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
    74  	assert.NilError(t, err)
    75  }
    76  
    77  func TestAddDuplicateDriver(t *testing.T) {
    78  	reg := getNew(t)
    79  
    80  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
    81  	assert.NilError(t, err)
    82  
    83  	// Try adding the same driver
    84  	err = reg.AddDriver(mockDriverName, mockDriverInit, nil)
    85  	assert.Check(t, is.ErrorContains(err, ""))
    86  }
    87  
    88  func TestIPAMDefaultAddressSpaces(t *testing.T) {
    89  	reg := getNew(t)
    90  
    91  	as1, as2, err := reg.IPAMDefaultAddressSpaces("default")
    92  	assert.NilError(t, err)
    93  	assert.Check(t, as1 != "")
    94  	assert.Check(t, as2 != "")
    95  }
    96  
    97  func TestDriver(t *testing.T) {
    98  	reg := getNew(t)
    99  
   100  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   101  	assert.NilError(t, err)
   102  
   103  	d, cap := reg.Driver(mockDriverName)
   104  	assert.Check(t, d != nil)
   105  	assert.Check(t, cap != nil)
   106  }
   107  
   108  func TestIPAM(t *testing.T) {
   109  	reg := getNew(t)
   110  
   111  	i, cap := reg.IPAM("default")
   112  	assert.Check(t, i != nil)
   113  	assert.Check(t, cap != nil)
   114  }
   115  
   116  func TestWalkIPAMs(t *testing.T) {
   117  	reg := getNew(t)
   118  
   119  	ipams := make([]string, 0, 2)
   120  	reg.WalkIPAMs(func(name string, driver ipamapi.Ipam, cap *ipamapi.Capability) bool {
   121  		ipams = append(ipams, name)
   122  		return false
   123  	})
   124  
   125  	sort.Strings(ipams)
   126  	expected := []string{"default", "null"}
   127  	if runtime.GOOS == "windows" {
   128  		expected = append(expected, "windows")
   129  	}
   130  	assert.Check(t, is.DeepEqual(ipams, expected))
   131  }
   132  
   133  func TestWalkDrivers(t *testing.T) {
   134  	reg := getNew(t)
   135  
   136  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   137  	assert.NilError(t, err)
   138  
   139  	var driverName string
   140  	reg.WalkDrivers(func(name string, driver driverapi.Driver, capability driverapi.Capability) bool {
   141  		driverName = name
   142  		return false
   143  	})
   144  
   145  	assert.Check(t, is.Equal(driverName, mockDriverName))
   146  }