Skip to content

Test rework, part 2 #3455

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Sep 27, 2024
Merged

Test rework, part 2 #3455

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
f363e6f
Migrate system tests to new tooling
apostasie Sep 22, 2024
36ab583
Migrate network tests to new tooling
apostasie Sep 22, 2024
0aef2f2
Migrate completion tests to new tooling
apostasie Sep 22, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
224 changes: 180 additions & 44 deletions cmd/nerdctl/completion/completion_linux_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,53 +20,189 @@ import (
"testing"

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

func TestCompletion(t *testing.T) {
testutil.DockerIncompatible(t)
base := testutil.NewBase(t)
const gsc = "__complete"
// cmd is executed with base.Args={"--namespace=nerdctl-test"}
base.Cmd(gsc, "--cgroup-manager", "").AssertOutContains("cgroupfs\n")
base.Cmd(gsc, "--snapshotter", "").AssertOutContains("native\n")
base.Cmd(gsc, "").AssertOutContains("run\t")
base.Cmd(gsc, "run", "-").AssertOutContains("--network\t")
base.Cmd(gsc, "run", "--n").AssertOutContains("--network\t")
base.Cmd(gsc, "run", "--ne").AssertOutContains("--network\t")
base.Cmd(gsc, "run", "--net", "").AssertOutContains("host\n")
base.Cmd(gsc, "run", "-it", "--net", "").AssertOutContains("host\n")
base.Cmd(gsc, "run", "-it", "--rm", "--net", "").AssertOutContains("host\n")
base.Cmd(gsc, "run", "--restart", "").AssertOutContains("always\n")
base.Cmd(gsc, "network", "rm", "").AssertOutNotContains("host\n") // host is unremovable
base.Cmd(gsc, "run", "--cap-add", "").AssertOutContains("sys_admin\n")
base.Cmd(gsc, "run", "--cap-add", "").AssertOutNotContains("CAP_SYS_ADMIN\n") // invalid form
nerdtest.Setup()

// Tests with an image
base.Cmd("pull", testutil.AlpineImage).AssertOK()
base.Cmd(gsc, "run", "-i", "").AssertOutContains(testutil.AlpineImage)
base.Cmd(gsc, "run", "-it", "").AssertOutContains(testutil.AlpineImage)
base.Cmd(gsc, "run", "-it", "--rm", "").AssertOutContains(testutil.AlpineImage)
testCase := &test.Case{
Description: "Base completion",
Require: test.Not(nerdtest.Docker),
Setup: func(data test.Data, helpers test.Helpers) {
helpers.Ensure("pull", testutil.AlpineImage)
helpers.Ensure("network", "create", data.Identifier())
helpers.Ensure("volume", "create", data.Identifier())
data.Set("identifier", data.Identifier())
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("network", "rm", data.Identifier())
helpers.Anyhow("volume", "rm", data.Identifier())
},
SubTests: []*test.Case{
{
Description: "--cgroup-manager",
Command: test.RunCommand("__complete", "--cgroup-manager", ""),
Expected: test.Expects(0, nil, test.Contains("cgroupfs\n")),
},
{
Description: "--snapshotter",
Command: test.RunCommand("__complete", "--snapshotter", ""),
Expected: test.Expects(0, nil, test.Contains("native\n")),
},
{
Description: "empty",
Command: test.RunCommand("__complete", ""),
Expected: test.Expects(0, nil, test.Contains("run\t")),
},
{
Description: "run -",
Command: test.RunCommand("__complete", "run", "-"),
Expected: test.Expects(0, nil, test.Contains("--network\t")),
},
{
Description: "run --n",
Command: test.RunCommand("__complete", "run", "--n"),
Expected: test.Expects(0, nil, test.Contains("--network\t")),
},
{
Description: "run --ne",
Command: test.RunCommand("__complete", "run", "--ne"),
Expected: test.Expects(0, nil, test.Contains("--network\t")),
},
{
Description: "run --net",
Command: test.RunCommand("__complete", "run", "--net", ""),
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: test.All(
test.Contains("host\n"),
test.Contains(data.Get("identifier")+"\n"),
),
}
},
},
{
Description: "run -it --net",
Command: test.RunCommand("__complete", "run", "-it", "--net", ""),
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: test.All(
test.Contains("host\n"),
test.Contains(data.Get("identifier")+"\n"),
),
}
},
},
{
Description: "run -ti --rm --net",
Command: test.RunCommand("__complete", "run", "-it", "--rm", "--net", ""),
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: test.All(
test.Contains("host\n"),
test.Contains(data.Get("identifier")+"\n"),
),
}
},
},
{
Description: "run --restart",
Command: test.RunCommand("__complete", "run", "--restart", ""),
Expected: test.Expects(0, nil, test.Contains("always\n")),
},
{
Description: "network --rm",
Command: test.RunCommand("__complete", "network", "rm", ""),
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: test.All(
test.DoesNotContain("host\n"),
test.Contains(data.Get("identifier")+"\n"),
),
}
},
},
{
Description: "run --cap-add",
Command: test.RunCommand("__complete", "run", "--cap-add", ""),
Expected: test.Expects(0, nil, test.All(
test.Contains("sys_admin\n"),
test.DoesNotContain("CAP_SYS_ADMIN\n"),
)),
},
{
Description: "volume inspect",
Command: test.RunCommand("__complete", "volume", "inspect", ""),
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: test.Contains(data.Get("identifier") + "\n"),
}
},
},
{
Description: "volume rm",
Command: test.RunCommand("__complete", "volume", "rm", ""),
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: test.Contains(data.Get("identifier") + "\n"),
}
},
},
{
Description: "no namespace --cgroup-manager",
Command: func(data test.Data, helpers test.Helpers) test.Command {
cmd := helpers.Command()
cmd.Clear()
cmd.WithBinary("nerdctl")
cmd.WithArgs("__complete", "--cgroup-manager", "")
return cmd
},
Expected: test.Expects(0, nil, test.Contains("cgroupfs\n")),
},
{
Description: "no namespace empty",
Command: func(data test.Data, helpers test.Helpers) test.Command {
return helpers.Command().Clear().WithBinary("nerdctl").WithArgs("__complete", "")
},
Expected: test.Expects(0, nil, test.Contains("run\t")),
},
{
Description: "namespace space empty",
Command: func(data test.Data, helpers test.Helpers) test.Command {
// mind {"--namespace=nerdctl-test"} vs {"--namespace", "nerdctl-test"}
return helpers.Command().Clear().WithBinary("nerdctl").
WithArgs("__complete", "--namespace", testutil.Namespace, "")
},
Expected: test.Expects(0, nil, test.Contains("run\t")),
},
{
Description: "run -i",
Command: test.RunCommand("__complete", "run", "-i", ""),
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage)),
},
{
Description: "run -it",
Command: test.RunCommand("__complete", "run", "-it", ""),
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage)),
},
{
Description: "run -it --rm",
Command: test.RunCommand("__complete", "run", "-it", "--rm", ""),
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage)),
},
{
Description: "namespace run -i",
Command: func(data test.Data, helpers test.Helpers) test.Command {
// mind {"--namespace=nerdctl-test"} vs {"--namespace", "nerdctl-test"}
return helpers.Command().Clear().WithBinary("nerdctl").
WithArgs("__complete", "--namespace", testutil.Namespace, "run", "-i", "")
},
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage+"\n")),
},
},
}

// Tests with a network
testNetworkName := "nerdctl-test-completion"
defer base.Cmd("network", "rm", testNetworkName).Run()
base.Cmd("network", "create", testNetworkName).AssertOK()
base.Cmd(gsc, "network", "rm", "").AssertOutContains(testNetworkName)
base.Cmd(gsc, "run", "--net", "").AssertOutContains(testNetworkName)

// Tests with a volume
testVolumekName := "nerdctl-test-completion"
defer base.Cmd("volume", "rm", testVolumekName).Run()
base.Cmd("volume", "create", testVolumekName).AssertOK()
base.Cmd(gsc, "volume", "inspect", "").AssertOutContains(testVolumekName)
base.Cmd(gsc, "volume", "rm", "").AssertOutContains(testVolumekName)

// Tests with raw base (without Args={"--namespace=nerdctl-test"})
rawBase := testutil.NewBase(t)
rawBase.Args = nil // unset "--namespace=nerdctl-test"
rawBase.Cmd(gsc, "--cgroup-manager", "").AssertOutContains("cgroupfs\n")
rawBase.Cmd(gsc, "").AssertOutContains("run\t")
// mind {"--namespace=nerdctl-test"} vs {"--namespace", "nerdctl-test"}
rawBase.Cmd(gsc, "--namespace", testutil.Namespace, "").AssertOutContains("run\t")
rawBase.Cmd(gsc, "--namespace", testutil.Namespace, "run", "-i", "").AssertOutContains(testutil.AlpineImage)
testCase.Run(t)
}
131 changes: 79 additions & 52 deletions cmd/nerdctl/network/network_create_linux_test.go
View file
Open in desktop
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)
}
Loading