mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
6e4a572529
This commit brings in the first implementation of overlay driver which makes use of vxlan tunneling protocol to create logical networks across multiple hosts. This is very much alpha code and should be used for demo and testing purposes only. Signed-off-by: Jana Radhakrishnan <mrjana@docker.com>
130 lines
2.4 KiB
Go
130 lines
2.4 KiB
Go
package overlay
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/docker/libnetwork/driverapi"
|
|
)
|
|
|
|
type driverTester struct {
|
|
t *testing.T
|
|
d driverapi.Driver
|
|
}
|
|
|
|
const testNetworkType = "overlay"
|
|
|
|
func setupDriver(t *testing.T) *driverTester {
|
|
dt := &driverTester{t: t}
|
|
if err := Init(dt); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
opt := make(map[string]interface{})
|
|
if err := dt.d.Config(opt); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
return dt
|
|
}
|
|
|
|
func cleanupDriver(t *testing.T, dt *driverTester) {
|
|
ch := make(chan struct{})
|
|
go func() {
|
|
Fini(dt.d)
|
|
close(ch)
|
|
}()
|
|
|
|
select {
|
|
case <-ch:
|
|
case <-time.After(10 * time.Second):
|
|
t.Fatal("test timed out because Fini() did not return on time")
|
|
}
|
|
}
|
|
|
|
func (dt *driverTester) RegisterDriver(name string, drv driverapi.Driver,
|
|
cap driverapi.Capability) error {
|
|
if name != testNetworkType {
|
|
dt.t.Fatalf("Expected driver register name to be %q. Instead got %q",
|
|
testNetworkType, name)
|
|
}
|
|
|
|
if _, ok := drv.(*driver); !ok {
|
|
dt.t.Fatalf("Expected driver type to be %T. Instead got %T",
|
|
&driver{}, drv)
|
|
}
|
|
|
|
dt.d = drv.(*driver)
|
|
return nil
|
|
}
|
|
|
|
func TestOverlayInit(t *testing.T) {
|
|
if err := Init(&driverTester{t: t}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestOverlayFiniWithoutConfig(t *testing.T) {
|
|
dt := &driverTester{t: t}
|
|
if err := Init(dt); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cleanupDriver(t, dt)
|
|
}
|
|
|
|
func TestOverlayNilConfig(t *testing.T) {
|
|
dt := &driverTester{t: t}
|
|
if err := Init(dt); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := dt.d.Config(nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cleanupDriver(t, dt)
|
|
}
|
|
|
|
func TestOverlayConfig(t *testing.T) {
|
|
dt := setupDriver(t)
|
|
|
|
time.Sleep(1 * time.Second)
|
|
|
|
d := dt.d.(*driver)
|
|
if d.notifyCh == nil {
|
|
t.Fatal("Driver notify channel wasn't initialzed after Config method")
|
|
}
|
|
|
|
if d.exitCh == nil {
|
|
t.Fatal("Driver serfloop exit channel wasn't initialzed after Config method")
|
|
}
|
|
|
|
if d.serfInstance == nil {
|
|
t.Fatal("Driver serfinstance hasn't been initialized after Config method")
|
|
}
|
|
|
|
cleanupDriver(t, dt)
|
|
}
|
|
|
|
func TestOverlayMultipleConfig(t *testing.T) {
|
|
dt := setupDriver(t)
|
|
|
|
if err := dt.d.Config(nil); err == nil {
|
|
t.Fatal("Expected a failure, instead succeded")
|
|
}
|
|
|
|
cleanupDriver(t, dt)
|
|
}
|
|
|
|
func TestOverlayType(t *testing.T) {
|
|
dt := &driverTester{t: t}
|
|
if err := Init(dt); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if dt.d.Type() != testNetworkType {
|
|
t.Fatalf("Expected Type() to return %q. Instead got %q", testNetworkType,
|
|
dt.d.Type())
|
|
}
|
|
}
|