podman

1
//go:build !remote
2

3
package libpod
4

5
import (
6
	"testing"
7

8
	"github.com/containers/podman/v5/libpod/lock"
9
	"github.com/stretchr/testify/assert"
10
)
11

12
func TestBuildContainerGraphNoCtrsIsEmpty(t *testing.T) {
13
	graph, err := BuildContainerGraph([]*Container{})
14
	assert.NoError(t, err)
15
	assert.Equal(t, 0, len(graph.nodes))
16
	assert.Equal(t, 0, len(graph.noDepNodes))
17
	assert.Equal(t, 0, len(graph.notDependedOnNodes))
18
}
19

20
func TestBuildContainerGraphOneCtr(t *testing.T) {
21
	manager, err := lock.NewInMemoryManager(16)
22
	if err != nil {
23
		t.Fatalf("Error setting up locks: %v", err)
24
	}
25

26
	ctr1, err := getTestCtr1(manager)
27
	assert.NoError(t, err)
28

29
	graph, err := BuildContainerGraph([]*Container{ctr1})
30
	assert.NoError(t, err)
31
	assert.Equal(t, 1, len(graph.nodes))
32
	assert.Equal(t, 1, len(graph.noDepNodes))
33
	assert.Equal(t, 1, len(graph.notDependedOnNodes))
34

35
	node, ok := graph.nodes[ctr1.ID()]
36
	assert.True(t, ok)
37
	assert.Equal(t, ctr1.ID(), node.id)
38

39
	assert.Equal(t, ctr1.ID(), graph.noDepNodes[0].id)
40
	assert.Equal(t, ctr1.ID(), graph.notDependedOnNodes[ctr1.ID()].id)
41
}
42

43
func TestBuildContainerGraphTwoCtrNoEdge(t *testing.T) {
44
	manager, err := lock.NewInMemoryManager(16)
45
	if err != nil {
46
		t.Fatalf("Error setting up locks: %v", err)
47
	}
48

49
	ctr1, err := getTestCtr1(manager)
50
	assert.NoError(t, err)
51
	ctr2, err := getTestCtr2(manager)
52
	assert.NoError(t, err)
53

54
	graph, err := BuildContainerGraph([]*Container{ctr1, ctr2})
55
	assert.NoError(t, err)
56
	assert.Equal(t, 2, len(graph.nodes))
57
	assert.Equal(t, 2, len(graph.noDepNodes))
58
	assert.Equal(t, 2, len(graph.notDependedOnNodes))
59

60
	node1, ok := graph.nodes[ctr1.ID()]
61
	assert.True(t, ok)
62
	assert.Equal(t, ctr1.ID(), node1.id)
63

64
	node2, ok := graph.nodes[ctr2.ID()]
65
	assert.True(t, ok)
66
	assert.Equal(t, ctr2.ID(), node2.id)
67
}
68

69
func TestBuildContainerGraphTwoCtrOneEdge(t *testing.T) {
70
	manager, err := lock.NewInMemoryManager(16)
71
	if err != nil {
72
		t.Fatalf("Error setting up locks: %v", err)
73
	}
74

75
	ctr1, err := getTestCtr1(manager)
76
	assert.NoError(t, err)
77
	ctr2, err := getTestCtr2(manager)
78
	assert.NoError(t, err)
79
	ctr2.config.UserNsCtr = ctr1.config.ID
80

81
	graph, err := BuildContainerGraph([]*Container{ctr1, ctr2})
82
	assert.NoError(t, err)
83
	assert.Equal(t, 2, len(graph.nodes))
84
	assert.Equal(t, 1, len(graph.noDepNodes))
85
	assert.Equal(t, 1, len(graph.notDependedOnNodes))
86

87
	assert.Equal(t, ctr1.ID(), graph.noDepNodes[0].id)
88
	assert.Equal(t, ctr2.ID(), graph.notDependedOnNodes[ctr2.ID()].id)
89
}
90

91
func TestBuildContainerGraphTwoCtrCycle(t *testing.T) {
92
	manager, err := lock.NewInMemoryManager(16)
93
	if err != nil {
94
		t.Fatalf("Error setting up locks: %v", err)
95
	}
96

97
	ctr1, err := getTestCtr1(manager)
98
	assert.NoError(t, err)
99
	ctr2, err := getTestCtr2(manager)
100
	assert.NoError(t, err)
101
	ctr2.config.UserNsCtr = ctr1.config.ID
102
	ctr1.config.NetNsCtr = ctr2.config.ID
103

104
	_, err = BuildContainerGraph([]*Container{ctr1, ctr2})
105
	assert.Error(t, err)
106
}
107

108
func TestBuildContainerGraphThreeCtrNoEdges(t *testing.T) {
109
	manager, err := lock.NewInMemoryManager(16)
110
	if err != nil {
111
		t.Fatalf("Error setting up locks: %v", err)
112
	}
113

114
	ctr1, err := getTestCtr1(manager)
115
	assert.NoError(t, err)
116
	ctr2, err := getTestCtr2(manager)
117
	assert.NoError(t, err)
118
	ctr3, err := getTestCtrN("3", manager)
119
	assert.NoError(t, err)
120

121
	graph, err := BuildContainerGraph([]*Container{ctr1, ctr2, ctr3})
122
	assert.NoError(t, err)
123
	assert.Equal(t, 3, len(graph.nodes))
124
	assert.Equal(t, 3, len(graph.noDepNodes))
125
	assert.Equal(t, 3, len(graph.notDependedOnNodes))
126

127
	node1, ok := graph.nodes[ctr1.ID()]
128
	assert.True(t, ok)
129
	assert.Equal(t, ctr1.ID(), node1.id)
130

131
	node2, ok := graph.nodes[ctr2.ID()]
132
	assert.True(t, ok)
133
	assert.Equal(t, ctr2.ID(), node2.id)
134

135
	node3, ok := graph.nodes[ctr3.ID()]
136
	assert.True(t, ok)
137
	assert.Equal(t, ctr3.ID(), node3.id)
138
}
139

140
func TestBuildContainerGraphThreeContainersTwoInCycle(t *testing.T) {
141
	manager, err := lock.NewInMemoryManager(16)
142
	if err != nil {
143
		t.Fatalf("Error setting up locks: %v", err)
144
	}
145

146
	ctr1, err := getTestCtr1(manager)
147
	assert.NoError(t, err)
148
	ctr2, err := getTestCtr2(manager)
149
	assert.NoError(t, err)
150
	ctr3, err := getTestCtrN("3", manager)
151
	assert.NoError(t, err)
152
	ctr1.config.UserNsCtr = ctr2.config.ID
153
	ctr2.config.IPCNsCtr = ctr1.config.ID
154

155
	_, err = BuildContainerGraph([]*Container{ctr1, ctr2, ctr3})
156
	assert.Error(t, err)
157
}
158

159
func TestBuildContainerGraphThreeContainersCycle(t *testing.T) {
160
	manager, err := lock.NewInMemoryManager(16)
161
	if err != nil {
162
		t.Fatalf("Error setting up locks: %v", err)
163
	}
164

165
	ctr1, err := getTestCtr1(manager)
166
	assert.NoError(t, err)
167
	ctr2, err := getTestCtr2(manager)
168
	assert.NoError(t, err)
169
	ctr3, err := getTestCtrN("3", manager)
170
	assert.NoError(t, err)
171
	ctr1.config.UserNsCtr = ctr2.config.ID
172
	ctr2.config.IPCNsCtr = ctr3.config.ID
173
	ctr3.config.NetNsCtr = ctr1.config.ID
174

175
	_, err = BuildContainerGraph([]*Container{ctr1, ctr2, ctr3})
176
	assert.Error(t, err)
177
}
178

179
func TestBuildContainerGraphThreeContainersNoCycle(t *testing.T) {
180
	manager, err := lock.NewInMemoryManager(16)
181
	if err != nil {
182
		t.Fatalf("Error setting up locks: %v", err)
183
	}
184

185
	ctr1, err := getTestCtr1(manager)
186
	assert.NoError(t, err)
187
	ctr2, err := getTestCtr2(manager)
188
	assert.NoError(t, err)
189
	ctr3, err := getTestCtrN("3", manager)
190
	assert.NoError(t, err)
191
	ctr1.config.UserNsCtr = ctr2.config.ID
192
	ctr1.config.NetNsCtr = ctr3.config.ID
193
	ctr2.config.IPCNsCtr = ctr3.config.ID
194

195
	graph, err := BuildContainerGraph([]*Container{ctr1, ctr2, ctr3})
196
	assert.NoError(t, err)
197
	assert.Equal(t, 3, len(graph.nodes))
198
	assert.Equal(t, 1, len(graph.noDepNodes))
199
	assert.Equal(t, 1, len(graph.notDependedOnNodes))
200

201
	assert.Equal(t, ctr3.ID(), graph.noDepNodes[0].id)
202
	assert.Equal(t, ctr1.ID(), graph.notDependedOnNodes[ctr1.ID()].id)
203
}
204

205
func TestBuildContainerGraphFourContainersNoEdges(t *testing.T) {
206
	manager, err := lock.NewInMemoryManager(16)
207
	if err != nil {
208
		t.Fatalf("Error setting up locks: %v", err)
209
	}
210

211
	ctr1, err := getTestCtr1(manager)
212
	assert.NoError(t, err)
213
	ctr2, err := getTestCtr2(manager)
214
	assert.NoError(t, err)
215
	ctr3, err := getTestCtrN("3", manager)
216
	assert.NoError(t, err)
217
	ctr4, err := getTestCtrN("4", manager)
218
	assert.NoError(t, err)
219

220
	graph, err := BuildContainerGraph([]*Container{ctr1, ctr2, ctr3, ctr4})
221
	assert.NoError(t, err)
222
	assert.Equal(t, 4, len(graph.nodes))
223
	assert.Equal(t, 4, len(graph.noDepNodes))
224
	assert.Equal(t, 4, len(graph.notDependedOnNodes))
225

226
	node1, ok := graph.nodes[ctr1.ID()]
227
	assert.True(t, ok)
228
	assert.Equal(t, ctr1.ID(), node1.id)
229

230
	node2, ok := graph.nodes[ctr2.ID()]
231
	assert.True(t, ok)
232
	assert.Equal(t, ctr2.ID(), node2.id)
233

234
	node3, ok := graph.nodes[ctr3.ID()]
235
	assert.True(t, ok)
236
	assert.Equal(t, ctr3.ID(), node3.id)
237

238
	node4, ok := graph.nodes[ctr4.ID()]
239
	assert.True(t, ok)
240
	assert.Equal(t, ctr4.ID(), node4.id)
241
}
242

243
func TestBuildContainerGraphFourContainersTwoInCycle(t *testing.T) {
244
	manager, err := lock.NewInMemoryManager(16)
245
	if err != nil {
246
		t.Fatalf("Error setting up locks: %v", err)
247
	}
248

249
	ctr1, err := getTestCtr1(manager)
250
	assert.NoError(t, err)
251
	ctr2, err := getTestCtr2(manager)
252
	assert.NoError(t, err)
253
	ctr3, err := getTestCtrN("3", manager)
254
	assert.NoError(t, err)
255
	ctr4, err := getTestCtrN("4", manager)
256
	assert.NoError(t, err)
257

258
	ctr1.config.IPCNsCtr = ctr2.config.ID
259
	ctr2.config.UserNsCtr = ctr1.config.ID
260

261
	_, err = BuildContainerGraph([]*Container{ctr1, ctr2, ctr3, ctr4})
262
	assert.Error(t, err)
263
}
264

265
func TestBuildContainerGraphFourContainersAllInCycle(t *testing.T) {
266
	manager, err := lock.NewInMemoryManager(16)
267
	if err != nil {
268
		t.Fatalf("Error setting up locks: %v", err)
269
	}
270

271
	ctr1, err := getTestCtr1(manager)
272
	assert.NoError(t, err)
273
	ctr2, err := getTestCtr2(manager)
274
	assert.NoError(t, err)
275
	ctr3, err := getTestCtrN("3", manager)
276
	assert.NoError(t, err)
277
	ctr4, err := getTestCtrN("4", manager)
278
	assert.NoError(t, err)
279

280
	ctr1.config.IPCNsCtr = ctr2.config.ID
281
	ctr2.config.UserNsCtr = ctr3.config.ID
282
	ctr3.config.NetNsCtr = ctr4.config.ID
283
	ctr4.config.UTSNsCtr = ctr1.config.ID
284

285
	_, err = BuildContainerGraph([]*Container{ctr1, ctr2, ctr3, ctr4})
286
	assert.Error(t, err)
287
}
288

289
func TestBuildContainerGraphFourContainersNoneInCycle(t *testing.T) {
290
	manager, err := lock.NewInMemoryManager(16)
291
	if err != nil {
292
		t.Fatalf("Error setting up locks: %v", err)
293
	}
294

295
	ctr1, err := getTestCtr1(manager)
296
	assert.NoError(t, err)
297
	ctr2, err := getTestCtr2(manager)
298
	assert.NoError(t, err)
299
	ctr3, err := getTestCtrN("3", manager)
300
	assert.NoError(t, err)
301
	ctr4, err := getTestCtrN("4", manager)
302
	assert.NoError(t, err)
303

304
	ctr1.config.IPCNsCtr = ctr2.config.ID
305
	ctr1.config.NetNsCtr = ctr3.config.ID
306
	ctr2.config.UserNsCtr = ctr3.config.ID
307

308
	graph, err := BuildContainerGraph([]*Container{ctr1, ctr2, ctr3, ctr4})
309
	assert.NoError(t, err)
310
	assert.Equal(t, 4, len(graph.nodes))
311
	assert.Equal(t, 2, len(graph.noDepNodes))
312
	assert.Equal(t, 2, len(graph.notDependedOnNodes))
313
}
314