Skip to content

Commit

Permalink
Migrate network tests to new tooling
Browse files Browse the repository at this point in the history 
Signed-off-by: apostasie <[email protected]>
  • Loading branch information
@apostasie
apostasie committed Sep 22, 2024
1 parent d9ee983 commit 1fa27fd
Show file tree
Hide file tree
Showing 5 changed files with 374 additions and 248 deletions.
131 changes: 79 additions & 52 deletions cmd/nerdctl/network/network_create_linux_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,66 +17,93 @@
package network

import (
"fmt"
"net"
"strings"
"testing"

"gotest.tools/v3/assert"

"github.com/containerd/nerdctl/v2/cmd/nerdctl/helpers"
ipv6helper "github.com/containerd/nerdctl/v2/cmd/nerdctl/helpers"
"github.com/containerd/nerdctl/v2/pkg/testutil"
"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
"github.com/containerd/nerdctl/v2/pkg/testutil/test"
)

func TestNetworkCreateWithMTU(t *testing.T) {
testNetwork := testutil.Identifier(t)
base := testutil.NewBase(t)

args := []string{
"network", "create", testNetwork,
"--driver", "bridge", "--opt", "com.docker.network.driver.mtu=9216",
}
base.Cmd(args...).AssertOK()
defer base.Cmd("network", "rm", testNetwork).AssertOK()

base.Cmd("run", "--rm", "--net", testNetwork, testutil.AlpineImage, "ifconfig", "eth0").AssertOutContains("MTU:9216")
}

func TestNetworkCreate(t *testing.T) {
base := testutil.NewBase(t)
testNetwork := testutil.Identifier(t)

base.Cmd("network", "create", testNetwork).AssertOK()
defer base.Cmd("network", "rm", testNetwork).AssertOK()

net := base.InspectNetwork(testNetwork)
assert.Equal(t, len(net.IPAM.Config), 1)

base.Cmd("run", "--rm", "--net", testNetwork, testutil.CommonImage, "ip", "route").AssertOutContains(net.IPAM.Config[0].Subnet)

base.Cmd("network", "create", testNetwork+"-1").AssertOK()
defer base.Cmd("network", "rm", testNetwork+"-1").AssertOK()

base.Cmd("run", "--rm", "--net", testNetwork+"-1", testutil.CommonImage, "ip", "route").AssertOutNotContains(net.IPAM.Config[0].Subnet)
}

func TestNetworkCreateIPv6(t *testing.T) {
base := testutil.NewBaseWithIPv6Compatible(t)
testNetwork := testutil.Identifier(t)

subnetStr := "2001:db8:8::/64"
_, subnet, err := net.ParseCIDR(subnetStr)
assert.Assert(t, err == nil)

base.Cmd("network", "create", "--ipv6", "--subnet", subnetStr, testNetwork).AssertOK()
t.Cleanup(func() {
base.Cmd("network", "rm", testNetwork).Run()
})
nerdtest.Setup()

testGroup := &test.Group{
{
Description: "Network create",
Setup: func(data test.Data, helpers test.Helpers) {
helpers.Ensure("network", "create", data.Identifier())
netw := nerdtest.InspectNetwork(helpers, data.Identifier())
assert.Equal(t, len(netw.IPAM.Config), 1)
data.Set("subnet", netw.IPAM.Config[0].Subnet)

helpers.Ensure("network", "create", data.Identifier()+"-1")
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("network", "rm", data.Identifier())
helpers.Anyhow("network", "rm", data.Identifier()+"-1")
},
Command: func(data test.Data, helpers test.Helpers) test.Command {
data.Set("container2", helpers.Capture("run", "--rm", "--net", data.Identifier()+"-1", testutil.AlpineImage, "ip", "route"))
return helpers.Command("run", "--rm", "--net", data.Identifier(), testutil.AlpineImage, "ip", "route")
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 0,
Errors: nil,
Output: func(stdout string, info string, t *testing.T) {
assert.Assert(t, strings.Contains(stdout, data.Get("subnet")), info)
assert.Assert(t, !strings.Contains(data.Get("container2"), data.Get("subnet")), info)
},
}
},
},
{
Description: "Network create with MTU",
Setup: func(data test.Data, helpers test.Helpers) {
helpers.Ensure("network", "create", data.Identifier(), "--driver", "bridge", "--opt", "com.docker.network.driver.mtu=9216")
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("network", "rm", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.Command {
return helpers.Command("run", "--rm", "--net", data.Identifier(), testutil.AlpineImage, "ifconfig", "eth0")
},
Expected: test.Expects(0, nil, test.Contains("MTU:9216")),
},
{
Description: "Network create with ipv6",
Require: nerdtest.OnlyIPv6,
Setup: func(data test.Data, helpers test.Helpers) {
subnetStr := "2001:db8:8::/64"
data.Set("subnetStr", subnetStr)
_, _, err := net.ParseCIDR(subnetStr)
assert.Assert(t, err == nil)

helpers.Ensure("network", "create", data.Identifier(), "--ipv6", "--subnet", subnetStr)
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("network", "rm", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.Command {
return helpers.Command("run", "--rm", "--net", data.Identifier(), testutil.CommonImage, "ip", "addr", "show", "dev", "eth0")
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 0,
Output: func(stdout string, info string, t *testing.T) {
_, subnet, _ := net.ParseCIDR(data.Get("subnetStr"))
ip := ipv6helper.FindIPv6(stdout)
assert.Assert(t, subnet.Contains(ip), info)
},
}
},
},
}

base.Cmd("run", "--rm", "--net", testNetwork, testutil.CommonImage, "ip", "addr", "show", "dev", "eth0").AssertOutWithFunc(func(stdout string) error {
ip := helpers.FindIPv6(stdout)
if subnet.Contains(ip) {
return nil
}
return fmt.Errorf("expected subnet %s include ip %s", subnet, ip)
})
testGroup.Run(t)
}
131 changes: 77 additions & 54 deletions cmd/nerdctl/network/network_inspect_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,78 +17,101 @@
package network

import (
"runtime"
"encoding/json"
"errors"
"testing"

"gotest.tools/v3/assert"

"github.com/containerd/nerdctl/v2/pkg/inspecttypes/dockercompat"
"github.com/containerd/nerdctl/v2/pkg/testutil"
"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
"github.com/containerd/nerdctl/v2/pkg/testutil/test"
)

func TestNetworkInspect(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("IPAMConfig not implemented on Windows yet")
}
nerdtest.Setup()

testNetwork := testutil.Identifier(t)
const (
testSubnet = "10.24.24.0/24"
testGateway = "10.24.24.1"
testIPRange = "10.24.24.0/25"
)

base := testutil.NewBase(t)
defer base.Cmd("network", "rm", testNetwork).Run()

args := []string{
"network", "create", "--label", "tag=testNetwork", "--subnet", testSubnet,
"--gateway", testGateway, "--ip-range", testIPRange,
testNetwork,
}
base.Cmd(args...).AssertOK()
got := base.InspectNetwork(testNetwork)

assert.DeepEqual(base.T, testNetwork, got.Name)

expectedLabels := map[string]string{
"tag": "testNetwork",
}
assert.DeepEqual(base.T, expectedLabels, got.Labels)

expectedIPAM := dockercompat.IPAM{
Config: []dockercompat.IPAMConfig{
{
Subnet: testSubnet,
Gateway: testGateway,
IPRange: testIPRange,
testGroup := &test.Group{
{
Description: "Test network inspect",
// IPAMConfig is not implemented on Windows yet
Require: test.Not(test.Windows),
Setup: func(data test.Data, helpers test.Helpers) {
helpers.Ensure("network", "create", "--label", "tag=testNetwork", "--subnet", testSubnet,
"--gateway", testGateway, "--ip-range", testIPRange, data.Identifier())
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("network", "rm", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.Command {
return helpers.Command("network", "inspect", data.Identifier())
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 0,
Output: func(stdout string, info string, t *testing.T) {
var dc []dockercompat.Network

err := json.Unmarshal([]byte(stdout), &dc)
assert.NilError(t, err, "Unable to unmarshal output\n"+info)
assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info)
got := dc[0]

assert.Equal(t, got.Name, data.Identifier(), info)
assert.Equal(t, got.Labels["tag"], "testNetwork", info)
assert.Equal(t, len(got.IPAM.Config), 1, info)
assert.Equal(t, got.IPAM.Config[0].Subnet, testSubnet, info)
assert.Equal(t, got.IPAM.Config[0].Gateway, testGateway, info)
assert.Equal(t, got.IPAM.Config[0].IPRange, testIPRange, info)
},
}
},
},
}
assert.DeepEqual(base.T, expectedIPAM, got.IPAM)
}

func TestNetworkWithNamespace(t *testing.T) {
testutil.DockerIncompatible(t)

t.Parallel()

tID := testutil.Identifier(t)
base := testutil.NewBase(t)
baseOther := testutil.NewBaseWithNamespace(t, tID)
{
Description: "Test network with namespace",
Require: test.Not(nerdtest.Docker),
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("network", "rm", data.Identifier())
helpers.Anyhow("namespace", "remove", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.Command {
return helpers.Command("network", "create", data.Identifier())
},

tearDown := func() {
base.Cmd("network", "rm", tID).Run()
baseOther.Cmd("namespace", "remove", tID).Run()
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 0,
Output: func(stdout string, info string, t *testing.T) {
cmd := helpers.Command().Clear().WithBinary("nerdctl").WithArgs("--namespace", data.Identifier())

cmd.Clone().WithArgs("network", "inspect", data.Identifier()).Run(&test.Expected{
ExitCode: 1,
Errors: []error{errors.New("no such network")},
})

cmd.Clone().WithArgs("network", "remove", data.Identifier()).Run(&test.Expected{
ExitCode: 1,
Errors: []error{errors.New("no such network")},
})

cmd.Clone().WithArgs("network", "ls").Run(&test.Expected{
Output: test.DoesNotContain(data.Identifier()),
})

cmd.Clone().WithArgs("network", "prune", "-f").Run(&test.Expected{
Output: test.DoesNotContain(data.Identifier()),
})
},
}
},
},
}
tearDown()
t.Cleanup(tearDown)

base.Cmd("network", "create", tID).AssertOK()

// Other namespace cannot inspect, prune, see, or remove this network
baseOther.Cmd("network", "inspect", tID).AssertFail()
baseOther.Cmd("network", "prune", "-f").AssertOutNotContains(tID)
baseOther.Cmd("network", "ls").AssertOutNotContains(tID)
baseOther.Cmd("network", "remove", tID).AssertFail()
testGroup.Run(t)
}
Loading

0 comments on commit 1fa27fd

Please sign in to comment.