func TestSetupBadFixedCIDRv4(t *testing.T) { defer osl.SetupTestOSContext(t)() config := &networkConfiguration{ BridgeName: DefaultBridgeName, AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(24, 32)}, FixedCIDR: &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)}} br := &bridgeInterface{} if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } err := setupFixedCIDRv4(config, br) if err == nil { t.Fatal("Setup bridge FixedCIDRv4 should have failed") } if _, ok := err.(*FixedCIDRv4Error); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestSetupFixedCIDRv4(t *testing.T) { defer osl.SetupTestOSContext(t)() config := &networkConfiguration{ BridgeName: DefaultBridgeName, AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(16, 32)}, FixedCIDR: &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)}} br := &bridgeInterface{} if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } if err := setupFixedCIDRv4(config, br); err != nil { t.Fatalf("Failed to setup bridge FixedCIDRv4: %v", err) } if ip, err := ipAllocator.RequestIP(config.FixedCIDR, nil); err != nil { t.Fatalf("Failed to request IP to allocator: %v", err) } else if expected := "192.168.2.1"; ip.String() != expected { t.Fatalf("Expected allocated IP %s, got %s", expected, ip) } }
func TestSetupIPv6(t *testing.T) { defer osl.SetupTestOSContext(t)() config, br := setupTestInterface(t) if err := setupBridgeIPv6(config, br); err != nil { t.Fatalf("Failed to setup bridge IPv6: %v", err) } procSetting, err := ioutil.ReadFile(fmt.Sprintf("/proc/sys/net/ipv6/conf/%s/disable_ipv6", config.BridgeName)) if err != nil { t.Fatalf("Failed to read disable_ipv6 kernel setting: %v", err) } if expected := []byte("0\n"); bytes.Compare(expected, procSetting) != 0 { t.Fatalf("Invalid kernel setting disable_ipv6: expected %q, got %q", string(expected), string(procSetting)) } addrsv6, err := netlink.AddrList(br.Link, netlink.FAMILY_V6) if err != nil { t.Fatalf("Failed to list device IPv6 addresses: %v", err) } var found bool for _, addr := range addrsv6 { if bridgeIPv6Str == addr.IPNet.String() { found = true break } } if !found { t.Fatalf("Bridge device does not have requested IPv6 address %v", bridgeIPv6Str) } }
func TestSetupBridgeIPv4Fixed(t *testing.T) { defer osl.SetupTestOSContext(t)() ip, netw, err := net.ParseCIDR("192.168.1.1/24") if err != nil { t.Fatalf("Failed to parse bridge IPv4: %v", err) } config, br := setupTestInterface(t) config.AddressIPv4 = &net.IPNet{IP: ip, Mask: netw.Mask} if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Failed to setup bridge IPv4: %v", err) } addrsv4, err := netlink.AddrList(br.Link, netlink.FAMILY_V4) if err != nil { t.Fatalf("Failed to list device IPv4 addresses: %v", err) } var found bool for _, addr := range addrsv4 { if config.AddressIPv4.String() == addr.IPNet.String() { found = true break } } if !found { t.Fatalf("Bridge device does not have requested IPv4 address %v", config.AddressIPv4) } }
func TestLinkCreateTwo(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } config := &networkConfiguration{ BridgeName: DefaultBridgeName, EnableIPv6: true} genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config err := d.CreateNetwork("dummy", genericOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te1 := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te1, nil) if err != nil { t.Fatalf("Failed to create a link: %s", err.Error()) } te2 := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te2, nil) if err != nil { if _, ok := err.(driverapi.ErrEndpointExists); !ok { t.Fatalf("Failed with a wrong error: %s", err.Error()) } } else { t.Fatalf("Expected to fail while trying to add same endpoint twice") } }
func TestCreate(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } netconfig := &networkConfiguration{BridgeName: DefaultBridgeName} genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = netconfig if err := d.CreateNetwork("dummy", genericOption); err != nil { t.Fatalf("Failed to create bridge: %v", err) } err := d.CreateNetwork("dummy", genericOption) if err == nil { t.Fatalf("Expected bridge driver to refuse creation of second network with default name") } if _, ok := err.(types.ForbiddenError); !ok { t.Fatalf("Creation of second network with default name failed with unexpected error type") } err = d.DeleteNetwork("dummy") if err == nil { t.Fatalf("deletion of network with default name should fail on this driver") } if _, ok := err.(types.ForbiddenError); !ok { t.Fatalf("deletion of network with default name failed with unexpected error type") } }
func TestSetupBridgeIPv4Auto(t *testing.T) { defer osl.SetupTestOSContext(t)() config, br := setupTestInterface(t) if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Failed to setup bridge IPv4: %v", err) } addrsv4, err := netlink.AddrList(br.Link, netlink.FAMILY_V4) if err != nil { t.Fatalf("Failed to list device IPv4 addresses: %v", err) } var found bool for _, addr := range addrsv4 { if bridgeNetworks[0].String() == addr.IPNet.String() { found = true break } } if !found { t.Fatalf("Bridge device does not have the automatic IPv4 address %v", bridgeNetworks[0].String()) } }
func TestLinkCreateNoEnableIPv6(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } config := &networkConfiguration{ BridgeName: DefaultBridgeName} genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config err := d.CreateNetwork("dummy", genericOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te, nil) if err != nil { t.Fatalf("Failed to create a link: %s", err.Error()) } interfaces := te.ifaces if interfaces[0].addrv6.IP.To16() != nil { t.Fatalf("Expectd IPv6 address to be nil when IPv6 is not enabled. Got IPv6 = %s", interfaces[0].addrv6.String()) } if te.gw6.To16() != nil { t.Fatalf("Expected GatewayIPv6 to be nil when IPv6 is not enabled. Got GatewayIPv6 = %s", te.gw6.String()) } }
func TestUnknownNetwork(t *testing.T) { if !netutils.IsRunningInContainer() { defer osl.SetupTestOSContext(t)() } netOption := options.Generic{ "BridgeName": "testnetwork", "AllowNonDefaultBridge": true} option := options.Generic{ netlabel.GenericData: netOption, } network, err := createTestNetwork(bridgeNetType, "testnetwork", option) if err != nil { t.Fatal(err) } err = network.Delete() if err != nil { t.Fatal(err) } err = network.Delete() if err == nil { t.Fatal("Expected to fail. But instead succeeded") } if _, ok := err.(*libnetwork.UnknownNetworkError); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestSetupIPChains(t *testing.T) { // Create a test bridge with a basic bridge configuration (name + IPv4). defer osl.SetupTestOSContext(t)() driverconfig := &configuration{ EnableIPTables: true, } d := &driver{ config: driverconfig, } assertChainConfig(d, t) config := getBasicTestConfig() br := &bridgeInterface{} createTestBridge(config, br, t) assertBridgeConfig(config, br, d, t) config.EnableIPMasquerade = true assertBridgeConfig(config, br, d, t) config.EnableICC = true assertBridgeConfig(config, br, d, t) config.EnableIPMasquerade = false assertBridgeConfig(config, br, d, t) }
func TestNetworkType(t *testing.T) { if !netutils.IsRunningInContainer() { defer osl.SetupTestOSContext(t)() } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "testnetwork", "AllowNonDefaultBridge": true, }, } n, err := createTestNetwork(bridgeNetType, "testnetwork", netOption) if err != nil { t.Fatal(err) } defer func() { if err := n.Delete(); err != nil { t.Fatal(err) } }() if n.Type() != bridgeNetType { t.Fatalf("Expected network type %s, got %s", bridgeNetType, n.Type()) } }
func TestNetworkID(t *testing.T) { if !netutils.IsRunningInContainer() { defer osl.SetupTestOSContext(t)() } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "testnetwork", "AllowNonDefaultBridge": true, }, } n, err := createTestNetwork(bridgeNetType, "testnetwork", netOption) if err != nil { t.Fatal(err) } defer func() { if err := n.Delete(); err != nil { t.Fatal(err) } }() if n.ID() == "" { t.Fatal("Expected non-empty network id") } }
func TestSetDefaultGw(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } _, subnetv6, _ := net.ParseCIDR("2001:db8:ea9:9abc:b0c4::/80") var nw *net.IPNet for _, n := range bridgeNetworks { if err := netutils.CheckRouteOverlaps(n); err == nil { nw = n break } } if nw == nil { t.Skipf("Skip as no more automatic networks available") } gw4 := types.GetIPCopy(nw.IP).To4() gw4[3] = 254 gw6 := net.ParseIP("2001:db8:ea9:9abc:b0c4::254") config := &networkConfiguration{ BridgeName: DefaultBridgeName, EnableIPv6: true, FixedCIDRv6: subnetv6, DefaultGatewayIPv4: gw4, DefaultGatewayIPv6: gw6, } genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config err := d.CreateNetwork("dummy", genericOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te, nil) if err != nil { t.Fatalf("Failed to create endpoint: %v", err) } err = d.Join("dummy", "ep", "sbox", te, nil) if err != nil { t.Fatalf("Failed to join endpoint: %v", err) } if !gw4.Equal(te.gw) { t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw4, te.gw) } if !gw6.Equal(te.gw6) { t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw6, te.gw6) } }
func TestSetupFixedCIDRv6(t *testing.T) { defer osl.SetupTestOSContext(t)() config := &networkConfiguration{} br := newInterface(config) _, config.FixedCIDRv6, _ = net.ParseCIDR("2002:db8::/48") if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } if err := setupBridgeIPv6(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } if err := setupFixedCIDRv6(config, br); err != nil { t.Fatalf("Failed to setup bridge FixedCIDRv6: %v", err) } var ip net.IP if ip, err := ipAllocator.RequestIP(config.FixedCIDRv6, nil); err != nil { t.Fatalf("Failed to request IP to allocator: %v", err) } else if expected := "2002:db8::1"; ip.String() != expected { t.Fatalf("Expected allocated IP %s, got %s", expected, ip) } if err := ipAllocator.ReleaseIP(config.FixedCIDRv6, ip); err != nil { t.Fatalf("Failed to release IP from allocator: %v", err) } else if _, err := ipAllocator.RequestIP(config.FixedCIDRv6, ip); err != nil { t.Fatalf("Failed to request a released IP: %v", err) } }
func TestInterfaceDefaultName(t *testing.T) { defer osl.SetupTestOSContext(t)() config := &networkConfiguration{} if _ = newInterface(config); config.BridgeName != DefaultBridgeName { t.Fatalf("Expected default interface name %q, got %q", DefaultBridgeName, config.BridgeName) } }
func TestCreateMultipleNetworks(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() dd, _ := d.(*driver) config := &configuration{ EnableIPTables: true, } genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config if err := d.Config(genericOption); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } config1 := &networkConfiguration{BridgeName: "net_test_1", AllowNonDefaultBridge: true} genericOption = make(map[string]interface{}) genericOption[netlabel.GenericData] = config1 if err := d.CreateNetwork("1", genericOption); err != nil { t.Fatalf("Failed to create bridge: %v", err) } config2 := &networkConfiguration{BridgeName: "net_test_2", AllowNonDefaultBridge: true} genericOption[netlabel.GenericData] = config2 if err := d.CreateNetwork("2", genericOption); err != nil { t.Fatalf("Failed to create bridge: %v", err) } config3 := &networkConfiguration{BridgeName: "net_test_3", AllowNonDefaultBridge: true} genericOption[netlabel.GenericData] = config3 if err := d.CreateNetwork("3", genericOption); err != nil { t.Fatalf("Failed to create bridge: %v", err) } // Verify the network isolation rules are installed, each network subnet should appear 4 times verifyV4INCEntries(dd.networks, 4, t) config4 := &networkConfiguration{BridgeName: "net_test_4", AllowNonDefaultBridge: true} genericOption[netlabel.GenericData] = config4 if err := d.CreateNetwork("4", genericOption); err != nil { t.Fatalf("Failed to create bridge: %v", err) } // Now 6 times verifyV4INCEntries(dd.networks, 6, t) d.DeleteNetwork("1") verifyV4INCEntries(dd.networks, 4, t) d.DeleteNetwork("2") verifyV4INCEntries(dd.networks, 2, t) d.DeleteNetwork("3") verifyV4INCEntries(dd.networks, 0, t) d.DeleteNetwork("4") verifyV4INCEntries(dd.networks, 0, t) }
func TestSandboxAddSamePrio(t *testing.T) { if !netutils.IsRunningInContainer() { defer osl.SetupTestOSContext(t)() } c, nw1, nw2 := getTestEnv(t) ctrlr := c.(*controller) sbx, err := ctrlr.NewSandbox("sandbox1") if err != nil { t.Fatal(err) } sid := sbx.ID() ep1, err := nw1.CreateEndpoint("ep1") if err != nil { t.Fatal(err) } ep2, err := nw2.CreateEndpoint("ep2") if err != nil { t.Fatal(err) } if err := ep1.Join(sbx); err != nil { t.Fatal(err) } if err := ep2.Join(sbx); err != nil { t.Fatal(err) } if ctrlr.sandboxes[sid].endpoints[0] != ep1 { t.Fatal("Expected ep1 to be at the top of the heap. But did not find ep1 at the top of the heap") } if err := ep1.Leave(sbx); err != nil { t.Fatal(err) } if ctrlr.sandboxes[sid].endpoints[0] != ep2 { t.Fatal("Expected ep2 to be at the top of the heap after removing ep3. But did not find ep2 at the top of the heap") } if err := ep2.Leave(sbx); err != nil { t.Fatal(err) } if err := sbx.Delete(); err != nil { t.Fatal(err) } if len(ctrlr.sandboxes) != 0 { t.Fatalf("controller containers is not empty. len = %d", len(ctrlr.sandboxes)) } osl.GC() }
func TestGenerateRandomMAC(t *testing.T) { defer osl.SetupTestOSContext(t)() mac1 := netutils.GenerateRandomMAC() mac2 := netutils.GenerateRandomMAC() if bytes.Compare(mac1, mac2) == 0 { t.Fatalf("Generated twice the same MAC address %v", mac1) } }
func TestSetupVerifyMissing(t *testing.T) { defer osl.SetupTestOSContext(t)() addrv4 := net.IPv4(192, 168, 1, 1) inf := setupVerifyTest(t) config := &networkConfiguration{} config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()} if err := setupVerifyAndReconcile(config, inf); err == nil { t.Fatal("Address verification was expected to fail") } }
func TestCreateFullOptions(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() config := &configuration{ EnableIPForwarding: true, EnableIPTables: true, } // Test this scenario: Default gw address does not belong to // container network and it's greater than bridge address cip, cnw, _ := net.ParseCIDR("172.16.122.0/24") cnw.IP = cip ip, nw, _ := net.ParseCIDR("172.16.0.10/16") nw.IP = ip gw := net.ParseIP("172.16.0.1") netConfig := &networkConfiguration{ BridgeName: DefaultBridgeName, AddressIPv4: nw, FixedCIDR: cnw, DefaultGatewayIPv4: gw, EnableIPv6: true, } _, netConfig.FixedCIDRv6, _ = net.ParseCIDR("2001:db8::/48") genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config if err := d.Config(genericOption); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } netOption := make(map[string]interface{}) netOption[netlabel.GenericData] = netConfig err := d.CreateNetwork("dummy", netOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } // Verify the IP address allocated for the endpoint belongs to the container network epOptions := make(map[string]interface{}) te := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep1", te, epOptions) if err != nil { t.Fatalf("Failed to create an endpoint : %s", err.Error()) } if !cnw.Contains(te.Interfaces()[0].Address().IP) { t.Fatalf("endpoint got assigned address outside of container network(%s): %s", cnw.String(), te.Interfaces()[0].Address()) } }
func TestUnknownDriver(t *testing.T) { if !netutils.IsRunningInContainer() { defer osl.SetupTestOSContext(t)() } _, err := createTestNetwork("unknowndriver", "testnetwork", options.Generic{}) if err == nil { t.Fatal("Expected to fail. But instead succeeded") } if _, ok := err.(types.NotFoundError); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestDuplicateEndpoint(t *testing.T) { if !netutils.IsRunningInContainer() { defer osl.SetupTestOSContext(t)() } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "testnetwork", "AllowNonDefaultBridge": true, }, } n, err := createTestNetwork(bridgeNetType, "testnetwork", netOption) if err != nil { t.Fatal(err) } defer func() { if err := n.Delete(); err != nil { t.Fatal(err) } }() ep, err := n.CreateEndpoint("ep1") if err != nil { t.Fatal(err) } defer func() { if err := ep.Delete(); err != nil { t.Fatal(err) } }() ep2, err := n.CreateEndpoint("ep1") defer func() { // Cleanup ep2 as well, else network cleanup might fail for failure cases if ep2 != nil { if err := ep2.Delete(); err != nil { t.Fatal(err) } } }() if err == nil { t.Fatal("Expected to fail. But instead succeeded") } if _, ok := err.(types.ForbiddenError); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestSetupNewNonDefaultBridge(t *testing.T) { defer osl.SetupTestOSContext(t)() config := &networkConfiguration{BridgeName: "test0"} br := &bridgeInterface{} err := setupDevice(config, br) if err == nil { t.Fatal("Expected bridge creation failure with \"non default name\", succeeded") } if _, ok := err.(NonDefaultBridgeExistError); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestAddressesEmptyInterface(t *testing.T) { defer osl.SetupTestOSContext(t)() inf := newInterface(&networkConfiguration{}) addrv4, addrsv6, err := inf.addresses() if err != nil { t.Fatalf("Failed to get addresses of default interface: %v", err) } if expected := (netlink.Addr{}); addrv4 != expected { t.Fatalf("Default interface has unexpected IPv4: %s", addrv4) } if len(addrsv6) != 0 { t.Fatalf("Default interface has unexpected IPv6: %v", addrsv6) } }
func TestSetDefaultGw(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } _, subnetv6, _ := net.ParseCIDR("2001:db8:ea9:9abc:b0c4::/80") gw4 := bridgeNetworks[0].IP.To4() gw4[3] = 254 gw6 := net.ParseIP("2001:db8:ea9:9abc:b0c4::254") config := &networkConfiguration{ BridgeName: DefaultBridgeName, EnableIPv6: true, FixedCIDRv6: subnetv6, DefaultGatewayIPv4: gw4, DefaultGatewayIPv6: gw6, } genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config err := d.CreateNetwork("dummy", genericOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te, nil) if err != nil { t.Fatalf("Failed to create endpoint: %v", err) } err = d.Join("dummy", "ep", "sbox", te, nil) if err != nil { t.Fatalf("Failed to join endpoint: %v", err) } if !gw4.Equal(te.gw) { t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw4, te.gw) } if !gw6.Equal(te.gw6) { t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw6, te.gw6) } }
func TestSetupVerify(t *testing.T) { defer osl.SetupTestOSContext(t)() addrv4 := net.IPv4(192, 168, 1, 1) inf := setupVerifyTest(t) config := &networkConfiguration{} config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()} if err := netlink.AddrAdd(inf.Link, &netlink.Addr{IPNet: config.AddressIPv4}); err != nil { t.Fatalf("Failed to assign IPv4 %s to interface: %v", config.AddressIPv4, err) } if err := setupVerifyAndReconcile(config, inf); err != nil { t.Fatalf("Address verification failed: %v", err) } }
func TestCreateFail(t *testing.T) { defer osl.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } netconfig := &networkConfiguration{BridgeName: "dummy0"} genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = netconfig if err := d.CreateNetwork("dummy", genericOption); err == nil { t.Fatal("Bridge creation was expected to fail") } }
func TestUnknownEndpoint(t *testing.T) { if !netutils.IsRunningInContainer() { defer osl.SetupTestOSContext(t)() } ip, subnet, err := net.ParseCIDR("192.168.100.1/24") if err != nil { t.Fatal(err) } subnet.IP = ip netOption := options.Generic{ "BridgeName": "testnetwork", "AddressIPv4": subnet, "AllowNonDefaultBridge": true} option := options.Generic{ netlabel.GenericData: netOption, } network, err := createTestNetwork(bridgeNetType, "testnetwork", option) if err != nil { t.Fatal(err) } _, err = network.CreateEndpoint("") if err == nil { t.Fatal("Expected to fail. But instead succeeded") } if _, ok := err.(libnetwork.ErrInvalidName); !ok { t.Fatalf("Expected to fail with ErrInvalidName error. Actual error: %v", err) } ep, err := network.CreateEndpoint("testep") if err != nil { t.Fatal(err) } err = ep.Delete() if err != nil { t.Fatal(err) } // Done testing. Now cleanup if err := network.Delete(); err != nil { t.Fatal(err) } }
func TestSetupDeviceUp(t *testing.T) { defer osl.SetupTestOSContext(t)() config := &networkConfiguration{BridgeName: DefaultBridgeName} br := &bridgeInterface{} if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if err := setupDeviceUp(config, br); err != nil { t.Fatalf("Failed to up bridge device: %v", err) } lnk, _ := netlink.LinkByName(DefaultBridgeName) if lnk.Attrs().Flags&net.FlagUp != net.FlagUp { t.Fatalf("bridgeInterface should be up") } }
func TestSetupNewBridge(t *testing.T) { defer osl.SetupTestOSContext(t)() config := &networkConfiguration{BridgeName: DefaultBridgeName} br := &bridgeInterface{} if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if br.Link == nil { t.Fatal("bridgeInterface link is nil (expected valid link)") } if _, err := netlink.LinkByName(DefaultBridgeName); err != nil { t.Fatalf("Failed to retrieve bridge device: %v", err) } if br.Link.Attrs().Flags&net.FlagUp == net.FlagUp { t.Fatalf("bridgeInterface should be created down") } }