podman

1
//go:build linux
2

3
package specgenutil
4

5
import (
6
	"fmt"
7
	"strings"
8
	"testing"
9

10
	"github.com/containers/common/pkg/machine"
11
	"github.com/containers/podman/v5/pkg/domain/entities"
12
	"github.com/containers/podman/v5/pkg/specgen"
13
	"github.com/stretchr/testify/assert"
14
)
15

16
func TestWinPath(t *testing.T) {
17
	const (
18
		fail = false
19
		pass = true
20
	)
21
	tests := []struct {
22
		vol     string
23
		source  string
24
		dest    string
25
		isN     bool
26
		outcome bool
27
		mach    string
28
	}{
29
		{`C:\Foo:/blah`, "/mnt/c/Foo", "/blah", false, pass, "wsl"},
30
		{`C:\Foo:/blah`, "/mnt/c/Foo", "/blah", false, fail, ""},
31
		{`\\?\C:\Foo:/blah`, "/mnt/c/Foo", "/blah", false, pass, "wsl"},
32
		{`/c/bar:/blah`, "/mnt/c/bar", "/blah", false, pass, "wsl"},
33
		{`/c/bar:/blah`, "/c/bar", "/blah", false, pass, ""},
34
		{`/test/this:/blah`, "/test/this", "/blah", false, pass, "wsl"},
35
		{`c:/bar/something:/other`, "/mnt/c/bar/something", "/other", false, pass, "wsl"},
36
		{`c:/foo:ro`, "c", "/foo", true, pass, ""},
37
		{`\\computer\loc:/dest`, "", "", false, fail, "wsl"},
38
		{`\\.\drive\loc:/target`, "/mnt/wsl/drive/loc", "/target", false, pass, "wsl"},
39
	}
40

41
	f := func(vol string, mach string) (*specgen.SpecGenerator, error) {
42
		machine := machine.GetMachineMarker()
43
		oldEnable, oldType := machine.Enabled, machine.Type
44
		machine.Enabled, machine.Type = len(mach) > 0, mach
45
		sg := specgen.NewSpecGenerator("nothing", false)
46
		err := FillOutSpecGen(sg, &entities.ContainerCreateOptions{
47
			ImageVolume: "ignore",
48
			Volume:      []string{vol}}, []string{},
49
		)
50
		machine.Enabled, machine.Type = oldEnable, oldType
51
		return sg, err
52
	}
53

54
	for _, test := range tests {
55
		msg := "Checking: " + test.vol
56
		sg, err := f(test.vol, test.mach)
57
		if test.outcome == fail {
58
			assert.NotNil(t, err, msg)
59
			continue
60
		}
61
		if !assert.Nil(t, err, msg) {
62
			continue
63
		}
64
		if test.isN {
65
			if !assert.Equal(t, 1, len(sg.Volumes), msg) {
66
				continue
67
			}
68
			assert.Equal(t, test.source, sg.Volumes[0].Name, msg)
69
			assert.Equal(t, test.dest, sg.Volumes[0].Dest, msg)
70
		} else {
71
			if !assert.Equal(t, 1, len(sg.Mounts), msg) {
72
				continue
73
			}
74
			assert.Equal(t, test.source, sg.Mounts[0].Source, msg)
75
			assert.Equal(t, test.dest, sg.Mounts[0].Destination, msg)
76
		}
77
	}
78
}
79

80
func TestParseLinuxResourcesDeviceAccess(t *testing.T) {
81
	d, err := parseLinuxResourcesDeviceAccess("a *:* rwm")
82
	assert.Nil(t, err, "err is nil")
83
	assert.True(t, d.Allow, "allow is true")
84
	assert.Equal(t, d.Type, "a", "type is 'a'")
85
	assert.Nil(t, d.Minor, "minor is nil")
86
	assert.Nil(t, d.Major, "major is nil")
87

88
	d, err = parseLinuxResourcesDeviceAccess("b 3:* rwm")
89
	assert.Nil(t, err, "err is nil")
90
	assert.True(t, d.Allow, "allow is true")
91
	assert.Equal(t, d.Type, "b", "type is 'b'")
92
	assert.Nil(t, d.Minor, "minor is nil")
93
	assert.NotNil(t, d.Major, "major is not nil")
94
	assert.Equal(t, *d.Major, int64(3), "major is 3")
95

96
	d, err = parseLinuxResourcesDeviceAccess("a *:3 rwm")
97
	assert.Nil(t, err, "err is nil")
98
	assert.True(t, d.Allow, "allow is true")
99
	assert.Equal(t, d.Type, "a", "type is 'a'")
100
	assert.Nil(t, d.Major, "major is nil")
101
	assert.NotNil(t, d.Minor, "minor is not nil")
102
	assert.Equal(t, *d.Minor, int64(3), "minor is 3")
103

104
	d, err = parseLinuxResourcesDeviceAccess("c 1:2 rwm")
105
	assert.Nil(t, err, "err is nil")
106
	assert.True(t, d.Allow, "allow is true")
107
	assert.Equal(t, d.Type, "c", "type is 'c'")
108
	assert.NotNil(t, d.Major, "minor is not nil")
109
	assert.Equal(t, *d.Major, int64(1), "minor is 1")
110
	assert.NotNil(t, d.Minor, "minor is not nil")
111
	assert.Equal(t, *d.Minor, int64(2), "minor is 2")
112

113
	_, err = parseLinuxResourcesDeviceAccess("q *:* rwm")
114
	assert.NotNil(t, err, "err is not nil")
115

116
	_, err = parseLinuxResourcesDeviceAccess("a a:* rwm")
117
	assert.NotNil(t, err, "err is not nil")
118

119
	_, err = parseLinuxResourcesDeviceAccess("a *:a rwm")
120
	assert.NotNil(t, err, "err is not nil")
121

122
	_, err = parseLinuxResourcesDeviceAccess("a *:* abc")
123
	assert.NotNil(t, err, "err is not nil")
124

125
	_, err = parseLinuxResourcesDeviceAccess("* *:* *")
126
	assert.NotNil(t, err, "err is not nil")
127

128
	_, err = parseLinuxResourcesDeviceAccess("* *:a2 *")
129
	assert.NotNil(t, err, "err is not nil")
130

131
	_, err = parseLinuxResourcesDeviceAccess("*")
132
	assert.NotNil(t, err, "err is not nil")
133

134
	_, err = parseLinuxResourcesDeviceAccess("*:*")
135
	assert.NotNil(t, err, "err is not nil")
136

137
	_, err = parseLinuxResourcesDeviceAccess("a *:*")
138
	assert.NotNil(t, err, "err is not nil")
139

140
	_, err = parseLinuxResourcesDeviceAccess("a *:*")
141
	assert.NotNil(t, err, "err is not nil")
142

143
	_, err = parseLinuxResourcesDeviceAccess("a 12a:* r")
144
	assert.NotNil(t, err, "err is not nil")
145

146
	_, err = parseLinuxResourcesDeviceAccess("a a12:* r")
147
	assert.NotNil(t, err, "err is not nil")
148

149
	_, err = parseLinuxResourcesDeviceAccess("a 0x1:* r")
150
	assert.NotNil(t, err, "err is not nil")
151

152
	_, err = parseLinuxResourcesDeviceAccess("a -2:* r")
153
	assert.NotNil(t, err, "err is not nil")
154

155
	_, err = parseLinuxResourcesDeviceAccess("a *:-3 r")
156
	assert.NotNil(t, err, "err is not nil")
157
}
158

159
func TestGenRlimits(t *testing.T) {
160
	testLimits := map[string]string{
161
		"core":       "1:2",
162
		"cpu":        "1:2",
163
		"data":       "1:2",
164
		"fsize":      "1:2",
165
		"locks":      "1:2",
166
		"memlock":    "1:2",
167
		"msgqueue":   "1:2",
168
		"nice":       "1:2",
169
		"nofile":     "1:2",
170
		"nproc":      "1:2",
171
		"rss":        "1:2",
172
		"rtprio":     "1:2",
173
		"rttime":     "1:2",
174
		"sigpending": "1:2",
175
		"stack":      "1:2",
176
	}
177

178
	lowerCaseLimits := make([]string, 0, len(testLimits))
179
	upperCaseLimitsWithPrefix := make([]string, 0, len(testLimits))
180
	for name, limit := range testLimits {
181
		lowerCaseLimits = append(lowerCaseLimits, fmt.Sprintf("%s=%s", name, limit))
182
		upperCaseLimitsWithPrefix = append(upperCaseLimitsWithPrefix, strings.ToUpper(fmt.Sprintf("%s%s=%s", rlimitPrefix, name, limit)))
183
	}
184

185
	parsedLimits, err := GenRlimits(lowerCaseLimits)
186
	assert.NoError(t, err, "err is nil")
187

188
	for _, limit := range parsedLimits {
189
		val, ok := testLimits[limit.Type]
190
		assert.True(t, ok, "%s matched", limit.Type)
191
		assert.Equal(t, val, fmt.Sprintf("%d:%d", limit.Soft, limit.Hard), "soft and hard limits are equal")
192
	}
193

194
	parsedLimits, err = GenRlimits(upperCaseLimitsWithPrefix)
195
	assert.NoError(t, err, "err is nil")
196

197
	for _, limit := range parsedLimits {
198
		val, ok := testLimits[limit.Type]
199
		assert.True(t, ok, "%s matched", limit.Type)
200
		assert.Equal(t, val, fmt.Sprintf("%d:%d", limit.Soft, limit.Hard), "soft and hard limits are equal")
201
	}
202

203
	// go-utils module has no tests for the parser.
204
	_, err = GenRlimits([]string{"foo=1:1"})
205
	assert.Error(t, err, "err is not nil")
206

207
	_, err = GenRlimits([]string{"RLIMIT_FOO=1:1"})
208
	assert.Error(t, err, "err is not nil")
209

210
	_, err = GenRlimits([]string{"nofile"})
211
	assert.Error(t, err, "err is not nil")
212

213
	_, err = GenRlimits([]string{"nofile=bar"})
214
	assert.Error(t, err, "err is not nil")
215

216
	_, err = GenRlimits([]string{"nofile=bar:buzz"})
217
	assert.Error(t, err, "err is not nil")
218
}
219