Skip to content

Commit 334cc2f

Browse files
AkihiroSudaAkihiroSuda
authored
Merge pull request containerd#3455 from apostasie/qa-nextgen
Test rework, part 2
2 parents b2a7039 + 0aef2f2 commit 334cc2f

9 files changed

+727
-459
lines changed

‎cmd/nerdctl/completion/completion_linux_test.go

Lines changed: 180 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -20,53 +20,189 @@ import (
2020
"testing"
2121

2222
"github.com/containerd/nerdctl/v2/pkg/testutil"
23+
"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
24+
"github.com/containerd/nerdctl/v2/pkg/testutil/test"
2325
)
2426

2527
func TestCompletion(t *testing.T) {
26-
testutil.DockerIncompatible(t)
27-
base := testutil.NewBase(t)
28-
const gsc = "__complete"
29-
// cmd is executed with base.Args={"--namespace=nerdctl-test"}
30-
base.Cmd(gsc, "--cgroup-manager", "").AssertOutContains("cgroupfs\n")
31-
base.Cmd(gsc, "--snapshotter", "").AssertOutContains("native\n")
32-
base.Cmd(gsc, "").AssertOutContains("run\t")
33-
base.Cmd(gsc, "run", "-").AssertOutContains("--network\t")
34-
base.Cmd(gsc, "run", "--n").AssertOutContains("--network\t")
35-
base.Cmd(gsc, "run", "--ne").AssertOutContains("--network\t")
36-
base.Cmd(gsc, "run", "--net", "").AssertOutContains("host\n")
37-
base.Cmd(gsc, "run", "-it", "--net", "").AssertOutContains("host\n")
38-
base.Cmd(gsc, "run", "-it", "--rm", "--net", "").AssertOutContains("host\n")
39-
base.Cmd(gsc, "run", "--restart", "").AssertOutContains("always\n")
40-
base.Cmd(gsc, "network", "rm", "").AssertOutNotContains("host\n") // host is unremovable
41-
base.Cmd(gsc, "run", "--cap-add", "").AssertOutContains("sys_admin\n")
42-
base.Cmd(gsc, "run", "--cap-add", "").AssertOutNotContains("CAP_SYS_ADMIN\n") // invalid form
28+
nerdtest.Setup()
4329

44-
// Tests with an image
45-
base.Cmd("pull", testutil.AlpineImage).AssertOK()
46-
base.Cmd(gsc, "run", "-i", "").AssertOutContains(testutil.AlpineImage)
47-
base.Cmd(gsc, "run", "-it", "").AssertOutContains(testutil.AlpineImage)
48-
base.Cmd(gsc, "run", "-it", "--rm", "").AssertOutContains(testutil.AlpineImage)
30+
testCase := &test.Case{
31+
Description: "Base completion",
32+
Require: test.Not(nerdtest.Docker),
33+
Setup: func(data test.Data, helpers test.Helpers) {
34+
helpers.Ensure("pull", testutil.AlpineImage)
35+
helpers.Ensure("network", "create", data.Identifier())
36+
helpers.Ensure("volume", "create", data.Identifier())
37+
data.Set("identifier", data.Identifier())
38+
},
39+
Cleanup: func(data test.Data, helpers test.Helpers) {
40+
helpers.Anyhow("network", "rm", data.Identifier())
41+
helpers.Anyhow("volume", "rm", data.Identifier())
42+
},
43+
SubTests: []*test.Case{
44+
{
45+
Description: "--cgroup-manager",
46+
Command: test.RunCommand("__complete", "--cgroup-manager", ""),
47+
Expected: test.Expects(0, nil, test.Contains("cgroupfs\n")),
48+
},
49+
{
50+
Description: "--snapshotter",
51+
Command: test.RunCommand("__complete", "--snapshotter", ""),
52+
Expected: test.Expects(0, nil, test.Contains("native\n")),
53+
},
54+
{
55+
Description: "empty",
56+
Command: test.RunCommand("__complete", ""),
57+
Expected: test.Expects(0, nil, test.Contains("run\t")),
58+
},
59+
{
60+
Description: "run -",
61+
Command: test.RunCommand("__complete", "run", "-"),
62+
Expected: test.Expects(0, nil, test.Contains("--network\t")),
63+
},
64+
{
65+
Description: "run --n",
66+
Command: test.RunCommand("__complete", "run", "--n"),
67+
Expected: test.Expects(0, nil, test.Contains("--network\t")),
68+
},
69+
{
70+
Description: "run --ne",
71+
Command: test.RunCommand("__complete", "run", "--ne"),
72+
Expected: test.Expects(0, nil, test.Contains("--network\t")),
73+
},
74+
{
75+
Description: "run --net",
76+
Command: test.RunCommand("__complete", "run", "--net", ""),
77+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
78+
return &test.Expected{
79+
Output: test.All(
80+
test.Contains("host\n"),
81+
test.Contains(data.Get("identifier")+"\n"),
82+
),
83+
}
84+
},
85+
},
86+
{
87+
Description: "run -it --net",
88+
Command: test.RunCommand("__complete", "run", "-it", "--net", ""),
89+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
90+
return &test.Expected{
91+
Output: test.All(
92+
test.Contains("host\n"),
93+
test.Contains(data.Get("identifier")+"\n"),
94+
),
95+
}
96+
},
97+
},
98+
{
99+
Description: "run -ti --rm --net",
100+
Command: test.RunCommand("__complete", "run", "-it", "--rm", "--net", ""),
101+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
102+
return &test.Expected{
103+
Output: test.All(
104+
test.Contains("host\n"),
105+
test.Contains(data.Get("identifier")+"\n"),
106+
),
107+
}
108+
},
109+
},
110+
{
111+
Description: "run --restart",
112+
Command: test.RunCommand("__complete", "run", "--restart", ""),
113+
Expected: test.Expects(0, nil, test.Contains("always\n")),
114+
},
115+
{
116+
Description: "network --rm",
117+
Command: test.RunCommand("__complete", "network", "rm", ""),
118+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
119+
return &test.Expected{
120+
Output: test.All(
121+
test.DoesNotContain("host\n"),
122+
test.Contains(data.Get("identifier")+"\n"),
123+
),
124+
}
125+
},
126+
},
127+
{
128+
Description: "run --cap-add",
129+
Command: test.RunCommand("__complete", "run", "--cap-add", ""),
130+
Expected: test.Expects(0, nil, test.All(
131+
test.Contains("sys_admin\n"),
132+
test.DoesNotContain("CAP_SYS_ADMIN\n"),
133+
)),
134+
},
135+
{
136+
Description: "volume inspect",
137+
Command: test.RunCommand("__complete", "volume", "inspect", ""),
138+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
139+
return &test.Expected{
140+
Output: test.Contains(data.Get("identifier") + "\n"),
141+
}
142+
},
143+
},
144+
{
145+
Description: "volume rm",
146+
Command: test.RunCommand("__complete", "volume", "rm", ""),
147+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
148+
return &test.Expected{
149+
Output: test.Contains(data.Get("identifier") + "\n"),
150+
}
151+
},
152+
},
153+
{
154+
Description: "no namespace --cgroup-manager",
155+
Command: func(data test.Data, helpers test.Helpers) test.Command {
156+
cmd := helpers.Command()
157+
cmd.Clear()
158+
cmd.WithBinary("nerdctl")
159+
cmd.WithArgs("__complete", "--cgroup-manager", "")
160+
return cmd
161+
},
162+
Expected: test.Expects(0, nil, test.Contains("cgroupfs\n")),
163+
},
164+
{
165+
Description: "no namespace empty",
166+
Command: func(data test.Data, helpers test.Helpers) test.Command {
167+
return helpers.Command().Clear().WithBinary("nerdctl").WithArgs("__complete", "")
168+
},
169+
Expected: test.Expects(0, nil, test.Contains("run\t")),
170+
},
171+
{
172+
Description: "namespace space empty",
173+
Command: func(data test.Data, helpers test.Helpers) test.Command {
174+
// mind {"--namespace=nerdctl-test"} vs {"--namespace", "nerdctl-test"}
175+
return helpers.Command().Clear().WithBinary("nerdctl").
176+
WithArgs("__complete", "--namespace", testutil.Namespace, "")
177+
},
178+
Expected: test.Expects(0, nil, test.Contains("run\t")),
179+
},
180+
{
181+
Description: "run -i",
182+
Command: test.RunCommand("__complete", "run", "-i", ""),
183+
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage)),
184+
},
185+
{
186+
Description: "run -it",
187+
Command: test.RunCommand("__complete", "run", "-it", ""),
188+
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage)),
189+
},
190+
{
191+
Description: "run -it --rm",
192+
Command: test.RunCommand("__complete", "run", "-it", "--rm", ""),
193+
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage)),
194+
},
195+
{
196+
Description: "namespace run -i",
197+
Command: func(data test.Data, helpers test.Helpers) test.Command {
198+
// mind {"--namespace=nerdctl-test"} vs {"--namespace", "nerdctl-test"}
199+
return helpers.Command().Clear().WithBinary("nerdctl").
200+
WithArgs("__complete", "--namespace", testutil.Namespace, "run", "-i", "")
201+
},
202+
Expected: test.Expects(0, nil, test.Contains(testutil.AlpineImage+"\n")),
203+
},
204+
},
205+
}
49206

50-
// Tests with a network
51-
testNetworkName := "nerdctl-test-completion"
52-
defer base.Cmd("network", "rm", testNetworkName).Run()
53-
base.Cmd("network", "create", testNetworkName).AssertOK()
54-
base.Cmd(gsc, "network", "rm", "").AssertOutContains(testNetworkName)
55-
base.Cmd(gsc, "run", "--net", "").AssertOutContains(testNetworkName)
56-
57-
// Tests with a volume
58-
testVolumekName := "nerdctl-test-completion"
59-
defer base.Cmd("volume", "rm", testVolumekName).Run()
60-
base.Cmd("volume", "create", testVolumekName).AssertOK()
61-
base.Cmd(gsc, "volume", "inspect", "").AssertOutContains(testVolumekName)
62-
base.Cmd(gsc, "volume", "rm", "").AssertOutContains(testVolumekName)
63-
64-
// Tests with raw base (without Args={"--namespace=nerdctl-test"})
65-
rawBase := testutil.NewBase(t)
66-
rawBase.Args = nil // unset "--namespace=nerdctl-test"
67-
rawBase.Cmd(gsc, "--cgroup-manager", "").AssertOutContains("cgroupfs\n")
68-
rawBase.Cmd(gsc, "").AssertOutContains("run\t")
69-
// mind {"--namespace=nerdctl-test"} vs {"--namespace", "nerdctl-test"}
70-
rawBase.Cmd(gsc, "--namespace", testutil.Namespace, "").AssertOutContains("run\t")
71-
rawBase.Cmd(gsc, "--namespace", testutil.Namespace, "run", "-i", "").AssertOutContains(testutil.AlpineImage)
207+
testCase.Run(t)
72208
}

‎cmd/nerdctl/network/network_create_linux_test.go

Lines changed: 79 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -17,66 +17,93 @@
1717
package network
1818

1919
import (
20-
"fmt"
2120
"net"
21+
"strings"
2222
"testing"
2323

2424
"gotest.tools/v3/assert"
2525

26-
"github.com/containerd/nerdctl/v2/cmd/nerdctl/helpers"
26+
ipv6helper "github.com/containerd/nerdctl/v2/cmd/nerdctl/helpers"
2727
"github.com/containerd/nerdctl/v2/pkg/testutil"
28+
"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
29+
"github.com/containerd/nerdctl/v2/pkg/testutil/test"
2830
)
2931

30-
func TestNetworkCreateWithMTU(t *testing.T) {
31-
testNetwork := testutil.Identifier(t)
32-
base := testutil.NewBase(t)
33-
34-
args := []string{
35-
"network", "create", testNetwork,
36-
"--driver", "bridge", "--opt", "com.docker.network.driver.mtu=9216",
37-
}
38-
base.Cmd(args...).AssertOK()
39-
defer base.Cmd("network", "rm", testNetwork).AssertOK()
40-
41-
base.Cmd("run", "--rm", "--net", testNetwork, testutil.AlpineImage, "ifconfig", "eth0").AssertOutContains("MTU:9216")
42-
}
43-
4432
func TestNetworkCreate(t *testing.T) {
45-
base := testutil.NewBase(t)
46-
testNetwork := testutil.Identifier(t)
47-
48-
base.Cmd("network", "create", testNetwork).AssertOK()
49-
defer base.Cmd("network", "rm", testNetwork).AssertOK()
50-
51-
net := base.InspectNetwork(testNetwork)
52-
assert.Equal(t, len(net.IPAM.Config), 1)
53-
54-
base.Cmd("run", "--rm", "--net", testNetwork, testutil.CommonImage, "ip", "route").AssertOutContains(net.IPAM.Config[0].Subnet)
55-
56-
base.Cmd("network", "create", testNetwork+"-1").AssertOK()
57-
defer base.Cmd("network", "rm", testNetwork+"-1").AssertOK()
58-
59-
base.Cmd("run", "--rm", "--net", testNetwork+"-1", testutil.CommonImage, "ip", "route").AssertOutNotContains(net.IPAM.Config[0].Subnet)
60-
}
61-
62-
func TestNetworkCreateIPv6(t *testing.T) {
63-
base := testutil.NewBaseWithIPv6Compatible(t)
64-
testNetwork := testutil.Identifier(t)
65-
66-
subnetStr := "2001:db8:8::/64"
67-
_, subnet, err := net.ParseCIDR(subnetStr)
68-
assert.Assert(t, err == nil)
69-
70-
base.Cmd("network", "create", "--ipv6", "--subnet", subnetStr, testNetwork).AssertOK()
71-
t.Cleanup(func() {
72-
base.Cmd("network", "rm", testNetwork).Run()
73-
})
33+
nerdtest.Setup()
34+
35+
testGroup := &test.Group{
36+
{
37+
Description: "Network create",
38+
Setup: func(data test.Data, helpers test.Helpers) {
39+
helpers.Ensure("network", "create", data.Identifier())
40+
netw := nerdtest.InspectNetwork(helpers, data.Identifier())
41+
assert.Equal(t, len(netw.IPAM.Config), 1)
42+
data.Set("subnet", netw.IPAM.Config[0].Subnet)
43+
44+
helpers.Ensure("network", "create", data.Identifier()+"-1")
45+
},
46+
Cleanup: func(data test.Data, helpers test.Helpers) {
47+
helpers.Anyhow("network", "rm", data.Identifier())
48+
helpers.Anyhow("network", "rm", data.Identifier()+"-1")
49+
},
50+
Command: func(data test.Data, helpers test.Helpers) test.Command {
51+
data.Set("container2", helpers.Capture("run", "--rm", "--net", data.Identifier()+"-1", testutil.AlpineImage, "ip", "route"))
52+
return helpers.Command("run", "--rm", "--net", data.Identifier(), testutil.AlpineImage, "ip", "route")
53+
},
54+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
55+
return &test.Expected{
56+
ExitCode: 0,
57+
Errors: nil,
58+
Output: func(stdout string, info string, t *testing.T) {
59+
assert.Assert(t, strings.Contains(stdout, data.Get("subnet")), info)
60+
assert.Assert(t, !strings.Contains(data.Get("container2"), data.Get("subnet")), info)
61+
},
62+
}
63+
},
64+
},
65+
{
66+
Description: "Network create with MTU",
67+
Setup: func(data test.Data, helpers test.Helpers) {
68+
helpers.Ensure("network", "create", data.Identifier(), "--driver", "bridge", "--opt", "com.docker.network.driver.mtu=9216")
69+
},
70+
Cleanup: func(data test.Data, helpers test.Helpers) {
71+
helpers.Anyhow("network", "rm", data.Identifier())
72+
},
73+
Command: func(data test.Data, helpers test.Helpers) test.Command {
74+
return helpers.Command("run", "--rm", "--net", data.Identifier(), testutil.AlpineImage, "ifconfig", "eth0")
75+
},
76+
Expected: test.Expects(0, nil, test.Contains("MTU:9216")),
77+
},
78+
{
79+
Description: "Network create with ipv6",
80+
Require: nerdtest.OnlyIPv6,
81+
Setup: func(data test.Data, helpers test.Helpers) {
82+
subnetStr := "2001:db8:8::/64"
83+
data.Set("subnetStr", subnetStr)
84+
_, _, err := net.ParseCIDR(subnetStr)
85+
assert.Assert(t, err == nil)
86+
87+
helpers.Ensure("network", "create", data.Identifier(), "--ipv6", "--subnet", subnetStr)
88+
},
89+
Cleanup: func(data test.Data, helpers test.Helpers) {
90+
helpers.Anyhow("network", "rm", data.Identifier())
91+
},
92+
Command: func(data test.Data, helpers test.Helpers) test.Command {
93+
return helpers.Command("run", "--rm", "--net", data.Identifier(), testutil.CommonImage, "ip", "addr", "show", "dev", "eth0")
94+
},
95+
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
96+
return &test.Expected{
97+
ExitCode: 0,
98+
Output: func(stdout string, info string, t *testing.T) {
99+
_, subnet, _ := net.ParseCIDR(data.Get("subnetStr"))
100+
ip := ipv6helper.FindIPv6(stdout)
101+
assert.Assert(t, subnet.Contains(ip), info)
102+
},
103+
}
104+
},
105+
},
106+
}
74107

75-
base.Cmd("run", "--rm", "--net", testNetwork, testutil.CommonImage, "ip", "addr", "show", "dev", "eth0").AssertOutWithFunc(func(stdout string) error {
76-
ip := helpers.FindIPv6(stdout)
77-
if subnet.Contains(ip) {
78-
return nil
79-
}
80-
return fmt.Errorf("expected subnet %s include ip %s", subnet, ip)
81-
})
108+
testGroup.Run(t)
82109
}

0 commit comments

Comments
 (0)