github.com/zhuohuang-hust/src-cbuild@v0.0.0-20230105071821-c7aab3e7c840/mergeCode/libnetwork/drvregistry/drvregistry_test.go (about)

     1  package drvregistry
     2  
     3  import (
     4  	"flag"
     5  	"sort"
     6  	"testing"
     7  
     8  	"github.com/docker/libnetwork/datastore"
     9  	"github.com/docker/libnetwork/discoverapi"
    10  	"github.com/docker/libnetwork/driverapi"
    11  	"github.com/docker/libnetwork/ipamapi"
    12  	builtinIpam "github.com/docker/libnetwork/ipams/builtin"
    13  	nullIpam "github.com/docker/libnetwork/ipams/null"
    14  	remoteIpam "github.com/docker/libnetwork/ipams/remote"
    15  	"github.com/stretchr/testify/assert"
    16  )
    17  
    18  var runningInContainer = flag.Bool("incontainer", false,
    19  	"Indicates if the test is running in a container")
    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) ProgramExternalConnectivity(nid, eid string, options map[string]interface{}) error {
    72  	return nil
    73  }
    74  
    75  func (m *mockDriver) RevokeExternalConnectivity(nid, eid string) error {
    76  	return nil
    77  }
    78  
    79  func (m *mockDriver) NetworkAllocate(id string, option map[string]string, ipV4Data, ipV6Data []driverapi.IPAMData) (map[string]string, error) {
    80  	return nil, nil
    81  }
    82  
    83  func (m *mockDriver) NetworkFree(id string) error {
    84  	return nil
    85  }
    86  
    87  func (m *mockDriver) EventNotify(etype driverapi.EventType, nid, tableName, key string, value []byte) {
    88  }
    89  
    90  func getNew(t *testing.T) *DrvRegistry {
    91  	reg, err := New(nil, nil, nil, nil, nil)
    92  	if err != nil {
    93  		t.Fatal(err)
    94  	}
    95  
    96  	err = initIPAMDrivers(reg, nil, nil)
    97  	if err != nil {
    98  		t.Fatal(err)
    99  	}
   100  	return reg
   101  }
   102  
   103  func initIPAMDrivers(r *DrvRegistry, lDs, gDs interface{}) error {
   104  	for _, fn := range [](func(ipamapi.Callback, interface{}, interface{}) error){
   105  		builtinIpam.Init,
   106  		remoteIpam.Init,
   107  		nullIpam.Init,
   108  	} {
   109  		if err := fn(r, lDs, gDs); err != nil {
   110  			return err
   111  		}
   112  	}
   113  
   114  	return nil
   115  }
   116  func TestNew(t *testing.T) {
   117  	getNew(t)
   118  }
   119  
   120  func TestAddDriver(t *testing.T) {
   121  	reg := getNew(t)
   122  
   123  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   124  	assert.NoError(t, err)
   125  }
   126  
   127  func TestAddDuplicateDriver(t *testing.T) {
   128  	reg := getNew(t)
   129  
   130  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   131  	assert.NoError(t, err)
   132  
   133  	// Try adding the same driver
   134  	err = reg.AddDriver(mockDriverName, mockDriverInit, nil)
   135  	assert.Error(t, err)
   136  }
   137  
   138  func TestIPAMDefaultAddressSpaces(t *testing.T) {
   139  	reg := getNew(t)
   140  
   141  	as1, as2, err := reg.IPAMDefaultAddressSpaces("default")
   142  	assert.NoError(t, err)
   143  	assert.NotEqual(t, as1, "")
   144  	assert.NotEqual(t, as2, "")
   145  }
   146  
   147  func TestDriver(t *testing.T) {
   148  	reg := getNew(t)
   149  
   150  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   151  	assert.NoError(t, err)
   152  
   153  	d, cap := reg.Driver(mockDriverName)
   154  	assert.NotEqual(t, d, nil)
   155  	assert.NotEqual(t, cap, nil)
   156  }
   157  
   158  func TestIPAM(t *testing.T) {
   159  	reg := getNew(t)
   160  
   161  	i, cap := reg.IPAM("default")
   162  	assert.NotEqual(t, i, nil)
   163  	assert.NotEqual(t, cap, nil)
   164  }
   165  
   166  func TestWalkIPAMs(t *testing.T) {
   167  	reg := getNew(t)
   168  
   169  	ipams := make([]string, 0, 2)
   170  	reg.WalkIPAMs(func(name string, driver ipamapi.Ipam, cap *ipamapi.Capability) bool {
   171  		ipams = append(ipams, name)
   172  		return false
   173  	})
   174  
   175  	sort.Strings(ipams)
   176  	assert.Equal(t, ipams, []string{"default", "null"})
   177  }
   178  
   179  func TestWalkDrivers(t *testing.T) {
   180  	reg := getNew(t)
   181  
   182  	err := reg.AddDriver(mockDriverName, mockDriverInit, nil)
   183  	assert.NoError(t, err)
   184  
   185  	var driverName string
   186  	reg.WalkDrivers(func(name string, driver driverapi.Driver, capability driverapi.Capability) bool {
   187  		driverName = name
   188  		return false
   189  	})
   190  
   191  	assert.Equal(t, driverName, mockDriverName)
   192  }