Skip to content
This repository was archived by the owner on Mar 9, 2022. It is now read-only.

Commit 0609417

Browse files
Random-LiuRandom-Liu
committed
Add unit test.
Signed-off-by: Lantao Liu <[email protected]>
1 parent 750eca5 commit 0609417

File tree

3 files changed

+175
-17
lines changed

3 files changed

+175
-17
lines changed

‎pkg/server/container_create_test.go‎

Lines changed: 60 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -21,13 +21,17 @@ import (
2121
"os"
2222
"testing"
2323

24+
rootfsapi "github.com/containerd/containerd/api/services/rootfs"
25+
imagedigest "github.com/opencontainers/go-digest"
26+
imagespec "github.com/opencontainers/image-spec/specs-go/v1"
2427
"github.com/stretchr/testify/assert"
2528
"github.com/stretchr/testify/require"
2629
"golang.org/x/net/context"
2730
runtime "k8s.io/kubernetes/pkg/kubelet/apis/cri/v1alpha1"
2831

2932
"github.com/kubernetes-incubator/cri-containerd/pkg/metadata"
3033
ostesting "github.com/kubernetes-incubator/cri-containerd/pkg/os/testing"
34+
servertesting "github.com/kubernetes-incubator/cri-containerd/pkg/server/testing"
3135
)
3236

3337
func TestCreateContainer(t *testing.T) {
@@ -42,10 +46,20 @@ func TestCreateContainer(t *testing.T) {
4246
Namespace: "test-sandbox-namespace",
4347
Attempt: 2,
4448
}
49+
// Use an image id to avoid image name resolution.
50+
// TODO(random-liu): Change this to image name after we have complete image
51+
// management unit test framework.
52+
testImage := "sha256:c75bebcdd211f41b3a460c7bf82970ed6c75acaab9cd4c9a4e125b03ca113799"
53+
testChainID := imagedigest.Digest("test-chain-id")
54+
testImageMetadata := metadata.ImageMetadata{
55+
ID: testImage,
56+
ChainID: testChainID.String(),
57+
Config: &imagespec.ImageConfig{},
58+
}
4559
testConfig := &runtime.ContainerConfig{
4660
Metadata: testNameMeta,
4761
Image: &runtime.ImageSpec{
48-
Image: "test-image",
62+
Image: testImage,
4963
},
5064
Labels: map[string]string{"a": "b"},
5165
Annotations: map[string]string{"c": "d"},
@@ -55,12 +69,14 @@ func TestCreateContainer(t *testing.T) {
5569
}
5670

5771
for desc, test := range map[string]struct {
58-
sandboxMetadata *metadata.SandboxMetadata
59-
reserveNameErr bool
60-
createRootDirErr error
61-
createMetadataErr bool
62-
expectErr bool
63-
expectMeta *metadata.ContainerMetadata
72+
sandboxMetadata *metadata.SandboxMetadata
73+
reserveNameErr bool
74+
imageMetadataErr bool
75+
prepareSnapshotErr error
76+
createRootDirErr error
77+
createMetadataErr bool
78+
expectErr bool
79+
expectMeta *metadata.ContainerMetadata
6480
}{
6581
"should return error if sandbox does not exist": {
6682
sandboxMetadata: nil,
@@ -84,6 +100,24 @@ func TestCreateContainer(t *testing.T) {
84100
createRootDirErr: errors.New("random error"),
85101
expectErr: true,
86102
},
103+
"should return error if image is not pulled": {
104+
sandboxMetadata: &metadata.SandboxMetadata{
105+
ID: testSandboxID,
106+
Name: makeSandboxName(testSandboxNameMeta),
107+
Config: testSandboxConfig,
108+
},
109+
imageMetadataErr: true,
110+
expectErr: true,
111+
},
112+
"should return error if prepare snapshot fails": {
113+
sandboxMetadata: &metadata.SandboxMetadata{
114+
ID: testSandboxID,
115+
Name: makeSandboxName(testSandboxNameMeta),
116+
Config: testSandboxConfig,
117+
},
118+
prepareSnapshotErr: errors.New("random error"),
119+
expectErr: true,
120+
},
87121
"should be able to create container successfully": {
88122
sandboxMetadata: &metadata.SandboxMetadata{
89123
ID: testSandboxID,
@@ -94,12 +128,14 @@ func TestCreateContainer(t *testing.T) {
94128
expectMeta: &metadata.ContainerMetadata{
95129
Name: makeContainerName(testNameMeta, testSandboxNameMeta),
96130
SandboxID: testSandboxID,
131+
ImageRef: testImage,
97132
Config: testConfig,
98133
},
99134
},
100135
} {
101136
t.Logf("TestCase %q", desc)
102137
c := newTestCRIContainerdService()
138+
fakeRootfsClient := c.rootfsService.(*servertesting.FakeRootfsClient)
103139
fakeOS := c.os.(*ostesting.FakeOS)
104140
if test.sandboxMetadata != nil {
105141
assert.NoError(t, c.sandboxStore.Create(*test.sandboxMetadata))
@@ -108,6 +144,13 @@ func TestCreateContainer(t *testing.T) {
108144
if test.reserveNameErr {
109145
assert.NoError(t, c.containerNameIndex.Reserve(containerName, "random id"))
110146
}
147+
if !test.imageMetadataErr {
148+
assert.NoError(t, c.imageMetadataStore.Create(testImageMetadata))
149+
}
150+
if test.prepareSnapshotErr != nil {
151+
fakeRootfsClient.InjectError("prepare", test.prepareSnapshotErr)
152+
}
153+
fakeRootfsClient.SetFakeChainIDs([]imagedigest.Digest{testChainID})
111154
rootExists := false
112155
rootPath := ""
113156
fakeOS.MkdirAllFn = func(path string, perm os.FileMode) error {
@@ -153,5 +196,15 @@ func TestCreateContainer(t *testing.T) {
153196
// TODO(random-liu): Use fake clock to test CreatedAt.
154197
test.expectMeta.CreatedAt = meta.CreatedAt
155198
assert.Equal(t, test.expectMeta, meta, "container metadata should be created")
199+
200+
assert.Equal(t, []string{"prepare"}, fakeRootfsClient.GetCalledNames(), "prepare should be called")
201+
calls := fakeRootfsClient.GetCalledDetails()
202+
prepareOpts := calls[0].Argument.(*rootfsapi.PrepareRequest)
203+
assert.Equal(t, &rootfsapi.PrepareRequest{
204+
Name: id,
205+
ChainID: testChainID,
206+
// TODO(random-liu): Test readonly rootfs.
207+
Readonly: false,
208+
}, prepareOpts, "prepare request should be correct")
156209
}
157210
}

‎pkg/server/container_start_test.go‎

Lines changed: 114 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,10 @@ import (
2626

2727
"github.com/containerd/containerd/api/services/execution"
2828
"github.com/containerd/containerd/api/types/container"
29+
"github.com/containerd/containerd/api/types/mount"
30+
imagespec "github.com/opencontainers/image-spec/specs-go/v1"
2931
runtimespec "github.com/opencontainers/runtime-spec/specs-go"
32+
"github.com/opencontainers/runtime-tools/generate"
3033
"github.com/stretchr/testify/assert"
3134
"github.com/stretchr/testify/require"
3235
"golang.org/x/net/context"
@@ -38,7 +41,7 @@ import (
3841
)
3942

4043
func getStartContainerTestData() (*runtime.ContainerConfig, *runtime.PodSandboxConfig,
41-
func(*testing.T, string, uint32, *runtimespec.Spec)) {
44+
*imagespec.ImageConfig, func(*testing.T, string, uint32, *runtimespec.Spec)) {
4245
config := &runtime.ContainerConfig{
4346
Metadata: &runtime.ContainerMetadata{
4447
Name: "test-name",
@@ -92,11 +95,17 @@ func getStartContainerTestData() (*runtime.ContainerConfig, *runtime.PodSandboxC
9295
CgroupParent: "/test/cgroup/parent",
9396
},
9497
}
98+
imageConfig := &imagespec.ImageConfig{
99+
Env: []string{"ik1=iv1", "ik2=iv2"},
100+
Entrypoint: []string{"/entrypoint"},
101+
Cmd: []string{"cmd"},
102+
WorkingDir: "/workspace",
103+
}
95104
specCheck := func(t *testing.T, id string, sandboxPid uint32, spec *runtimespec.Spec) {
96105
assert.Equal(t, relativeRootfsPath, spec.Root.Path)
97106
assert.Equal(t, []string{"test", "command", "test", "args"}, spec.Process.Args)
98107
assert.Equal(t, "test-cwd", spec.Process.Cwd)
99-
assert.Contains(t, spec.Process.Env, "k1=v1", "k2=v2")
108+
assert.Contains(t, spec.Process.Env, "k1=v1", "k2=v2", "ik1=iv1", "ik2=iv2")
100109

101110
t.Logf("Check bind mount")
102111
found1, found2 := false, false
@@ -159,27 +168,27 @@ func getStartContainerTestData() (*runtime.ContainerConfig, *runtime.PodSandboxC
159168
Path: getPIDNamespace(sandboxPid),
160169
})
161170
}
162-
return config, sandboxConfig, specCheck
171+
return config, sandboxConfig, imageConfig, specCheck
163172
}
164173

165174
func TestGeneralContainerSpec(t *testing.T) {
166175
testID := "test-id"
167176
testPid := uint32(1234)
168-
config, sandboxConfig, specCheck := getStartContainerTestData()
177+
config, sandboxConfig, imageConfig, specCheck := getStartContainerTestData()
169178
c := newTestCRIContainerdService()
170-
spec, err := c.generateContainerSpec(testID, testPid, config, sandboxConfig)
179+
spec, err := c.generateContainerSpec(testID, testPid, config, sandboxConfig, imageConfig)
171180
assert.NoError(t, err)
172181
specCheck(t, testID, testPid, spec)
173182
}
174183

175184
func TestContainerSpecTty(t *testing.T) {
176185
testID := "test-id"
177186
testPid := uint32(1234)
178-
config, sandboxConfig, specCheck := getStartContainerTestData()
187+
config, sandboxConfig, imageConfig, specCheck := getStartContainerTestData()
179188
c := newTestCRIContainerdService()
180189
for _, tty := range []bool{true, false} {
181190
config.Tty = tty
182-
spec, err := c.generateContainerSpec(testID, testPid, config, sandboxConfig)
191+
spec, err := c.generateContainerSpec(testID, testPid, config, sandboxConfig, imageConfig)
183192
assert.NoError(t, err)
184193
specCheck(t, testID, testPid, spec)
185194
assert.Equal(t, tty, spec.Process.Terminal)
@@ -189,27 +198,90 @@ func TestContainerSpecTty(t *testing.T) {
189198
func TestContainerSpecReadonlyRootfs(t *testing.T) {
190199
testID := "test-id"
191200
testPid := uint32(1234)
192-
config, sandboxConfig, specCheck := getStartContainerTestData()
201+
config, sandboxConfig, imageConfig, specCheck := getStartContainerTestData()
193202
c := newTestCRIContainerdService()
194203
for _, readonly := range []bool{true, false} {
195204
config.Linux.SecurityContext.ReadonlyRootfs = readonly
196-
spec, err := c.generateContainerSpec(testID, testPid, config, sandboxConfig)
205+
spec, err := c.generateContainerSpec(testID, testPid, config, sandboxConfig, imageConfig)
197206
assert.NoError(t, err)
198207
specCheck(t, testID, testPid, spec)
199208
assert.Equal(t, readonly, spec.Root.Readonly)
200209
}
201210
}
202211

212+
func TestContainerSpecCommand(t *testing.T) {
213+
for desc, test := range map[string]struct {
214+
criEntrypoint []string
215+
criArgs []string
216+
imageEntrypoint []string
217+
imageArgs []string
218+
expected []string
219+
expectErr bool
220+
}{
221+
"should use cri entrypoint if it's specified": {
222+
criEntrypoint: []string{"a", "b"},
223+
imageEntrypoint: []string{"c", "d"},
224+
imageArgs: []string{"e", "f"},
225+
expected: []string{"a", "b"},
226+
},
227+
"should use cri entrypoint if it's specified even if it's empty": {
228+
criEntrypoint: []string{},
229+
criArgs: []string{"a", "b"},
230+
imageEntrypoint: []string{"c", "d"},
231+
imageArgs: []string{"e", "f"},
232+
expected: []string{"a", "b"},
233+
},
234+
"should use cri entrypoint and args if they are specified": {
235+
criEntrypoint: []string{"a", "b"},
236+
criArgs: []string{"c", "d"},
237+
imageEntrypoint: []string{"e", "f"},
238+
imageArgs: []string{"g", "h"},
239+
expected: []string{"a", "b", "c", "d"},
240+
},
241+
"should use image entrypoint if cri entrypoint is not specified": {
242+
criArgs: []string{"a", "b"},
243+
imageEntrypoint: []string{"c", "d"},
244+
imageArgs: []string{"e", "f"},
245+
expected: []string{"c", "d", "a", "b"},
246+
},
247+
"should use image args if both cri entrypoint and args are not specified": {
248+
imageEntrypoint: []string{"c", "d"},
249+
imageArgs: []string{"e", "f"},
250+
expected: []string{"c", "d", "e", "f"},
251+
},
252+
"should return error if both entrypoint and args are empty": {
253+
expectErr: true,
254+
},
255+
} {
256+
257+
config, _, imageConfig, _ := getStartContainerTestData()
258+
g := generate.New()
259+
config.Command = test.criEntrypoint
260+
config.Args = test.criArgs
261+
imageConfig.Entrypoint = test.imageEntrypoint
262+
imageConfig.Cmd = test.imageArgs
263+
err := setOCIProcessArgs(&g, config, imageConfig)
264+
if test.expectErr {
265+
assert.Error(t, err)
266+
continue
267+
}
268+
assert.NoError(t, err)
269+
assert.Equal(t, test.expected, g.Spec().Process.Args, desc)
270+
}
271+
}
272+
203273
func TestStartContainer(t *testing.T) {
204274
testID := "test-id"
205275
testSandboxID := "test-sandbox-id"
206276
testSandboxPid := uint32(4321)
207-
config, sandboxConfig, specCheck := getStartContainerTestData()
277+
testImageID := "sha256:c75bebcdd211f41b3a460c7bf82970ed6c75acaab9cd4c9a4e125b03ca113799"
278+
config, sandboxConfig, imageConfig, specCheck := getStartContainerTestData()
208279
testMetadata := &metadata.ContainerMetadata{
209280
ID: testID,
210281
Name: "test-name",
211282
SandboxID: testSandboxID,
212283
Config: config,
284+
ImageRef: testImageID,
213285
CreatedAt: time.Now().UnixNano(),
214286
}
215287
testSandboxMetadata := &metadata.SandboxMetadata{
@@ -222,10 +294,13 @@ func TestStartContainer(t *testing.T) {
222294
Pid: testSandboxPid,
223295
Status: container.Status_RUNNING,
224296
}
297+
testMounts := []*mount.Mount{{Type: "bind", Source: "test-source"}}
225298
for desc, test := range map[string]struct {
226299
containerMetadata *metadata.ContainerMetadata
227300
sandboxMetadata *metadata.SandboxMetadata
228301
sandboxContainerdContainer *container.Container
302+
imageMetadataErr bool
303+
snapshotMountsErr bool
229304
prepareFIFOErr error
230305
createContainerErr error
231306
startContainerErr error
@@ -288,6 +363,24 @@ func TestStartContainer(t *testing.T) {
288363
expectCalls: []string{"info"},
289364
expectErr: true,
290365
},
366+
"should return error when image doesn't exist": {
367+
containerMetadata: testMetadata,
368+
sandboxMetadata: testSandboxMetadata,
369+
sandboxContainerdContainer: testSandboxContainer,
370+
imageMetadataErr: true,
371+
expectStateChange: true,
372+
expectCalls: []string{"info"},
373+
expectErr: true,
374+
},
375+
"should return error when snapshot mounts fails": {
376+
containerMetadata: testMetadata,
377+
sandboxMetadata: testSandboxMetadata,
378+
sandboxContainerdContainer: testSandboxContainer,
379+
snapshotMountsErr: true,
380+
expectStateChange: true,
381+
expectCalls: []string{"info"},
382+
expectErr: true,
383+
},
291384
"should return error when fail to open streaming pipes": {
292385
containerMetadata: testMetadata,
293386
sandboxMetadata: testSandboxMetadata,
@@ -329,6 +422,7 @@ func TestStartContainer(t *testing.T) {
329422
c := newTestCRIContainerdService()
330423
fake := c.containerService.(*servertesting.FakeExecutionClient)
331424
fakeOS := c.os.(*ostesting.FakeOS)
425+
fakeRootfsClient := c.rootfsService.(*servertesting.FakeRootfsClient)
332426
if test.containerMetadata != nil {
333427
assert.NoError(t, c.containerStore.Create(*test.containerMetadata))
334428
}
@@ -338,6 +432,15 @@ func TestStartContainer(t *testing.T) {
338432
if test.sandboxContainerdContainer != nil {
339433
fake.SetFakeContainers([]container.Container{*test.sandboxContainerdContainer})
340434
}
435+
if !test.imageMetadataErr {
436+
assert.NoError(t, c.imageMetadataStore.Create(metadata.ImageMetadata{
437+
ID: testImageID,
438+
Config: imageConfig,
439+
}))
440+
}
441+
if !test.snapshotMountsErr {
442+
fakeRootfsClient.SetFakeMounts(testID, testMounts)
443+
}
341444
// TODO(random-liu): Test behavior with different streaming config.
342445
fakeOS.OpenFifoFn = func(context.Context, string, int, os.FileMode) (io.ReadWriteCloser, error) {
343446
return nopReadWriteCloser{}, test.prepareFIFOErr
@@ -394,6 +497,7 @@ func TestStartContainer(t *testing.T) {
394497
calls := fake.GetCalledDetails()
395498
createOpts, ok := calls[1].Argument.(*execution.CreateRequest)
396499
assert.True(t, ok, "2nd call should be create")
500+
assert.Equal(t, testMounts, createOpts.Rootfs, "rootfs mounts should be correct")
397501
// TODO(random-liu): Test other create options.
398502
spec := &runtimespec.Spec{}
399503
assert.NoError(t, json.Unmarshal(createOpts.Spec.Value, spec))

‎pkg/server/sandbox_run_test.go‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -126,6 +126,7 @@ func TestGenerateSandboxContainerSpec(t *testing.T) {
126126
expectErr: true,
127127
},
128128
"should return error when env is invalid ": {
129+
// Also covers addImageEnvs.
129130
imageConfigChange: func(c *imagespec.ImageConfig) {
130131
c.Env = []string{"a"}
131132
},

0 commit comments

Comments
 (0)