github.com/kaisenlinux/docker.io@v0.0.0-20230510090727-ea55db55fac7/libnetwork/drvregistry/drvregistry_test.go (about)

     1  package drvregistry
     2  
     3  import (
     4  	"sort"
     5  	"testing"
     6  
     7  	"github.com/docker/libnetwork/datastore"
     8  	"github.com/docker/libnetwork/discoverapi"
     9  	"github.com/docker/libnetwork/driverapi"
    10  	"github.com/docker/libnetwork/ipamapi"
    11  	builtinIpam "github.com/docker/libnetwork/ipams/builtin"
    12  	nullIpam "github.com/docker/libnetwork/ipams/null"
    13  	remoteIpam "github.com/docker/libnetwork/ipams/remote"
    14  	"gotest.tools/v3/assert"
    15  	is "gotest.tools/v3/assert/cmp"
    16  
    17  	// this takes care of the incontainer flag
    18  	_ "github.com/docker/libnetwork/testutils"
    19  )
    20  
    21  const mockDriverName = "mock-driver"
    22  
    23  type mockDriver struct{}
    24  
    25  var md = mockDriver{}
    26  
    27  func mockDriverInit(reg driverapi.DriverCallback, opt map[string]interface{}) error {
    28  	return reg.RegisterDriver(mockDriverName, &md, driverapi.Capability{DataScope: datastore.LocalScope})
    29  }
    30  
    31  func (m *mockDriver) CreateNetwork(nid string, options map[string]interface{}, nInfo driverapi.NetworkInfo, ipV4Data, ipV6Data []driverapi.IPAMData) error {
    32  	return nil
    33  }
    34  
    35  func (m *mockDriver) DeleteNetwork(nid string) error {
    36  	return nil
    37  }
    38  
    39  func (m *mockDriver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo, options map[string]interface{}) error {
    40  	return nil
    41  }
    42  
    43  func (m *mockDriver) DeleteEndpoint(nid, eid string) error {
    44  	return nil
    45  }
    46  
    47  func (m *mockDriver) EndpointOperInfo(nid, eid string) (map[string]interface{}, error) {
    48  	return nil, nil
    49  }
    50  
    51  func (m *mockDriver) Join(nid, eid string, sboxKey string, jinfo driverapi.JoinInfo, options map[string]interface{}) error {
    52  	return nil
    53  }
    54  
    55  func (m *mockDriver) Leave(nid, eid string) error {
    56  	return nil
    57  }
    58  
    59  func (m *mockDriver) DiscoverNew(dType discoverapi.DiscoveryType, data interface{}) error {
    60  	return nil
    61  }
    62  
    63  func (m *mockDriver) DiscoverDelete(dType discoverapi.DiscoveryType, data interface{}) error {
    64  	return nil
    65  }
    66  
    67  func (m *mockDriver) Type() string {
    68  	return mockDriverName
    69  }
    70  
    71  func (m *mockDriver) IsBuiltIn() bool {
    72  	return true
    73  }
    74  
    75  func (m *mockDriver) ProgramExternalConnectivity(nid, eid string, options map[string]interface{}) error {
    76  	return nil
    77  }
    78  
    79  func (m *mockDriver) RevokeExternalConnectivity(nid, eid string) error {
    80  	return nil
    81  }
    82  
    83  func (m *mockDriver) NetworkAllocate(id string, option map[string]string, ipV4Data, ipV6Data []driverapi.IPAMData) (map[string]string, error) {
    84  	return nil, nil
    85  }
    86  
    87  func (m *mockDriver) NetworkFree(id string) error {
    88  	return nil
    89  }
    90  
    91  func (m *mockDriver) EventNotify(etype driverapi.EventType, nid, tableName, key string, value []byte) {
    92  }
    93  
    94  func (m *mockDriver) DecodeTableEntry(tablename string, key string, value []byte) (string, map[string]string) {
    95  	return "", nil
    96  }
    97  
    98  func getNew(t *testing.T) *DrvRegistry {
    99  	reg, err := New(nil, nil, nil, nil, nil)
   100  	if err != nil {
   101  		t.Fatal(err)
   102  	}
   103  
   104  	err = initIPAMDrivers(reg, nil, nil)
   105  	if err != nil {
   106  		t.Fatal(err)
   107  	}
   108  	return reg
   109  }
   110  
   111  func initIPAMDrivers(r *DrvRegistry, lDs, gDs interface{}) error {
   112  	for _, fn := range [](func(ipamapi.Callback, interface{}, interface{}) error){
   113  		builtinIpam.Init,
   114  		remoteIpam.Init,
   115  		nullIpam.Init,
   116  	} {
   117  		if err := fn(r, lDs, gDs); err != nil {
   118  			return err
   119  		}
   120  	}
   121  
   122  	return nil
   123  }
   124  func TestNew(t *testing.T) {
   125  	getNew(t)
   126  }
   127  
   128  func TestAddDriver(t *testing.T) {
   129  	reg := getNew(t)
   130  
   131  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   132  	assert.NilError(t, err)
   133  }
   134  
   135  func TestAddDuplicateDriver(t *testing.T) {
   136  	reg := getNew(t)
   137  
   138  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   139  	assert.NilError(t, err)
   140  
   141  	// Try adding the same driver
   142  	err = reg.AddDriver(mockDriverName, mockDriverInit, nil)
   143  	assert.Check(t, is.ErrorContains(err, ""))
   144  }
   145  
   146  func TestIPAMDefaultAddressSpaces(t *testing.T) {
   147  	reg := getNew(t)
   148  
   149  	as1, as2, err := reg.IPAMDefaultAddressSpaces("default")
   150  	assert.NilError(t, err)
   151  	assert.Check(t, as1 != "")
   152  	assert.Check(t, as2 != "")
   153  }
   154  
   155  func TestDriver(t *testing.T) {
   156  	reg := getNew(t)
   157  
   158  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   159  	assert.NilError(t, err)
   160  
   161  	d, cap := reg.Driver(mockDriverName)
   162  	assert.Check(t, d != nil)
   163  	assert.Check(t, cap != nil)
   164  }
   165  
   166  func TestIPAM(t *testing.T) {
   167  	reg := getNew(t)
   168  
   169  	i, cap := reg.IPAM("default")
   170  	assert.Check(t, i != nil)
   171  	assert.Check(t, cap != nil)
   172  }
   173  
   174  func TestWalkIPAMs(t *testing.T) {
   175  	reg := getNew(t)
   176  
   177  	ipams := make([]string, 0, 2)
   178  	reg.WalkIPAMs(func(name string, driver ipamapi.Ipam, cap *ipamapi.Capability) bool {
   179  		ipams = append(ipams, name)
   180  		return false
   181  	})
   182  
   183  	sort.Strings(ipams)
   184  	assert.Check(t, is.DeepEqual(ipams, []string{"default", "null"}))
   185  }
   186  
   187  func TestWalkDrivers(t *testing.T) {
   188  	reg := getNew(t)
   189  
   190  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   191  	assert.NilError(t, err)
   192  
   193  	var driverName string
   194  	reg.WalkDrivers(func(name string, driver driverapi.Driver, capability driverapi.Capability) bool {
   195  		driverName = name
   196  		return false
   197  	})
   198  
   199  	assert.Check(t, is.Equal(driverName, mockDriverName))
   200  }