1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
package main
import (
"runtime"
"testing"
"github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/cmd/podman/shared"
"github.com/containers/libpod/pkg/inspect"
cc "github.com/containers/libpod/pkg/spec"
"github.com/docker/go-units"
ociv1 "github.com/opencontainers/image-spec/specs-go/v1"
spec "github.com/opencontainers/runtime-spec/specs-go"
"github.com/spf13/cobra"
"github.com/stretchr/testify/assert"
)
var (
cmd = []string{"podman", "test", "alpine"}
CLI *cliconfig.PodmanCommand
)
// generates a mocked ImageData structure based on alpine
func generateAlpineImageData() *inspect.ImageData {
config := &ociv1.ImageConfig{
User: "",
ExposedPorts: nil,
Env: []string{"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
Entrypoint: []string{},
Cmd: []string{"/bin/sh"},
Volumes: nil,
WorkingDir: "",
Labels: nil,
StopSignal: "",
}
data := &inspect.ImageData{
ID: "e21c333399e0aeedfd70e8827c9fba3f8e9b170ef8a48a29945eb7702bf6aa5f",
RepoTags: []string{"docker.io/library/alpine:latest"},
RepoDigests: []string{"docker.io/library/alpine@sha256:5cb04fce748f576d7b72a37850641de8bd725365519673c643ef2d14819b42c6"},
Comment: "Created:2017-12-01 18:48:48.949613376 +0000",
Author: "",
Architecture: "amd64",
Os: "linux",
Version: "17.06.2-ce",
Config: config,
}
return data
}
// sets a global CLI
func testCmd(c *cobra.Command) error {
CLI = &cliconfig.PodmanCommand{Command: c}
return nil
}
// creates the mocked cli pointing to our create flags
// global flags like log-level are not implemented
func createCLI(args []string) *cliconfig.PodmanCommand {
var testCommand = &cliconfig.PodmanCommand{
Command: &cobra.Command{
Use: "test",
RunE: func(cmd *cobra.Command, args []string) error {
return testCmd(cmd)
},
},
}
rootCmd := testCommand
getCreateFlags(rootCmd)
rootCmd.ParseFlags(args)
return rootCmd
}
func getRuntimeSpec(c *cliconfig.PodmanCommand) (*spec.Spec, error) {
/*
TODO: This test has never worked. Need to install content
runtime, err := getRuntime(c)
if err != nil {
return nil, err
}
createConfig, err := parseCreateOpts(c, runtime, "alpine", generateAlpineImageData())
*/
ctx := getContext()
createConfig, err := shared.ParseCreateOpts(ctx, c, nil, "alpine", generateAlpineImageData())
if err != nil {
return nil, err
}
runtimeSpec, err := cc.CreateConfigToOCISpec(createConfig)
if err != nil {
return nil, err
}
return runtimeSpec, nil
}
// TestPIDsLimit verifies the inputted pid-limit is correctly defined in the spec
func TestPIDsLimit(t *testing.T) {
// The default configuration of podman enables seccomp, which is not available on non-Linux systems.
// Thus, any tests that use the default seccomp setting would fail.
// Skip the tests on non-Linux platforms rather than explicitly disable seccomp in the test and possibly affect the test result.
if runtime.GOOS != "linux" {
t.Skip("seccomp, which is enabled by default, is only supported on Linux")
}
args := []string{"--pids-limit", "22"}
a := createCLI(args)
a.InputArgs = args
//a.Run(append(cmd, args...))
runtimeSpec, err := getRuntimeSpec(a)
if err != nil {
t.Fatalf(err.Error())
}
assert.Equal(t, runtimeSpec.Linux.Resources.Pids.Limit, int64(22))
}
// TestBLKIOWeightDevice verifies the inputted blkio weigh device is correctly defined in the spec
func TestBLKIOWeightDevice(t *testing.T) {
// The default configuration of podman enables seccomp, which is not available on non-Linux systems.
// Thus, any tests that use the default seccomp setting would fail.
// Skip the tests on non-Linux platforms rather than explicitly disable seccomp in the test and possibly affect the test result.
if runtime.GOOS != "linux" {
t.Skip("seccomp, which is enabled by default, is only supported on Linux")
}
args := []string{"--blkio-weight-device", "/dev/zero:100"}
a := createCLI(args)
a.InputArgs = args
runtimeSpec, err := getRuntimeSpec(a)
if err != nil {
t.Fatalf(err.Error())
}
assert.Equal(t, *runtimeSpec.Linux.Resources.BlockIO.WeightDevice[0].Weight, uint16(100))
}
// TestMemorySwap verifies that the inputted memory swap is correctly defined in the spec
func TestMemorySwap(t *testing.T) {
// The default configuration of podman enables seccomp, which is not available on non-Linux systems.
// Thus, any tests that use the default seccomp setting would fail.
// Skip the tests on non-Linux platforms rather than explicitly disable seccomp in the test and possibly affect the test result.
if runtime.GOOS != "linux" {
t.Skip("seccomp, which is enabled by default, is only supported on Linux")
}
args := []string{"--memory-swap", "45m", "--memory", "40m"}
a := createCLI(args)
a.InputArgs = args
//a.Run(append(cmd, args...))
runtimeSpec, err := getRuntimeSpec(a)
if err != nil {
t.Fatalf(err.Error())
}
mem, _ := units.RAMInBytes("45m")
assert.Equal(t, *runtimeSpec.Linux.Resources.Memory.Swap, mem)
}
|
