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

     1  package overlay
     2  
     3  import (
     4  	"net"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/docker/docker/pkg/plugingetter"
     9  	"github.com/docker/libkv/store/consul"
    10  	"github.com/docker/libnetwork/datastore"
    11  	"github.com/docker/libnetwork/discoverapi"
    12  	"github.com/docker/libnetwork/driverapi"
    13  	"github.com/docker/libnetwork/netlabel"
    14  	_ "github.com/docker/libnetwork/testutils"
    15  )
    16  
    17  func init() {
    18  	consul.Register()
    19  }
    20  
    21  type driverTester struct {
    22  	t *testing.T
    23  	d *driver
    24  }
    25  
    26  const testNetworkType = "overlay"
    27  
    28  func setupDriver(t *testing.T) *driverTester {
    29  	dt := &driverTester{t: t}
    30  	config := make(map[string]interface{})
    31  	config[netlabel.GlobalKVClient] = discoverapi.DatastoreConfigData{
    32  		Scope:    datastore.GlobalScope,
    33  		Provider: "consul",
    34  		Address:  "127.0.0.01:8500",
    35  	}
    36  
    37  	if err := Init(dt, config); err != nil {
    38  		t.Fatal(err)
    39  	}
    40  
    41  	iface, err := net.InterfaceByName("eth0")
    42  	if err != nil {
    43  		t.Fatal(err)
    44  	}
    45  	addrs, err := iface.Addrs()
    46  	if err != nil || len(addrs) == 0 {
    47  		t.Fatal(err)
    48  	}
    49  	data := discoverapi.NodeDiscoveryData{
    50  		Address: addrs[0].String(),
    51  		Self:    true,
    52  	}
    53  	dt.d.DiscoverNew(discoverapi.NodeDiscovery, data)
    54  	return dt
    55  }
    56  
    57  func cleanupDriver(t *testing.T, dt *driverTester) {
    58  	ch := make(chan struct{})
    59  	go func() {
    60  		Fini(dt.d)
    61  		close(ch)
    62  	}()
    63  
    64  	select {
    65  	case <-ch:
    66  	case <-time.After(10 * time.Second):
    67  		t.Fatal("test timed out because Fini() did not return on time")
    68  	}
    69  }
    70  
    71  func (dt *driverTester) GetPluginGetter() plugingetter.PluginGetter {
    72  	return nil
    73  }
    74  
    75  func (dt *driverTester) RegisterDriver(name string, drv driverapi.Driver,
    76  	cap driverapi.Capability) error {
    77  	if name != testNetworkType {
    78  		dt.t.Fatalf("Expected driver register name to be %q. Instead got %q",
    79  			testNetworkType, name)
    80  	}
    81  
    82  	if _, ok := drv.(*driver); !ok {
    83  		dt.t.Fatalf("Expected driver type to be %T. Instead got %T",
    84  			&driver{}, drv)
    85  	}
    86  
    87  	dt.d = drv.(*driver)
    88  	return nil
    89  }
    90  
    91  func TestOverlayInit(t *testing.T) {
    92  	if err := Init(&driverTester{t: t}, nil); err != nil {
    93  		t.Fatal(err)
    94  	}
    95  }
    96  
    97  func TestOverlayFiniWithoutConfig(t *testing.T) {
    98  	dt := &driverTester{t: t}
    99  	if err := Init(dt, nil); err != nil {
   100  		t.Fatal(err)
   101  	}
   102  
   103  	cleanupDriver(t, dt)
   104  }
   105  
   106  func TestOverlayConfig(t *testing.T) {
   107  	dt := setupDriver(t)
   108  
   109  	time.Sleep(1 * time.Second)
   110  
   111  	d := dt.d
   112  	if d.notifyCh == nil {
   113  		t.Fatal("Driver notify channel wasn't initialzed after Config method")
   114  	}
   115  
   116  	if d.exitCh == nil {
   117  		t.Fatal("Driver serfloop exit channel wasn't initialzed after Config method")
   118  	}
   119  
   120  	if d.serfInstance == nil {
   121  		t.Fatal("Driver serfinstance  hasn't been initialized after Config method")
   122  	}
   123  
   124  	cleanupDriver(t, dt)
   125  }
   126  
   127  func TestOverlayType(t *testing.T) {
   128  	dt := &driverTester{t: t}
   129  	if err := Init(dt, nil); err != nil {
   130  		t.Fatal(err)
   131  	}
   132  
   133  	if dt.d.Type() != testNetworkType {
   134  		t.Fatalf("Expected Type() to return %q. Instead got %q", testNetworkType,
   135  			dt.d.Type())
   136  	}
   137  }