podman

state_test.go
2633 строки · 67.3 Кб
Перенос по словам
1
//go:build !remote
2

3
package libpod
4

5
import (
6
	"os"
7
	"path/filepath"
8
	"strings"
9
	"testing"
10
	"time"
11

12
	"github.com/containers/common/libnetwork/types"
13
	"github.com/containers/common/pkg/config"
14
	"github.com/containers/podman/v5/libpod/define"
15
	"github.com/containers/podman/v5/libpod/lock"
16
	"github.com/containers/storage"
17
	"github.com/stretchr/testify/assert"
18
	"github.com/stretchr/testify/require"
19
)
20

21
// Returns state, tmp directory containing all state files, lock manager, and
22
// error.
23
// Closing the state and removing the given tmp directory should be sufficient
24
// to clean up.
25
type emptyStateFunc func() (State, string, lock.Manager, error)
26

27
const (
28
	tmpDirPrefix = "libpod_state_test_"
29
)
30

31
var (
32
	testedStates = map[string]emptyStateFunc{
33
		"boltdb": getEmptyBoltState,
34
	}
35
)
36

37
// Get an empty BoltDB state for use in tests
38
func getEmptyBoltState() (_ State, _ string, _ lock.Manager, retErr error) {
39
	tmpDir, err := os.MkdirTemp("", tmpDirPrefix)
40
	if err != nil {
41
		return nil, "", nil, err
42
	}
43
	defer func() {
44
		if retErr != nil {
45
			os.RemoveAll(tmpDir)
46
		}
47
	}()
48

49
	if err := os.Setenv("CI_DESIRED_DATABASE", "boltdb"); err != nil {
50
		return nil, "", nil, err
51
	}
52

53
	dbPath := filepath.Join(tmpDir, "db.sql")
54

55
	lockManager, err := lock.NewInMemoryManager(16)
56
	if err != nil {
57
		return nil, "", nil, err
58
	}
59

60
	runtime := new(Runtime)
61
	runtime.config = new(config.Config)
62
	runtime.storageConfig = storage.StoreOptions{}
63
	runtime.lockManager = lockManager
64

65
	state, err := NewBoltState(dbPath, runtime)
66
	if err != nil {
67
		return nil, "", nil, err
68
	}
69

70
	return state, tmpDir, lockManager, nil
71
}
72

73
func runForAllStates(t *testing.T, testFunc func(*testing.T, State, lock.Manager)) {
74
	for stateName, stateFunc := range testedStates {
75
		state, path, manager, err := stateFunc()
76
		if err != nil {
77
			t.Fatalf("Error initializing state %s: %v", stateName, err)
78
		}
79
		defer os.RemoveAll(path)
80
		defer state.Close()
81

82
		success := t.Run(stateName, func(t *testing.T) {
83
			testFunc(t, state, manager)
84
		})
85
		if !success {
86
			t.Fail()
87
		}
88
	}
89
}
90

91
func TestAddAndGetContainer(t *testing.T) {
92
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
93
		testCtr, err := getTestCtr1(manager)
94
		assert.NoError(t, err)
95

96
		err = state.AddContainer(testCtr)
97
		assert.NoError(t, err)
98

99
		retrievedCtr, err := state.Container(testCtr.ID())
100
		assert.NoError(t, err)
101

102
		testContainersEqual(t, retrievedCtr, testCtr, true)
103
	})
104
}
105

106
func TestAddAndGetContainerFromMultiple(t *testing.T) {
107
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
108
		testCtr1, err := getTestCtr1(manager)
109
		assert.NoError(t, err)
110
		testCtr2, err := getTestCtr2(manager)
111
		assert.NoError(t, err)
112

113
		err = state.AddContainer(testCtr1)
114
		assert.NoError(t, err)
115

116
		err = state.AddContainer(testCtr2)
117
		assert.NoError(t, err)
118

119
		retrievedCtr, err := state.Container(testCtr1.ID())
120
		assert.NoError(t, err)
121

122
		testContainersEqual(t, retrievedCtr, testCtr1, true)
123
	})
124
}
125

126
func TestGetContainerPodSameIDFails(t *testing.T) {
127
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
128
		testPod, err := getTestPod1(manager)
129
		assert.NoError(t, err)
130

131
		err = state.AddPod(testPod)
132
		assert.NoError(t, err)
133

134
		_, err = state.Container(testPod.ID())
135
		assert.Error(t, err)
136
	})
137
}
138

139
func TestAddInvalidContainerFails(t *testing.T) {
140
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
141
		err := state.AddContainer(&Container{config: &ContainerConfig{ID: "1234"}})
142
		assert.Error(t, err)
143
	})
144
}
145

146
func TestAddDuplicateCtrIDFails(t *testing.T) {
147
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
148
		testCtr1, err := getTestCtr1(manager)
149
		assert.NoError(t, err)
150
		testCtr2, err := getTestContainer(testCtr1.ID(), "test2", manager)
151
		assert.NoError(t, err)
152

153
		err = state.AddContainer(testCtr1)
154
		assert.NoError(t, err)
155

156
		err = state.AddContainer(testCtr2)
157
		assert.Error(t, err)
158

159
		ctrs, err := state.AllContainers(false)
160
		assert.NoError(t, err)
161
		assert.Equal(t, 1, len(ctrs))
162
	})
163
}
164

165
func TestAddDuplicateCtrNameFails(t *testing.T) {
166
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
167
		testCtr1, err := getTestCtr1(manager)
168
		assert.NoError(t, err)
169
		testCtr2, err := getTestContainer(strings.Repeat("2", 32), testCtr1.Name(), manager)
170
		assert.NoError(t, err)
171

172
		err = state.AddContainer(testCtr1)
173
		assert.NoError(t, err)
174

175
		err = state.AddContainer(testCtr2)
176
		assert.Error(t, err)
177

178
		ctrs, err := state.AllContainers(false)
179
		assert.NoError(t, err)
180
		assert.Equal(t, 1, len(ctrs))
181
	})
182
}
183

184
func TestAddCtrPodDupIDFails(t *testing.T) {
185
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
186
		testPod, err := getTestPod1(manager)
187
		assert.NoError(t, err)
188
		testCtr, err := getTestContainer(testPod.ID(), "testCtr", manager)
189
		assert.NoError(t, err)
190

191
		err = state.AddPod(testPod)
192
		assert.NoError(t, err)
193

194
		err = state.AddContainer(testCtr)
195
		assert.Error(t, err)
196

197
		ctrs, err := state.AllContainers(false)
198
		assert.NoError(t, err)
199
		assert.Equal(t, 0, len(ctrs))
200
	})
201
}
202

203
func TestAddCtrPodDupNameFails(t *testing.T) {
204
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
205
		testPod, err := getTestPod1(manager)
206
		assert.NoError(t, err)
207
		testCtr, err := getTestContainer(strings.Repeat("2", 32), testPod.Name(), manager)
208
		assert.NoError(t, err)
209

210
		err = state.AddPod(testPod)
211
		assert.NoError(t, err)
212

213
		err = state.AddContainer(testCtr)
214
		assert.Error(t, err)
215

216
		ctrs, err := state.AllContainers(false)
217
		assert.NoError(t, err)
218
		assert.Equal(t, 0, len(ctrs))
219
	})
220
}
221

222
func TestAddCtrInPodFails(t *testing.T) {
223
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
224
		testPod, err := getTestPod1(manager)
225
		assert.NoError(t, err)
226

227
		testCtr, err := getTestCtr2(manager)
228
		assert.NoError(t, err)
229

230
		testCtr.config.Pod = testPod.ID()
231

232
		err = state.AddPod(testPod)
233
		assert.NoError(t, err)
234

235
		err = state.AddContainer(testCtr)
236
		assert.Error(t, err)
237

238
		ctrs, err := state.AllContainers(false)
239
		assert.NoError(t, err)
240
		assert.Equal(t, 0, len(ctrs))
241
	})
242
}
243

244
func TestAddCtrDepInPodFails(t *testing.T) {
245
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
246
		testPod, err := getTestPod1(manager)
247
		assert.NoError(t, err)
248

249
		testCtr1, err := getTestCtr2(manager)
250
		assert.NoError(t, err)
251

252
		testCtr1.config.Pod = testPod.ID()
253

254
		testCtr2, err := getTestCtrN("3", manager)
255
		assert.NoError(t, err)
256

257
		testCtr2.config.UserNsCtr = testCtr1.ID()
258

259
		err = state.AddPod(testPod)
260
		assert.NoError(t, err)
261

262
		err = state.AddContainerToPod(testPod, testCtr1)
263
		assert.NoError(t, err)
264

265
		err = state.AddContainer(testCtr2)
266
		assert.Error(t, err)
267

268
		ctrs, err := state.AllContainers(false)
269
		assert.NoError(t, err)
270
		require.Len(t, ctrs, 1)
271

272
		testContainersEqual(t, ctrs[0], testCtr1, true)
273
	})
274
}
275

276
func TestGetNonexistentContainerFails(t *testing.T) {
277
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
278
		_, err := state.Container("does not exist")
279
		assert.Error(t, err)
280
	})
281
}
282

283
func TestGetContainerWithEmptyIDFails(t *testing.T) {
284
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
285
		_, err := state.Container("")
286
		assert.Error(t, err)
287
	})
288
}
289

290
func TestLookupContainerWithEmptyIDFails(t *testing.T) {
291
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
292
		_, err := state.LookupContainer("")
293
		assert.Error(t, err)
294

295
		_, err = state.LookupContainerID("")
296
		assert.Error(t, err)
297
	})
298
}
299

300
func TestLookupNonexistentContainerFails(t *testing.T) {
301
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
302
		_, err := state.LookupContainer("does not exist")
303
		assert.Error(t, err)
304

305
		_, err = state.LookupContainerID("does not exist")
306
		assert.Error(t, err)
307
	})
308
}
309

310
func TestLookupContainerByFullID(t *testing.T) {
311
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
312
		testCtr, err := getTestCtr1(manager)
313
		assert.NoError(t, err)
314

315
		err = state.AddContainer(testCtr)
316
		assert.NoError(t, err)
317

318
		retrievedCtr, err := state.LookupContainer(testCtr.ID())
319
		assert.NoError(t, err)
320
		testContainersEqual(t, retrievedCtr, testCtr, true)
321

322
		retrievedID, err := state.LookupContainerID(testCtr.ID())
323
		assert.NoError(t, err)
324
		assert.Equal(t, retrievedID, testCtr.ID())
325
	})
326
}
327

328
func TestLookupContainerByUniquePartialID(t *testing.T) {
329
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
330
		testCtr, err := getTestCtr1(manager)
331
		assert.NoError(t, err)
332

333
		err = state.AddContainer(testCtr)
334
		assert.NoError(t, err)
335

336
		retrievedCtr, err := state.LookupContainer(testCtr.ID()[0:8])
337
		assert.NoError(t, err)
338
		testContainersEqual(t, retrievedCtr, testCtr, true)
339

340
		retrievedID, err := state.LookupContainerID(testCtr.ID()[0:8])
341
		assert.NoError(t, err)
342
		assert.Equal(t, retrievedID, testCtr.ID())
343
	})
344
}
345

346
func TestLookupContainerByNonUniquePartialIDFails(t *testing.T) {
347
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
348
		testCtr1, err := getTestContainer(strings.Repeat("0", 32), "test1", manager)
349
		assert.NoError(t, err)
350
		testCtr2, err := getTestContainer(strings.Repeat("0", 31)+"1", "test2", manager)
351
		assert.NoError(t, err)
352

353
		err = state.AddContainer(testCtr1)
354
		assert.NoError(t, err)
355

356
		err = state.AddContainer(testCtr2)
357
		assert.NoError(t, err)
358

359
		_, err = state.LookupContainer(testCtr1.ID()[0:8])
360
		assert.Error(t, err)
361

362
		_, err = state.LookupContainerID(testCtr1.ID()[0:8])
363
		assert.Error(t, err)
364
	})
365
}
366

367
func TestLookupContainerByName(t *testing.T) {
368
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
369
		testCtr, err := getTestCtr1(manager)
370
		assert.NoError(t, err)
371

372
		err = state.AddContainer(testCtr)
373
		assert.NoError(t, err)
374

375
		retrievedCtr, err := state.LookupContainer(testCtr.Name())
376
		assert.NoError(t, err)
377
		testContainersEqual(t, retrievedCtr, testCtr, true)
378

379
		retrievedID, err := state.LookupContainerID(testCtr.Name())
380
		assert.NoError(t, err)
381
		assert.Equal(t, retrievedID, testCtr.ID())
382
	})
383
}
384

385
func TestLookupCtrByPodNameFails(t *testing.T) {
386
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
387
		testPod, err := getTestPod1(manager)
388
		assert.NoError(t, err)
389

390
		err = state.AddPod(testPod)
391
		assert.NoError(t, err)
392

393
		_, err = state.LookupContainer(testPod.Name())
394
		assert.Error(t, err)
395

396
		_, err = state.LookupContainerID(testPod.Name())
397
		assert.Error(t, err)
398
	})
399
}
400

401
func TestLookupCtrByPodIDFails(t *testing.T) {
402
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
403
		testPod, err := getTestPod1(manager)
404
		assert.NoError(t, err)
405

406
		err = state.AddPod(testPod)
407
		assert.NoError(t, err)
408

409
		_, err = state.LookupContainer(testPod.ID())
410
		assert.Error(t, err)
411

412
		_, err = state.LookupContainerID(testPod.ID())
413
		assert.Error(t, err)
414
	})
415
}
416

417
func TestHasContainerEmptyIDFails(t *testing.T) {
418
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
419
		_, err := state.HasContainer("")
420
		assert.Error(t, err)
421
	})
422
}
423

424
func TestHasContainerNoSuchContainerReturnsFalse(t *testing.T) {
425
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
426
		exists, err := state.HasContainer("does not exist")
427
		assert.NoError(t, err)
428
		assert.False(t, exists)
429
	})
430
}
431

432
func TestHasContainerFindsContainer(t *testing.T) {
433
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
434
		testCtr, err := getTestCtr1(manager)
435
		assert.NoError(t, err)
436

437
		err = state.AddContainer(testCtr)
438
		assert.NoError(t, err)
439

440
		exists, err := state.HasContainer(testCtr.ID())
441
		assert.NoError(t, err)
442
		assert.True(t, exists)
443
	})
444
}
445

446
func TestHasContainerPodIDIsFalse(t *testing.T) {
447
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
448
		testPod, err := getTestPod1(manager)
449
		assert.NoError(t, err)
450

451
		err = state.AddPod(testPod)
452
		assert.NoError(t, err)
453

454
		exists, err := state.HasContainer(testPod.ID())
455
		assert.NoError(t, err)
456
		assert.False(t, exists)
457
	})
458
}
459

460
func TestSaveAndUpdateContainer(t *testing.T) {
461
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
462
		testCtr, err := getTestCtr1(manager)
463
		assert.NoError(t, err)
464

465
		err = state.AddContainer(testCtr)
466
		assert.NoError(t, err)
467

468
		retrievedCtr, err := state.Container(testCtr.ID())
469
		require.NoError(t, err)
470

471
		retrievedCtr.state.State = define.ContainerStateStopped
472
		retrievedCtr.state.ExitCode = 127
473
		retrievedCtr.state.FinishedTime = time.Now()
474

475
		err = state.SaveContainer(retrievedCtr)
476
		assert.NoError(t, err)
477

478
		err = state.UpdateContainer(testCtr)
479
		assert.NoError(t, err)
480

481
		testContainersEqual(t, testCtr, retrievedCtr, false)
482
	})
483
}
484

485
func TestUpdateContainerNotInDatabaseReturnsError(t *testing.T) {
486
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
487
		testCtr, err := getTestCtr1(manager)
488
		assert.NoError(t, err)
489

490
		err = state.UpdateContainer(testCtr)
491
		assert.Error(t, err)
492
		assert.False(t, testCtr.valid)
493
	})
494
}
495

496
func TestUpdateInvalidContainerReturnsError(t *testing.T) {
497
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
498
		err := state.UpdateContainer(&Container{config: &ContainerConfig{ID: "1234"}})
499
		assert.Error(t, err)
500
	})
501
}
502

503
func TestSaveInvalidContainerReturnsError(t *testing.T) {
504
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
505
		err := state.SaveContainer(&Container{config: &ContainerConfig{ID: "1234"}})
506
		assert.Error(t, err)
507
	})
508
}
509

510
func TestSaveContainerNotInStateReturnsError(t *testing.T) {
511
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
512
		testCtr, err := getTestCtr1(manager)
513
		assert.NoError(t, err)
514

515
		err = state.SaveContainer(testCtr)
516
		assert.Error(t, err)
517
		assert.False(t, testCtr.valid)
518
	})
519
}
520

521
func TestRemoveContainer(t *testing.T) {
522
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
523
		testCtr, err := getTestCtr1(manager)
524
		assert.NoError(t, err)
525

526
		err = state.AddContainer(testCtr)
527
		assert.NoError(t, err)
528

529
		ctrs, err := state.AllContainers(false)
530
		assert.NoError(t, err)
531
		assert.Equal(t, 1, len(ctrs))
532

533
		err = state.RemoveContainer(testCtr)
534
		assert.NoError(t, err)
535

536
		ctrs2, err := state.AllContainers(false)
537
		assert.NoError(t, err)
538
		assert.Equal(t, 0, len(ctrs2))
539
	})
540
}
541

542
func TestRemoveNonexistentContainerFails(t *testing.T) {
543
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
544
		testCtr, err := getTestCtr1(manager)
545
		assert.NoError(t, err)
546

547
		err = state.RemoveContainer(testCtr)
548
		assert.Error(t, err)
549
		assert.False(t, testCtr.valid)
550
	})
551
}
552

553
func TestGetAllContainersOnNewStateIsEmpty(t *testing.T) {
554
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
555
		ctrs, err := state.AllContainers(false)
556
		assert.NoError(t, err)
557
		assert.Equal(t, 0, len(ctrs))
558
	})
559
}
560

561
func TestGetAllContainersWithOneContainer(t *testing.T) {
562
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
563
		testCtr, err := getTestCtr1(manager)
564
		assert.NoError(t, err)
565

566
		err = state.AddContainer(testCtr)
567
		assert.NoError(t, err)
568

569
		ctrs, err := state.AllContainers(false)
570
		assert.NoError(t, err)
571
		require.Len(t, ctrs, 1)
572

573
		testContainersEqual(t, ctrs[0], testCtr, true)
574
	})
575
}
576

577
func TestGetAllContainersTwoContainers(t *testing.T) {
578
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
579
		testCtr1, err := getTestCtr1(manager)
580
		assert.NoError(t, err)
581
		testCtr2, err := getTestCtr2(manager)
582
		assert.NoError(t, err)
583

584
		err = state.AddContainer(testCtr1)
585
		assert.NoError(t, err)
586

587
		err = state.AddContainer(testCtr2)
588
		assert.NoError(t, err)
589

590
		ctrs, err := state.AllContainers(false)
591
		assert.NoError(t, err)
592
		assert.Equal(t, 2, len(ctrs))
593
	})
594
}
595

596
func TestContainerInUseInvalidContainer(t *testing.T) {
597
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
598
		_, err := state.ContainerInUse(&Container{})
599
		assert.Error(t, err)
600
	})
601
}
602

603
func TestContainerInUseCtrNotInState(t *testing.T) {
604
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
605
		testCtr, err := getTestCtr1(manager)
606
		assert.NoError(t, err)
607
		_, err = state.ContainerInUse(testCtr)
608
		assert.Error(t, err)
609
	})
610
}
611

612
func TestContainerInUseOneContainer(t *testing.T) {
613
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
614
		testCtr1, err := getTestCtr1(manager)
615
		assert.NoError(t, err)
616
		testCtr2, err := getTestCtr2(manager)
617
		assert.NoError(t, err)
618

619
		testCtr2.config.UserNsCtr = testCtr1.config.ID
620

621
		err = state.AddContainer(testCtr1)
622
		assert.NoError(t, err)
623

624
		err = state.AddContainer(testCtr2)
625
		assert.NoError(t, err)
626

627
		ids, err := state.ContainerInUse(testCtr1)
628
		assert.NoError(t, err)
629
		assert.Equal(t, 1, len(ids))
630
		assert.Equal(t, testCtr2.config.ID, ids[0])
631
	})
632
}
633

634
func TestContainerInUseTwoContainers(t *testing.T) {
635
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
636
		testCtr1, err := getTestCtr1(manager)
637
		assert.NoError(t, err)
638
		testCtr2, err := getTestCtr2(manager)
639
		assert.NoError(t, err)
640
		testCtr3, err := getTestCtrN("3", manager)
641
		assert.NoError(t, err)
642

643
		testCtr2.config.UserNsCtr = testCtr1.config.ID
644
		testCtr3.config.IPCNsCtr = testCtr1.config.ID
645

646
		err = state.AddContainer(testCtr1)
647
		assert.NoError(t, err)
648

649
		err = state.AddContainer(testCtr2)
650
		assert.NoError(t, err)
651

652
		err = state.AddContainer(testCtr3)
653
		assert.NoError(t, err)
654

655
		ids, err := state.ContainerInUse(testCtr1)
656
		assert.NoError(t, err)
657
		assert.Equal(t, 2, len(ids))
658
	})
659
}
660

661
func TestContainerInUseOneContainerMultipleDependencies(t *testing.T) {
662
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
663
		testCtr1, err := getTestCtr1(manager)
664
		assert.NoError(t, err)
665
		testCtr2, err := getTestCtr2(manager)
666
		assert.NoError(t, err)
667

668
		testCtr2.config.UserNsCtr = testCtr1.config.ID
669
		testCtr2.config.IPCNsCtr = testCtr1.config.ID
670

671
		err = state.AddContainer(testCtr1)
672
		assert.NoError(t, err)
673

674
		err = state.AddContainer(testCtr2)
675
		assert.NoError(t, err)
676

677
		ids, err := state.ContainerInUse(testCtr1)
678
		assert.NoError(t, err)
679
		assert.Equal(t, 1, len(ids))
680
		assert.Equal(t, testCtr2.config.ID, ids[0])
681
	})
682
}
683

684
func TestContainerInUseGenericDependency(t *testing.T) {
685
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
686
		testCtr1, err := getTestCtr1(manager)
687
		assert.NoError(t, err)
688
		testCtr2, err := getTestCtr2(manager)
689
		assert.NoError(t, err)
690

691
		testCtr2.config.Dependencies = []string{testCtr1.config.ID}
692

693
		err = state.AddContainer(testCtr1)
694
		assert.NoError(t, err)
695

696
		err = state.AddContainer(testCtr2)
697
		assert.NoError(t, err)
698

699
		ids, err := state.ContainerInUse(testCtr1)
700
		assert.NoError(t, err)
701
		assert.Equal(t, 1, len(ids))
702
		assert.Equal(t, testCtr2.config.ID, ids[0])
703
	})
704
}
705

706
func TestContainerInUseMultipleGenericDependencies(t *testing.T) {
707
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
708
		testCtr1, err := getTestCtr1(manager)
709
		assert.NoError(t, err)
710
		testCtr2, err := getTestCtr2(manager)
711
		assert.NoError(t, err)
712
		testCtr3, err := getTestCtrN("3", manager)
713
		assert.NoError(t, err)
714

715
		testCtr3.config.Dependencies = []string{testCtr1.config.ID, testCtr2.config.ID}
716

717
		err = state.AddContainer(testCtr1)
718
		assert.NoError(t, err)
719

720
		err = state.AddContainer(testCtr2)
721
		assert.NoError(t, err)
722

723
		err = state.AddContainer(testCtr3)
724
		assert.NoError(t, err)
725

726
		ids1, err := state.ContainerInUse(testCtr1)
727
		assert.NoError(t, err)
728
		assert.Equal(t, 1, len(ids1))
729
		assert.Equal(t, testCtr3.config.ID, ids1[0])
730

731
		ids2, err := state.ContainerInUse(testCtr2)
732
		assert.NoError(t, err)
733
		assert.Equal(t, 1, len(ids2))
734
		assert.Equal(t, testCtr3.config.ID, ids2[0])
735
	})
736
}
737

738
func TestContainerInUseGenericAndNamespaceDependencies(t *testing.T) {
739
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
740
		testCtr1, err := getTestCtr1(manager)
741
		assert.NoError(t, err)
742
		testCtr2, err := getTestCtr2(manager)
743
		assert.NoError(t, err)
744

745
		testCtr2.config.Dependencies = []string{testCtr1.config.ID}
746
		testCtr2.config.IPCNsCtr = testCtr1.config.ID
747

748
		err = state.AddContainer(testCtr1)
749
		assert.NoError(t, err)
750

751
		err = state.AddContainer(testCtr2)
752
		assert.NoError(t, err)
753

754
		ids, err := state.ContainerInUse(testCtr1)
755
		assert.NoError(t, err)
756
		assert.Equal(t, 1, len(ids))
757
		assert.Equal(t, testCtr2.config.ID, ids[0])
758
	})
759
}
760

761
func TestCannotRemoveContainerWithDependency(t *testing.T) {
762
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
763
		testCtr1, err := getTestCtr1(manager)
764
		assert.NoError(t, err)
765
		testCtr2, err := getTestCtr2(manager)
766
		assert.NoError(t, err)
767

768
		testCtr2.config.UserNsCtr = testCtr1.config.ID
769

770
		err = state.AddContainer(testCtr1)
771
		assert.NoError(t, err)
772

773
		err = state.AddContainer(testCtr2)
774
		assert.NoError(t, err)
775

776
		err = state.RemoveContainer(testCtr1)
777
		assert.Error(t, err)
778

779
		ctrs, err := state.AllContainers(false)
780
		assert.NoError(t, err)
781
		assert.Equal(t, 2, len(ctrs))
782
	})
783
}
784

785
func TestCannotRemoveContainerWithGenericDependency(t *testing.T) {
786
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
787
		testCtr1, err := getTestCtr1(manager)
788
		assert.NoError(t, err)
789
		testCtr2, err := getTestCtr2(manager)
790
		assert.NoError(t, err)
791

792
		testCtr2.config.Dependencies = []string{testCtr1.config.ID}
793

794
		err = state.AddContainer(testCtr1)
795
		assert.NoError(t, err)
796

797
		err = state.AddContainer(testCtr2)
798
		assert.NoError(t, err)
799

800
		err = state.RemoveContainer(testCtr1)
801
		assert.Error(t, err)
802

803
		ctrs, err := state.AllContainers(false)
804
		assert.NoError(t, err)
805
		assert.Equal(t, 2, len(ctrs))
806
	})
807
}
808

809
func TestCanRemoveContainerAfterDependencyRemoved(t *testing.T) {
810
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
811
		testCtr1, err := getTestCtr1(manager)
812
		assert.NoError(t, err)
813
		testCtr2, err := getTestCtr2(manager)
814
		assert.NoError(t, err)
815

816
		testCtr2.config.UserNsCtr = testCtr1.ID()
817

818
		err = state.AddContainer(testCtr1)
819
		assert.NoError(t, err)
820

821
		err = state.AddContainer(testCtr2)
822
		assert.NoError(t, err)
823

824
		err = state.RemoveContainer(testCtr2)
825
		assert.NoError(t, err)
826

827
		err = state.RemoveContainer(testCtr1)
828
		assert.NoError(t, err)
829

830
		ctrs, err := state.AllContainers(false)
831
		assert.NoError(t, err)
832
		assert.Equal(t, 0, len(ctrs))
833
	})
834
}
835

836
func TestCanRemoveContainerAfterDependencyRemovedDuplicate(t *testing.T) {
837
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
838
		testCtr1, err := getTestCtr1(manager)
839
		assert.NoError(t, err)
840
		testCtr2, err := getTestCtr2(manager)
841
		assert.NoError(t, err)
842

843
		testCtr2.config.UserNsCtr = testCtr1.ID()
844
		testCtr2.config.IPCNsCtr = testCtr1.ID()
845

846
		err = state.AddContainer(testCtr1)
847
		assert.NoError(t, err)
848

849
		err = state.AddContainer(testCtr2)
850
		assert.NoError(t, err)
851

852
		err = state.RemoveContainer(testCtr2)
853
		assert.NoError(t, err)
854

855
		err = state.RemoveContainer(testCtr1)
856
		assert.NoError(t, err)
857

858
		ctrs, err := state.AllContainers(false)
859
		assert.NoError(t, err)
860
		assert.Equal(t, 0, len(ctrs))
861
	})
862
}
863

864
func TestCannotUsePodAsDependency(t *testing.T) {
865
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
866
		testCtr, err := getTestCtr1(manager)
867
		assert.NoError(t, err)
868

869
		testPod, err := getTestPod2(manager)
870
		assert.NoError(t, err)
871

872
		testCtr.config.UserNsCtr = testPod.ID()
873

874
		err = state.AddPod(testPod)
875
		assert.NoError(t, err)
876

877
		err = state.AddContainer(testCtr)
878
		assert.Error(t, err)
879

880
		ctrs, err := state.AllContainers(false)
881
		assert.NoError(t, err)
882
		assert.Equal(t, 0, len(ctrs))
883
	})
884
}
885

886
func TestAddContainerEmptyNetworkNameErrors(t *testing.T) {
887
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
888
		testCtr, err := getTestCtr1(manager)
889
		assert.NoError(t, err)
890

891
		testCtr.config.Networks = map[string]types.PerNetworkOptions{
892
			"": {},
893
		}
894

895
		err = state.AddContainer(testCtr)
896
		assert.Error(t, err)
897
	})
898
}
899

900
func TestCannotUseBadIDAsDependency(t *testing.T) {
901
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
902
		testCtr, err := getTestCtr1(manager)
903
		assert.NoError(t, err)
904

905
		testCtr.config.UserNsCtr = strings.Repeat("5", 32)
906

907
		err = state.AddContainer(testCtr)
908
		assert.Error(t, err)
909

910
		ctrs, err := state.AllContainers(false)
911
		assert.NoError(t, err)
912
		assert.Equal(t, 0, len(ctrs))
913
	})
914
}
915

916
func TestCannotUseBadIDAsGenericDependency(t *testing.T) {
917
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
918
		testCtr, err := getTestCtr1(manager)
919
		assert.NoError(t, err)
920

921
		testCtr.config.Dependencies = []string{strings.Repeat("5", 32)}
922

923
		err = state.AddContainer(testCtr)
924
		assert.Error(t, err)
925

926
		ctrs, err := state.AllContainers(false)
927
		assert.NoError(t, err)
928
		assert.Equal(t, 0, len(ctrs))
929
	})
930
}
931

932
func TestRewriteContainerConfigDoesNotExist(t *testing.T) {
933
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
934
		err := state.RewriteContainerConfig(&Container{}, &ContainerConfig{})
935
		assert.Error(t, err)
936
	})
937
}
938

939
func TestRewriteContainerConfigNotInState(t *testing.T) {
940
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
941
		testCtr, err := getTestCtr1(manager)
942
		assert.NoError(t, err)
943
		err = state.RewriteContainerConfig(testCtr, &ContainerConfig{})
944
		assert.Error(t, err)
945
	})
946
}
947

948
func TestRewriteContainerConfigRewritesConfig(t *testing.T) {
949
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
950
		testCtr, err := getTestCtr1(manager)
951
		assert.NoError(t, err)
952

953
		err = state.AddContainer(testCtr)
954
		assert.NoError(t, err)
955

956
		testCtr.config.LogPath = "/another/path/"
957

958
		err = state.RewriteContainerConfig(testCtr, testCtr.config)
959
		assert.NoError(t, err)
960

961
		testCtrFromState, err := state.Container(testCtr.ID())
962
		assert.NoError(t, err)
963

964
		testContainersEqual(t, testCtrFromState, testCtr, true)
965
	})
966
}
967

968
func TestRewritePodConfigDoesNotExist(t *testing.T) {
969
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
970
		err := state.RewritePodConfig(&Pod{}, &PodConfig{})
971
		assert.Error(t, err)
972
	})
973
}
974

975
func TestRewritePodConfigNotInState(t *testing.T) {
976
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
977
		testPod, err := getTestPod1(manager)
978
		assert.NoError(t, err)
979
		err = state.RewritePodConfig(testPod, &PodConfig{})
980
		assert.Error(t, err)
981
	})
982
}
983

984
func TestRewritePodConfigRewritesConfig(t *testing.T) {
985
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
986
		testPod, err := getTestPod1(manager)
987
		assert.NoError(t, err)
988

989
		err = state.AddPod(testPod)
990
		assert.NoError(t, err)
991

992
		testPod.config.CgroupParent = "/another_cgroup_parent"
993

994
		err = state.RewritePodConfig(testPod, testPod.config)
995
		assert.NoError(t, err)
996

997
		testPodFromState, err := state.Pod(testPod.ID())
998
		assert.NoError(t, err)
999

1000
		testPodsEqual(t, testPodFromState, testPod, true)
1001
	})
1002
}
1003

1004
func TestGetPodDoesNotExist(t *testing.T) {
1005
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1006
		_, err := state.Pod("doesnotexist")
1007
		assert.Error(t, err)
1008
	})
1009
}
1010

1011
func TestGetPodEmptyID(t *testing.T) {
1012
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1013
		_, err := state.Pod("")
1014
		assert.Error(t, err)
1015
	})
1016
}
1017

1018
func TestGetPodOnePod(t *testing.T) {
1019
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1020
		testPod, err := getTestPod1(manager)
1021
		assert.NoError(t, err)
1022

1023
		err = state.AddPod(testPod)
1024
		assert.NoError(t, err)
1025

1026
		statePod, err := state.Pod(testPod.ID())
1027
		assert.NoError(t, err)
1028

1029
		testPodsEqual(t, statePod, testPod, true)
1030
	})
1031
}
1032

1033
func TestGetOnePodFromTwo(t *testing.T) {
1034
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1035
		testPod1, err := getTestPod1(manager)
1036
		assert.NoError(t, err)
1037

1038
		testPod2, err := getTestPod2(manager)
1039
		assert.NoError(t, err)
1040

1041
		err = state.AddPod(testPod1)
1042
		assert.NoError(t, err)
1043

1044
		err = state.AddPod(testPod2)
1045
		assert.NoError(t, err)
1046

1047
		statePod, err := state.Pod(testPod1.ID())
1048
		assert.NoError(t, err)
1049

1050
		testPodsEqual(t, statePod, testPod1, true)
1051
	})
1052
}
1053

1054
func TestGetNotExistPodWithPods(t *testing.T) {
1055
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1056
		testPod1, err := getTestPod1(manager)
1057
		assert.NoError(t, err)
1058

1059
		testPod2, err := getTestPod2(manager)
1060
		assert.NoError(t, err)
1061

1062
		err = state.AddPod(testPod1)
1063
		assert.NoError(t, err)
1064

1065
		err = state.AddPod(testPod2)
1066
		assert.NoError(t, err)
1067

1068
		_, err = state.Pod("nonexistent")
1069
		assert.Error(t, err)
1070
	})
1071
}
1072

1073
func TestGetPodByCtrID(t *testing.T) {
1074
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1075
		testCtr, err := getTestCtr1(manager)
1076
		assert.NoError(t, err)
1077

1078
		err = state.AddContainer(testCtr)
1079
		assert.NoError(t, err)
1080

1081
		_, err = state.Pod(testCtr.ID())
1082
		assert.Error(t, err)
1083
	})
1084
}
1085

1086
func TestLookupPodEmptyID(t *testing.T) {
1087
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1088
		_, err := state.LookupPod("")
1089
		assert.Error(t, err)
1090
	})
1091
}
1092

1093
func TestLookupNotExistPod(t *testing.T) {
1094
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1095
		_, err := state.LookupPod("doesnotexist")
1096
		assert.Error(t, err)
1097
	})
1098
}
1099

1100
func TestLookupPodFullID(t *testing.T) {
1101
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1102
		testPod, err := getTestPod1(manager)
1103
		assert.NoError(t, err)
1104

1105
		err = state.AddPod(testPod)
1106
		assert.NoError(t, err)
1107

1108
		statePod, err := state.LookupPod(testPod.ID())
1109
		assert.NoError(t, err)
1110

1111
		testPodsEqual(t, statePod, testPod, true)
1112
	})
1113
}
1114

1115
func TestLookupPodUniquePartialID(t *testing.T) {
1116
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1117
		testPod, err := getTestPod1(manager)
1118
		assert.NoError(t, err)
1119

1120
		err = state.AddPod(testPod)
1121
		assert.NoError(t, err)
1122

1123
		statePod, err := state.LookupPod(testPod.ID()[0:8])
1124
		assert.NoError(t, err)
1125

1126
		testPodsEqual(t, statePod, testPod, true)
1127
	})
1128
}
1129

1130
func TestLookupPodNonUniquePartialID(t *testing.T) {
1131
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1132
		testPod1, err := getTestPod(strings.Repeat("1", 32), "test1", manager)
1133
		assert.NoError(t, err)
1134

1135
		testPod2, err := getTestPod(strings.Repeat("1", 31)+"2", "test2", manager)
1136
		assert.NoError(t, err)
1137

1138
		err = state.AddPod(testPod1)
1139
		assert.NoError(t, err)
1140

1141
		err = state.AddPod(testPod2)
1142
		assert.NoError(t, err)
1143

1144
		_, err = state.LookupPod(testPod1.ID()[0:8])
1145
		assert.Error(t, err)
1146
	})
1147
}
1148

1149
func TestLookupPodByName(t *testing.T) {
1150
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1151
		testPod, err := getTestPod1(manager)
1152
		assert.NoError(t, err)
1153

1154
		err = state.AddPod(testPod)
1155
		assert.NoError(t, err)
1156

1157
		statePod, err := state.LookupPod(testPod.Name())
1158
		assert.NoError(t, err)
1159

1160
		testPodsEqual(t, statePod, statePod, true)
1161
	})
1162
}
1163

1164
func TestLookupPodByCtrID(t *testing.T) {
1165
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1166
		testCtr, err := getTestCtr1(manager)
1167
		assert.NoError(t, err)
1168

1169
		err = state.AddContainer(testCtr)
1170
		assert.NoError(t, err)
1171

1172
		_, err = state.LookupPod(testCtr.ID())
1173
		assert.Error(t, err)
1174
	})
1175
}
1176

1177
func TestLookupPodByCtrName(t *testing.T) {
1178
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1179
		testCtr, err := getTestCtr1(manager)
1180
		assert.NoError(t, err)
1181

1182
		err = state.AddContainer(testCtr)
1183
		assert.NoError(t, err)
1184

1185
		_, err = state.LookupPod(testCtr.Name())
1186
		assert.Error(t, err)
1187
	})
1188
}
1189

1190
func TestHasPodEmptyIDErrors(t *testing.T) {
1191
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1192
		_, err := state.HasPod("")
1193
		assert.Error(t, err)
1194
	})
1195
}
1196

1197
func TestHasPodNoSuchPod(t *testing.T) {
1198
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1199
		exist, err := state.HasPod("nonexistent")
1200
		assert.NoError(t, err)
1201
		assert.False(t, exist)
1202
	})
1203
}
1204

1205
func TestHasPodWrongIDFalse(t *testing.T) {
1206
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1207
		testPod, err := getTestPod1(manager)
1208
		assert.NoError(t, err)
1209

1210
		err = state.AddPod(testPod)
1211
		assert.NoError(t, err)
1212

1213
		exist, err := state.HasPod(strings.Repeat("a", 32))
1214
		assert.NoError(t, err)
1215
		assert.False(t, exist)
1216
	})
1217
}
1218

1219
func TestHasPodRightIDTrue(t *testing.T) {
1220
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1221
		testPod, err := getTestPod1(manager)
1222
		assert.NoError(t, err)
1223

1224
		err = state.AddPod(testPod)
1225
		assert.NoError(t, err)
1226

1227
		exist, err := state.HasPod(testPod.ID())
1228
		assert.NoError(t, err)
1229
		assert.True(t, exist)
1230
	})
1231
}
1232

1233
func TestHasPodCtrIDFalse(t *testing.T) {
1234
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1235
		testCtr, err := getTestCtr1(manager)
1236
		assert.NoError(t, err)
1237

1238
		err = state.AddContainer(testCtr)
1239
		assert.NoError(t, err)
1240

1241
		exist, err := state.HasPod(testCtr.ID())
1242
		assert.NoError(t, err)
1243
		assert.False(t, exist)
1244
	})
1245
}
1246

1247
func TestAddPodInvalidPodErrors(t *testing.T) {
1248
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1249
		err := state.AddPod(&Pod{config: &PodConfig{}})
1250
		assert.Error(t, err)
1251
	})
1252
}
1253

1254
func TestAddPodValidPodSucceeds(t *testing.T) {
1255
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1256
		testPod, err := getTestPod1(manager)
1257
		assert.NoError(t, err)
1258

1259
		err = state.AddPod(testPod)
1260
		assert.NoError(t, err)
1261

1262
		allPods, err := state.AllPods()
1263
		assert.NoError(t, err)
1264
		assert.Equal(t, 1, len(allPods))
1265

1266
		testPodsEqual(t, allPods[0], testPod, true)
1267
	})
1268
}
1269

1270
func TestAddPodDuplicateIDFails(t *testing.T) {
1271
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1272
		testPod1, err := getTestPod1(manager)
1273
		assert.NoError(t, err)
1274

1275
		testPod2, err := getTestPod(testPod1.ID(), "testpod2", manager)
1276
		assert.NoError(t, err)
1277

1278
		err = state.AddPod(testPod1)
1279
		assert.NoError(t, err)
1280

1281
		err = state.AddPod(testPod2)
1282
		assert.Error(t, err)
1283

1284
		allPods, err := state.AllPods()
1285
		assert.NoError(t, err)
1286
		assert.Equal(t, 1, len(allPods))
1287
	})
1288
}
1289

1290
func TestAddPodDuplicateNameFails(t *testing.T) {
1291
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1292
		testPod1, err := getTestPod1(manager)
1293
		assert.NoError(t, err)
1294

1295
		testPod2, err := getTestPod(strings.Repeat("2", 32), testPod1.Name(), manager)
1296
		assert.NoError(t, err)
1297

1298
		err = state.AddPod(testPod1)
1299
		assert.NoError(t, err)
1300

1301
		err = state.AddPod(testPod2)
1302
		assert.Error(t, err)
1303

1304
		allPods, err := state.AllPods()
1305
		assert.NoError(t, err)
1306
		assert.Equal(t, 1, len(allPods))
1307
	})
1308
}
1309

1310
func TestAddPodNonDuplicateSucceeds(t *testing.T) {
1311
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1312
		testPod1, err := getTestPod1(manager)
1313
		assert.NoError(t, err)
1314

1315
		testPod2, err := getTestPod2(manager)
1316
		assert.NoError(t, err)
1317

1318
		err = state.AddPod(testPod1)
1319
		assert.NoError(t, err)
1320

1321
		err = state.AddPod(testPod2)
1322
		assert.NoError(t, err)
1323

1324
		allPods, err := state.AllPods()
1325
		assert.NoError(t, err)
1326
		assert.Equal(t, 2, len(allPods))
1327
	})
1328
}
1329

1330
func TestAddPodCtrIDConflictFails(t *testing.T) {
1331
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1332
		testCtr, err := getTestCtr1(manager)
1333
		assert.NoError(t, err)
1334

1335
		testPod, err := getTestPod(testCtr.ID(), "testpod1", manager)
1336
		assert.NoError(t, err)
1337

1338
		err = state.AddContainer(testCtr)
1339
		assert.NoError(t, err)
1340

1341
		err = state.AddPod(testPod)
1342
		assert.Error(t, err)
1343

1344
		allPods, err := state.AllPods()
1345
		assert.NoError(t, err)
1346
		assert.Equal(t, 0, len(allPods))
1347
	})
1348
}
1349

1350
func TestAddPodCtrNameConflictFails(t *testing.T) {
1351
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1352
		testCtr, err := getTestCtr1(manager)
1353
		assert.NoError(t, err)
1354

1355
		testPod, err := getTestPod(strings.Repeat("3", 32), testCtr.Name(), manager)
1356
		assert.NoError(t, err)
1357

1358
		err = state.AddContainer(testCtr)
1359
		assert.NoError(t, err)
1360

1361
		err = state.AddPod(testPod)
1362
		assert.Error(t, err)
1363

1364
		allPods, err := state.AllPods()
1365
		assert.NoError(t, err)
1366
		assert.Equal(t, 0, len(allPods))
1367
	})
1368
}
1369

1370
func TestRemovePodInvalidPodErrors(t *testing.T) {
1371
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1372
		err := state.RemovePod(&Pod{config: &PodConfig{}})
1373
		assert.Error(t, err)
1374
	})
1375
}
1376

1377
func TestRemovePodNotInStateFails(t *testing.T) {
1378
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1379
		testPod, err := getTestPod1(manager)
1380
		assert.NoError(t, err)
1381

1382
		err = state.RemovePod(testPod)
1383
		assert.Error(t, err)
1384
		assert.False(t, testPod.valid)
1385
	})
1386
}
1387

1388
func TestRemovePodSucceeds(t *testing.T) {
1389
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1390
		testPod, err := getTestPod1(manager)
1391
		assert.NoError(t, err)
1392

1393
		err = state.AddPod(testPod)
1394
		assert.NoError(t, err)
1395

1396
		err = state.RemovePod(testPod)
1397
		assert.NoError(t, err)
1398

1399
		allPods, err := state.AllPods()
1400
		assert.NoError(t, err)
1401
		assert.Equal(t, 0, len(allPods))
1402
	})
1403
}
1404

1405
func TestRemovePodFromPods(t *testing.T) {
1406
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1407
		testPod1, err := getTestPod1(manager)
1408
		assert.NoError(t, err)
1409

1410
		testPod2, err := getTestPod2(manager)
1411
		assert.NoError(t, err)
1412

1413
		err = state.AddPod(testPod1)
1414
		assert.NoError(t, err)
1415

1416
		err = state.AddPod(testPod2)
1417
		assert.NoError(t, err)
1418

1419
		err = state.RemovePod(testPod1)
1420
		assert.NoError(t, err)
1421

1422
		allPods, err := state.AllPods()
1423
		assert.NoError(t, err)
1424
		assert.Equal(t, 1, len(allPods))
1425

1426
		testPodsEqual(t, allPods[0], testPod2, true)
1427
	})
1428
}
1429

1430
func TestRemovePodNotEmptyFails(t *testing.T) {
1431
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1432
		testPod, err := getTestPod1(manager)
1433
		assert.NoError(t, err)
1434

1435
		testCtr, err := getTestCtr2(manager)
1436
		assert.NoError(t, err)
1437
		testCtr.config.Pod = testPod.ID()
1438

1439
		err = state.AddPod(testPod)
1440
		assert.NoError(t, err)
1441

1442
		err = state.AddContainerToPod(testPod, testCtr)
1443
		assert.NoError(t, err)
1444

1445
		err = state.RemovePod(testPod)
1446
		assert.Error(t, err)
1447

1448
		allPods, err := state.AllPods()
1449
		assert.NoError(t, err)
1450
		assert.Equal(t, 1, len(allPods))
1451
	})
1452
}
1453

1454
func TestRemovePodAfterEmptySucceeds(t *testing.T) {
1455
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1456
		testPod, err := getTestPod1(manager)
1457
		assert.NoError(t, err)
1458

1459
		testCtr, err := getTestCtr2(manager)
1460
		assert.NoError(t, err)
1461
		testCtr.config.Pod = testPod.ID()
1462

1463
		err = state.AddPod(testPod)
1464
		assert.NoError(t, err)
1465

1466
		err = state.AddContainerToPod(testPod, testCtr)
1467
		assert.NoError(t, err)
1468

1469
		err = state.RemoveContainerFromPod(testPod, testCtr)
1470
		assert.NoError(t, err)
1471

1472
		err = state.RemovePod(testPod)
1473
		assert.NoError(t, err)
1474

1475
		allPods, err := state.AllPods()
1476
		assert.NoError(t, err)
1477
		assert.Equal(t, 0, len(allPods))
1478
	})
1479
}
1480

1481
func TestAllPodsEmptyOnEmptyState(t *testing.T) {
1482
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1483
		allPods, err := state.AllPods()
1484
		assert.NoError(t, err)
1485
		assert.Equal(t, 0, len(allPods))
1486
	})
1487
}
1488

1489
func TestAllPodsFindsPod(t *testing.T) {
1490
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1491
		testPod, err := getTestPod1(manager)
1492
		assert.NoError(t, err)
1493

1494
		err = state.AddPod(testPod)
1495
		assert.NoError(t, err)
1496

1497
		allPods, err := state.AllPods()
1498
		assert.NoError(t, err)
1499
		assert.Equal(t, 1, len(allPods))
1500

1501
		testPodsEqual(t, allPods[0], testPod, true)
1502
	})
1503
}
1504

1505
func TestAllPodsMultiplePods(t *testing.T) {
1506
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1507
		testPod1, err := getTestPod1(manager)
1508
		assert.NoError(t, err)
1509

1510
		testPod2, err := getTestPod2(manager)
1511
		assert.NoError(t, err)
1512

1513
		testPod3, err := getTestPodN("3", manager)
1514
		assert.NoError(t, err)
1515

1516
		allPods1, err := state.AllPods()
1517
		assert.NoError(t, err)
1518
		assert.Equal(t, 0, len(allPods1))
1519

1520
		err = state.AddPod(testPod1)
1521
		assert.NoError(t, err)
1522

1523
		allPods2, err := state.AllPods()
1524
		assert.NoError(t, err)
1525
		assert.Equal(t, 1, len(allPods2))
1526

1527
		err = state.AddPod(testPod2)
1528
		assert.NoError(t, err)
1529

1530
		allPods3, err := state.AllPods()
1531
		assert.NoError(t, err)
1532
		assert.Equal(t, 2, len(allPods3))
1533

1534
		err = state.AddPod(testPod3)
1535
		assert.NoError(t, err)
1536

1537
		allPods4, err := state.AllPods()
1538
		assert.NoError(t, err)
1539
		assert.Equal(t, 3, len(allPods4))
1540
	})
1541
}
1542

1543
func TestPodHasContainerNoSuchPod(t *testing.T) {
1544
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1545
		_, err := state.PodHasContainer(&Pod{config: &PodConfig{}}, strings.Repeat("0", 32))
1546
		assert.Error(t, err)
1547
	})
1548
}
1549

1550
func TestPodHasContainerEmptyCtrID(t *testing.T) {
1551
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1552
		testPod, err := getTestPod1(manager)
1553
		assert.NoError(t, err)
1554

1555
		err = state.AddPod(testPod)
1556
		assert.NoError(t, err)
1557

1558
		_, err = state.PodHasContainer(testPod, "")
1559
		assert.Error(t, err)
1560
	})
1561
}
1562

1563
func TestPodHasContainerNoSuchCtr(t *testing.T) {
1564
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1565
		testPod, err := getTestPod1(manager)
1566
		assert.NoError(t, err)
1567

1568
		err = state.AddPod(testPod)
1569
		assert.NoError(t, err)
1570

1571
		exist, err := state.PodHasContainer(testPod, strings.Repeat("2", 32))
1572
		assert.NoError(t, err)
1573
		assert.False(t, exist)
1574
	})
1575
}
1576

1577
func TestPodHasContainerCtrNotInPod(t *testing.T) {
1578
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1579
		testPod, err := getTestPod1(manager)
1580
		assert.NoError(t, err)
1581

1582
		testCtr, err := getTestCtr2(manager)
1583
		assert.NoError(t, err)
1584

1585
		err = state.AddPod(testPod)
1586
		assert.NoError(t, err)
1587

1588
		err = state.AddContainer(testCtr)
1589
		assert.NoError(t, err)
1590

1591
		exist, err := state.PodHasContainer(testPod, testCtr.ID())
1592
		assert.NoError(t, err)
1593
		assert.False(t, exist)
1594
	})
1595
}
1596

1597
func TestPodHasContainerSucceeds(t *testing.T) {
1598
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1599
		testPod, err := getTestPod1(manager)
1600
		assert.NoError(t, err)
1601

1602
		testCtr, err := getTestCtr2(manager)
1603
		assert.NoError(t, err)
1604

1605
		testCtr.config.Pod = testPod.ID()
1606

1607
		err = state.AddPod(testPod)
1608
		assert.NoError(t, err)
1609

1610
		err = state.AddContainerToPod(testPod, testCtr)
1611
		assert.NoError(t, err)
1612

1613
		exist, err := state.PodHasContainer(testPod, testCtr.ID())
1614
		assert.NoError(t, err)
1615
		assert.True(t, exist)
1616
	})
1617
}
1618

1619
func TestPodContainersByIDInvalidPod(t *testing.T) {
1620
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1621
		_, err := state.PodContainersByID(&Pod{config: &PodConfig{}})
1622
		assert.Error(t, err)
1623
	})
1624
}
1625

1626
func TestPodContainerdByIDPodNotInState(t *testing.T) {
1627
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1628
		testPod, err := getTestPod1(manager)
1629
		assert.NoError(t, err)
1630

1631
		_, err = state.PodContainersByID(testPod)
1632
		assert.Error(t, err)
1633
		assert.False(t, testPod.valid)
1634
	})
1635
}
1636

1637
func TestPodContainersByIDEmptyPod(t *testing.T) {
1638
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1639
		testPod, err := getTestPod1(manager)
1640
		assert.NoError(t, err)
1641

1642
		err = state.AddPod(testPod)
1643
		assert.NoError(t, err)
1644

1645
		ctrs, err := state.PodContainersByID(testPod)
1646
		assert.NoError(t, err)
1647
		assert.Equal(t, 0, len(ctrs))
1648
	})
1649
}
1650

1651
func TestPodContainersByIDOneContainer(t *testing.T) {
1652
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1653
		testPod, err := getTestPod1(manager)
1654
		assert.NoError(t, err)
1655

1656
		testCtr, err := getTestCtr2(manager)
1657
		assert.NoError(t, err)
1658

1659
		testCtr.config.Pod = testPod.ID()
1660

1661
		err = state.AddPod(testPod)
1662
		assert.NoError(t, err)
1663

1664
		err = state.AddContainerToPod(testPod, testCtr)
1665
		assert.NoError(t, err)
1666

1667
		ctrs, err := state.PodContainersByID(testPod)
1668
		assert.NoError(t, err)
1669
		assert.Equal(t, 1, len(ctrs))
1670
		assert.Equal(t, testCtr.ID(), ctrs[0])
1671
	})
1672
}
1673

1674
func TestPodContainersByIDMultipleContainers(t *testing.T) {
1675
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1676
		testPod, err := getTestPod1(manager)
1677
		assert.NoError(t, err)
1678

1679
		testCtr1, err := getTestCtr2(manager)
1680
		assert.NoError(t, err)
1681
		testCtr1.config.Pod = testPod.ID()
1682

1683
		testCtr2, err := getTestCtrN("3", manager)
1684
		assert.NoError(t, err)
1685
		testCtr2.config.Pod = testPod.ID()
1686

1687
		testCtr3, err := getTestCtrN("4", manager)
1688
		assert.NoError(t, err)
1689
		testCtr3.config.Pod = testPod.ID()
1690

1691
		err = state.AddPod(testPod)
1692
		assert.NoError(t, err)
1693

1694
		ctrs0, err := state.PodContainersByID(testPod)
1695
		assert.NoError(t, err)
1696
		assert.Equal(t, 0, len(ctrs0))
1697

1698
		err = state.AddContainerToPod(testPod, testCtr1)
1699
		assert.NoError(t, err)
1700

1701
		ctrs1, err := state.PodContainersByID(testPod)
1702
		assert.NoError(t, err)
1703
		assert.Equal(t, 1, len(ctrs1))
1704

1705
		err = state.AddContainerToPod(testPod, testCtr2)
1706
		assert.NoError(t, err)
1707

1708
		ctrs2, err := state.PodContainersByID(testPod)
1709
		assert.NoError(t, err)
1710
		assert.Equal(t, 2, len(ctrs2))
1711

1712
		err = state.AddContainerToPod(testPod, testCtr3)
1713
		assert.NoError(t, err)
1714

1715
		ctrs3, err := state.PodContainersByID(testPod)
1716
		assert.NoError(t, err)
1717
		assert.Equal(t, 3, len(ctrs3))
1718
	})
1719
}
1720

1721
func TestPodContainersInvalidPod(t *testing.T) {
1722
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1723
		_, err := state.PodContainers(&Pod{config: &PodConfig{}})
1724
		assert.Error(t, err)
1725
	})
1726
}
1727

1728
func TestPodContainersPodNotInState(t *testing.T) {
1729
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1730
		testPod, err := getTestPod1(manager)
1731
		assert.NoError(t, err)
1732

1733
		_, err = state.PodContainers(testPod)
1734
		assert.Error(t, err)
1735
		assert.False(t, testPod.valid)
1736
	})
1737
}
1738

1739
func TestPodContainersEmptyPod(t *testing.T) {
1740
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1741
		testPod, err := getTestPod1(manager)
1742
		assert.NoError(t, err)
1743

1744
		err = state.AddPod(testPod)
1745
		assert.NoError(t, err)
1746

1747
		ctrs, err := state.PodContainers(testPod)
1748
		assert.NoError(t, err)
1749
		assert.Equal(t, 0, len(ctrs))
1750
	})
1751
}
1752

1753
func TestPodContainersOneContainer(t *testing.T) {
1754
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1755
		testPod, err := getTestPod1(manager)
1756
		assert.NoError(t, err)
1757

1758
		testCtr, err := getTestCtr2(manager)
1759
		assert.NoError(t, err)
1760

1761
		testCtr.config.Pod = testPod.ID()
1762

1763
		err = state.AddPod(testPod)
1764
		assert.NoError(t, err)
1765

1766
		err = state.AddContainerToPod(testPod, testCtr)
1767
		assert.NoError(t, err)
1768

1769
		ctrs, err := state.PodContainers(testPod)
1770
		assert.NoError(t, err)
1771
		require.Len(t, ctrs, 1)
1772

1773
		testContainersEqual(t, ctrs[0], testCtr, true)
1774
	})
1775
}
1776

1777
func TestPodContainersMultipleContainers(t *testing.T) {
1778
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1779
		testPod, err := getTestPod1(manager)
1780
		assert.NoError(t, err)
1781

1782
		testCtr1, err := getTestCtr2(manager)
1783
		assert.NoError(t, err)
1784
		testCtr1.config.Pod = testPod.ID()
1785

1786
		testCtr2, err := getTestCtrN("3", manager)
1787
		assert.NoError(t, err)
1788
		testCtr2.config.Pod = testPod.ID()
1789

1790
		testCtr3, err := getTestCtrN("4", manager)
1791
		assert.NoError(t, err)
1792
		testCtr3.config.Pod = testPod.ID()
1793

1794
		err = state.AddPod(testPod)
1795
		assert.NoError(t, err)
1796

1797
		ctrs0, err := state.PodContainers(testPod)
1798
		assert.NoError(t, err)
1799
		assert.Equal(t, 0, len(ctrs0))
1800

1801
		err = state.AddContainerToPod(testPod, testCtr1)
1802
		assert.NoError(t, err)
1803

1804
		ctrs1, err := state.PodContainers(testPod)
1805
		assert.NoError(t, err)
1806
		assert.Equal(t, 1, len(ctrs1))
1807

1808
		err = state.AddContainerToPod(testPod, testCtr2)
1809
		assert.NoError(t, err)
1810

1811
		ctrs2, err := state.PodContainers(testPod)
1812
		assert.NoError(t, err)
1813
		assert.Equal(t, 2, len(ctrs2))
1814

1815
		err = state.AddContainerToPod(testPod, testCtr3)
1816
		assert.NoError(t, err)
1817

1818
		ctrs3, err := state.PodContainers(testPod)
1819
		assert.NoError(t, err)
1820
		assert.Equal(t, 3, len(ctrs3))
1821
	})
1822
}
1823

1824
func TestRemovePodContainersInvalidPod(t *testing.T) {
1825
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1826
		err := state.RemovePodContainers(&Pod{config: &PodConfig{}})
1827
		assert.Error(t, err)
1828
	})
1829
}
1830

1831
func TestRemovePodContainersPodNotInState(t *testing.T) {
1832
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1833
		testPod, err := getTestPod1(manager)
1834
		assert.NoError(t, err)
1835

1836
		err = state.RemovePodContainers(testPod)
1837
		assert.Error(t, err)
1838
		assert.False(t, testPod.valid)
1839
	})
1840
}
1841

1842
func TestRemovePodContainersNoContainers(t *testing.T) {
1843
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1844
		testPod, err := getTestPod1(manager)
1845
		assert.NoError(t, err)
1846

1847
		err = state.AddPod(testPod)
1848
		assert.NoError(t, err)
1849

1850
		err = state.RemovePodContainers(testPod)
1851
		assert.NoError(t, err)
1852

1853
		ctrs, err := state.PodContainersByID(testPod)
1854
		assert.NoError(t, err)
1855
		assert.Equal(t, 0, len(ctrs))
1856
	})
1857
}
1858

1859
func TestRemovePodContainersOneContainer(t *testing.T) {
1860
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1861
		testPod, err := getTestPod1(manager)
1862
		assert.NoError(t, err)
1863

1864
		testCtr, err := getTestCtr2(manager)
1865
		assert.NoError(t, err)
1866
		testCtr.config.Pod = testPod.ID()
1867

1868
		err = state.AddPod(testPod)
1869
		assert.NoError(t, err)
1870

1871
		err = state.AddContainerToPod(testPod, testCtr)
1872
		assert.NoError(t, err)
1873

1874
		err = state.RemovePodContainers(testPod)
1875
		assert.NoError(t, err)
1876

1877
		ctrs, err := state.PodContainersByID(testPod)
1878
		assert.NoError(t, err)
1879
		assert.Equal(t, 0, len(ctrs))
1880
	})
1881
}
1882

1883
func TestRemovePodContainersPreservesCtrOutsidePod(t *testing.T) {
1884
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1885
		testPod, err := getTestPod1(manager)
1886
		assert.NoError(t, err)
1887

1888
		testCtr1, err := getTestCtr2(manager)
1889
		assert.NoError(t, err)
1890
		testCtr1.config.Pod = testPod.ID()
1891

1892
		testCtr2, err := getTestCtrN("3", manager)
1893
		assert.NoError(t, err)
1894

1895
		err = state.AddPod(testPod)
1896
		assert.NoError(t, err)
1897

1898
		err = state.AddContainerToPod(testPod, testCtr1)
1899
		assert.NoError(t, err)
1900

1901
		err = state.AddContainer(testCtr2)
1902
		assert.NoError(t, err)
1903

1904
		err = state.RemovePodContainers(testPod)
1905
		assert.NoError(t, err)
1906

1907
		ctrs, err := state.PodContainersByID(testPod)
1908
		assert.NoError(t, err)
1909
		assert.Equal(t, 0, len(ctrs))
1910

1911
		allCtrs, err := state.AllContainers(false)
1912
		assert.NoError(t, err)
1913
		assert.Equal(t, 1, len(allCtrs))
1914
	})
1915
}
1916

1917
func TestRemovePodContainersTwoContainers(t *testing.T) {
1918
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1919
		testPod, err := getTestPod1(manager)
1920
		assert.NoError(t, err)
1921

1922
		testCtr1, err := getTestCtr2(manager)
1923
		assert.NoError(t, err)
1924
		testCtr1.config.Pod = testPod.ID()
1925

1926
		testCtr2, err := getTestCtrN("3", manager)
1927
		assert.NoError(t, err)
1928
		testCtr2.config.Pod = testPod.ID()
1929

1930
		err = state.AddPod(testPod)
1931
		assert.NoError(t, err)
1932

1933
		err = state.AddContainerToPod(testPod, testCtr1)
1934
		assert.NoError(t, err)
1935

1936
		err = state.AddContainerToPod(testPod, testCtr2)
1937
		assert.NoError(t, err)
1938

1939
		err = state.RemovePodContainers(testPod)
1940
		assert.NoError(t, err)
1941

1942
		ctrs, err := state.PodContainersByID(testPod)
1943
		assert.NoError(t, err)
1944
		assert.Equal(t, 0, len(ctrs))
1945
	})
1946
}
1947

1948
func TestRemovePodContainerDependencyInPod(t *testing.T) {
1949
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1950
		testPod, err := getTestPod1(manager)
1951
		assert.NoError(t, err)
1952

1953
		testCtr1, err := getTestCtr2(manager)
1954
		assert.NoError(t, err)
1955
		testCtr1.config.Pod = testPod.ID()
1956

1957
		testCtr2, err := getTestCtrN("3", manager)
1958
		assert.NoError(t, err)
1959
		testCtr2.config.Pod = testPod.ID()
1960
		testCtr2.config.IPCNsCtr = testCtr1.ID()
1961

1962
		err = state.AddPod(testPod)
1963
		assert.NoError(t, err)
1964

1965
		err = state.AddContainerToPod(testPod, testCtr1)
1966
		assert.NoError(t, err)
1967

1968
		err = state.AddContainerToPod(testPod, testCtr2)
1969
		assert.NoError(t, err)
1970

1971
		err = state.RemovePodContainers(testPod)
1972
		assert.NoError(t, err)
1973

1974
		ctrs, err := state.PodContainersByID(testPod)
1975
		assert.NoError(t, err)
1976
		assert.Equal(t, 0, len(ctrs))
1977
	})
1978
}
1979

1980
func TestAddContainerToPodInvalidPod(t *testing.T) {
1981
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1982
		testCtr, err := getTestCtr1(manager)
1983
		assert.NoError(t, err)
1984

1985
		err = state.AddContainerToPod(&Pod{config: &PodConfig{}}, testCtr)
1986
		assert.Error(t, err)
1987
	})
1988
}
1989

1990
func TestAddContainerToPodInvalidCtr(t *testing.T) {
1991
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
1992
		testPod, err := getTestPod1(manager)
1993
		assert.NoError(t, err)
1994

1995
		err = state.AddPod(testPod)
1996
		assert.NoError(t, err)
1997

1998
		err = state.AddContainerToPod(testPod, &Container{config: &ContainerConfig{ID: "1234"}})
1999
		assert.Error(t, err)
2000

2001
		ctrs, err := state.PodContainersByID(testPod)
2002
		assert.NoError(t, err)
2003
		assert.Equal(t, 0, len(ctrs))
2004
	})
2005
}
2006

2007
func TestAddContainerToPodPodNotInState(t *testing.T) {
2008
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2009
		testPod, err := getTestPod1(manager)
2010
		assert.NoError(t, err)
2011

2012
		testCtr, err := getTestCtr2(manager)
2013
		assert.NoError(t, err)
2014
		testCtr.config.Pod = testPod.ID()
2015

2016
		err = state.AddContainerToPod(testPod, testCtr)
2017
		assert.Error(t, err)
2018
		assert.False(t, testPod.valid)
2019
	})
2020
}
2021

2022
func TestAddContainerToPodSucceeds(t *testing.T) {
2023
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2024
		testPod, err := getTestPod1(manager)
2025
		assert.NoError(t, err)
2026

2027
		testCtr, err := getTestCtr2(manager)
2028
		assert.NoError(t, err)
2029
		testCtr.config.Pod = testPod.ID()
2030

2031
		err = state.AddPod(testPod)
2032
		assert.NoError(t, err)
2033

2034
		err = state.AddContainerToPod(testPod, testCtr)
2035
		assert.NoError(t, err)
2036

2037
		ctrs, err := state.PodContainers(testPod)
2038
		assert.NoError(t, err)
2039
		require.Len(t, ctrs, 1)
2040

2041
		allCtrs, err := state.AllContainers(false)
2042
		assert.NoError(t, err)
2043
		require.Len(t, allCtrs, 1)
2044

2045
		testContainersEqual(t, ctrs[0], testCtr, true)
2046
		testContainersEqual(t, ctrs[0], allCtrs[0], false)
2047
	})
2048
}
2049

2050
func TestAddContainerToPodTwoContainers(t *testing.T) {
2051
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2052
		testPod, err := getTestPod1(manager)
2053
		assert.NoError(t, err)
2054

2055
		testCtr1, err := getTestCtr2(manager)
2056
		assert.NoError(t, err)
2057
		testCtr1.config.Pod = testPod.ID()
2058

2059
		testCtr2, err := getTestCtrN("3", manager)
2060
		assert.NoError(t, err)
2061
		testCtr2.config.Pod = testPod.ID()
2062

2063
		err = state.AddPod(testPod)
2064
		assert.NoError(t, err)
2065

2066
		err = state.AddContainerToPod(testPod, testCtr1)
2067
		assert.NoError(t, err)
2068

2069
		err = state.AddContainerToPod(testPod, testCtr2)
2070
		assert.NoError(t, err)
2071

2072
		ctrs, err := state.PodContainers(testPod)
2073
		assert.NoError(t, err)
2074
		assert.Equal(t, 2, len(ctrs))
2075

2076
		allCtrs, err := state.AllContainers(false)
2077
		assert.NoError(t, err)
2078
		assert.Equal(t, 2, len(allCtrs))
2079
	})
2080
}
2081

2082
func TestAddContainerToPodWithAddContainer(t *testing.T) {
2083
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2084
		testPod, err := getTestPod1(manager)
2085
		assert.NoError(t, err)
2086

2087
		testCtr1, err := getTestCtr2(manager)
2088
		assert.NoError(t, err)
2089
		testCtr1.config.Pod = testPod.ID()
2090

2091
		testCtr2, err := getTestCtrN("3", manager)
2092
		assert.NoError(t, err)
2093

2094
		err = state.AddPod(testPod)
2095
		assert.NoError(t, err)
2096

2097
		err = state.AddContainerToPod(testPod, testCtr1)
2098
		assert.NoError(t, err)
2099

2100
		err = state.AddContainer(testCtr2)
2101
		assert.NoError(t, err)
2102

2103
		ctrs, err := state.PodContainers(testPod)
2104
		assert.NoError(t, err)
2105
		require.Len(t, ctrs, 1)
2106

2107
		allCtrs, err := state.AllContainers(false)
2108
		assert.NoError(t, err)
2109
		assert.Equal(t, 2, len(allCtrs))
2110

2111
		testContainersEqual(t, ctrs[0], testCtr1, true)
2112
	})
2113
}
2114

2115
func TestAddContainerToPodCtrIDConflict(t *testing.T) {
2116
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2117
		testPod, err := getTestPod1(manager)
2118
		assert.NoError(t, err)
2119

2120
		testCtr1, err := getTestCtr2(manager)
2121
		assert.NoError(t, err)
2122

2123
		testCtr2, err := getTestContainer(testCtr1.ID(), "testCtr3", manager)
2124
		assert.NoError(t, err)
2125
		testCtr2.config.Pod = testPod.ID()
2126

2127
		err = state.AddPod(testPod)
2128
		assert.NoError(t, err)
2129

2130
		err = state.AddContainer(testCtr1)
2131
		assert.NoError(t, err)
2132

2133
		err = state.AddContainerToPod(testPod, testCtr2)
2134
		assert.Error(t, err)
2135

2136
		ctrs, err := state.PodContainers(testPod)
2137
		assert.NoError(t, err)
2138
		assert.Equal(t, 0, len(ctrs))
2139

2140
		allCtrs, err := state.AllContainers(false)
2141
		assert.NoError(t, err)
2142
		assert.Equal(t, 1, len(allCtrs))
2143
	})
2144
}
2145

2146
func TestAddContainerToPodCtrNameConflict(t *testing.T) {
2147
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2148
		testPod, err := getTestPod1(manager)
2149
		assert.NoError(t, err)
2150

2151
		testCtr1, err := getTestCtr2(manager)
2152
		assert.NoError(t, err)
2153

2154
		testCtr2, err := getTestContainer(strings.Repeat("4", 32), testCtr1.Name(), manager)
2155
		assert.NoError(t, err)
2156
		testCtr2.config.Pod = testPod.ID()
2157

2158
		err = state.AddPod(testPod)
2159
		assert.NoError(t, err)
2160

2161
		err = state.AddContainer(testCtr1)
2162
		assert.NoError(t, err)
2163

2164
		err = state.AddContainerToPod(testPod, testCtr2)
2165
		assert.Error(t, err)
2166

2167
		ctrs, err := state.PodContainers(testPod)
2168
		assert.NoError(t, err)
2169
		assert.Equal(t, 0, len(ctrs))
2170

2171
		allCtrs, err := state.AllContainers(false)
2172
		assert.NoError(t, err)
2173
		assert.Equal(t, 1, len(allCtrs))
2174
	})
2175
}
2176

2177
func TestAddContainerToPodPodIDConflict(t *testing.T) {
2178
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2179
		testPod, err := getTestPod1(manager)
2180
		assert.NoError(t, err)
2181

2182
		testCtr, err := getTestContainer(testPod.ID(), "testCtr", manager)
2183
		assert.NoError(t, err)
2184
		testCtr.config.Pod = testPod.ID()
2185

2186
		err = state.AddPod(testPod)
2187
		assert.NoError(t, err)
2188

2189
		err = state.AddContainerToPod(testPod, testCtr)
2190
		assert.Error(t, err)
2191

2192
		ctrs, err := state.PodContainers(testPod)
2193
		assert.NoError(t, err)
2194
		assert.Equal(t, 0, len(ctrs))
2195

2196
		allCtrs, err := state.AllContainers(false)
2197
		assert.NoError(t, err)
2198
		assert.Equal(t, 0, len(allCtrs))
2199
	})
2200
}
2201

2202
func TestAddContainerToPodPodNameConflict(t *testing.T) {
2203
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2204
		testPod, err := getTestPod1(manager)
2205
		assert.NoError(t, err)
2206

2207
		testCtr, err := getTestContainer(strings.Repeat("2", 32), testPod.Name(), manager)
2208
		assert.NoError(t, err)
2209
		testCtr.config.Pod = testPod.ID()
2210

2211
		err = state.AddPod(testPod)
2212
		assert.NoError(t, err)
2213

2214
		err = state.AddContainerToPod(testPod, testCtr)
2215
		assert.Error(t, err)
2216

2217
		ctrs, err := state.PodContainers(testPod)
2218
		assert.NoError(t, err)
2219
		assert.Equal(t, 0, len(ctrs))
2220

2221
		allCtrs, err := state.AllContainers(false)
2222
		assert.NoError(t, err)
2223
		assert.Equal(t, 0, len(allCtrs))
2224
	})
2225
}
2226

2227
func TestAddContainerToPodAddsDependencies(t *testing.T) {
2228
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2229
		testPod, err := getTestPod1(manager)
2230
		assert.NoError(t, err)
2231

2232
		testCtr1, err := getTestCtr2(manager)
2233
		assert.NoError(t, err)
2234
		testCtr1.config.Pod = testPod.ID()
2235

2236
		testCtr2, err := getTestCtrN("3", manager)
2237
		assert.NoError(t, err)
2238
		testCtr2.config.Pod = testPod.ID()
2239
		testCtr2.config.IPCNsCtr = testCtr1.ID()
2240

2241
		err = state.AddPod(testPod)
2242
		assert.NoError(t, err)
2243

2244
		err = state.AddContainerToPod(testPod, testCtr1)
2245
		assert.NoError(t, err)
2246

2247
		err = state.AddContainerToPod(testPod, testCtr2)
2248
		assert.NoError(t, err)
2249

2250
		deps, err := state.ContainerInUse(testCtr1)
2251
		assert.NoError(t, err)
2252
		assert.Equal(t, 1, len(deps))
2253
		assert.Equal(t, testCtr2.ID(), deps[0])
2254
	})
2255
}
2256

2257
func TestAddContainerToPodPodDependencyFails(t *testing.T) {
2258
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2259
		testPod, err := getTestPod1(manager)
2260
		assert.NoError(t, err)
2261

2262
		testCtr, err := getTestCtr2(manager)
2263
		assert.NoError(t, err)
2264
		testCtr.config.Pod = testPod.ID()
2265
		testCtr.config.IPCNsCtr = testPod.ID()
2266

2267
		err = state.AddPod(testPod)
2268
		assert.NoError(t, err)
2269

2270
		err = state.AddContainerToPod(testPod, testCtr)
2271
		assert.Error(t, err)
2272

2273
		ctrs, err := state.PodContainers(testPod)
2274
		assert.NoError(t, err)
2275
		assert.Equal(t, 0, len(ctrs))
2276
	})
2277
}
2278

2279
func TestAddContainerToPodBadDependencyFails(t *testing.T) {
2280
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2281
		testPod, err := getTestPod1(manager)
2282
		assert.NoError(t, err)
2283

2284
		testCtr, err := getTestCtr2(manager)
2285
		assert.NoError(t, err)
2286
		testCtr.config.Pod = testPod.ID()
2287
		testCtr.config.IPCNsCtr = strings.Repeat("8", 32)
2288

2289
		err = state.AddPod(testPod)
2290
		assert.NoError(t, err)
2291

2292
		err = state.AddContainerToPod(testPod, testCtr)
2293
		assert.Error(t, err)
2294

2295
		ctrs, err := state.PodContainers(testPod)
2296
		assert.NoError(t, err)
2297
		assert.Equal(t, 0, len(ctrs))
2298
	})
2299
}
2300

2301
func TestAddContainerToPodDependencyOutsidePodFails(t *testing.T) {
2302
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2303
		testPod, err := getTestPod1(manager)
2304
		assert.NoError(t, err)
2305

2306
		testCtr1, err := getTestCtr2(manager)
2307
		assert.NoError(t, err)
2308

2309
		testCtr2, err := getTestCtrN("3", manager)
2310
		assert.NoError(t, err)
2311
		testCtr2.config.Pod = testPod.ID()
2312
		testCtr2.config.IPCNsCtr = testCtr1.ID()
2313

2314
		err = state.AddPod(testPod)
2315
		assert.NoError(t, err)
2316

2317
		err = state.AddContainer(testCtr1)
2318
		assert.NoError(t, err)
2319

2320
		err = state.AddContainerToPod(testPod, testCtr2)
2321
		assert.Error(t, err)
2322

2323
		ctrs, err := state.PodContainers(testPod)
2324
		assert.NoError(t, err)
2325
		assert.Equal(t, 0, len(ctrs))
2326

2327
		allCtrs, err := state.AllContainers(false)
2328
		assert.NoError(t, err)
2329
		assert.Equal(t, 1, len(allCtrs))
2330

2331
		deps, err := state.ContainerInUse(testCtr1)
2332
		assert.NoError(t, err)
2333
		assert.Equal(t, 0, len(deps))
2334
	})
2335
}
2336

2337
func TestRemoveContainerFromPodBadPodFails(t *testing.T) {
2338
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2339
		testCtr, err := getTestCtr1(manager)
2340
		assert.NoError(t, err)
2341

2342
		err = state.RemoveContainerFromPod(&Pod{config: &PodConfig{}}, testCtr)
2343
		assert.Error(t, err)
2344
	})
2345
}
2346

2347
func TestRemoveContainerFromPodPodNotInStateFails(t *testing.T) {
2348
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2349
		testPod, err := getTestPod1(manager)
2350
		assert.NoError(t, err)
2351

2352
		testCtr, err := getTestCtr2(manager)
2353
		assert.NoError(t, err)
2354
		testCtr.config.Pod = testPod.ID()
2355

2356
		err = state.RemoveContainerFromPod(testPod, testCtr)
2357
		assert.Error(t, err)
2358

2359
		assert.False(t, testPod.valid)
2360
	})
2361
}
2362

2363
func TestRemoveContainerFromPodCtrNotInStateFails(t *testing.T) {
2364
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2365
		testPod, err := getTestPod1(manager)
2366
		assert.NoError(t, err)
2367

2368
		testCtr, err := getTestCtr2(manager)
2369
		assert.NoError(t, err)
2370
		testCtr.config.Pod = testPod.ID()
2371

2372
		err = state.AddPod(testPod)
2373
		assert.NoError(t, err)
2374

2375
		err = state.RemoveContainerFromPod(testPod, testCtr)
2376
		assert.Error(t, err)
2377

2378
		assert.False(t, testCtr.valid)
2379
	})
2380
}
2381

2382
func TestRemoveContainerFromPodCtrNotInPodFails(t *testing.T) {
2383
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2384
		testPod, err := getTestPod1(manager)
2385
		assert.NoError(t, err)
2386

2387
		testCtr, err := getTestCtr2(manager)
2388
		assert.NoError(t, err)
2389

2390
		err = state.AddPod(testPod)
2391
		assert.NoError(t, err)
2392

2393
		err = state.AddContainer(testCtr)
2394
		assert.NoError(t, err)
2395

2396
		err = state.RemoveContainerFromPod(testPod, testCtr)
2397
		assert.Error(t, err)
2398

2399
		assert.True(t, testCtr.valid)
2400

2401
		ctrs, err := state.AllContainers(false)
2402
		assert.NoError(t, err)
2403
		assert.Equal(t, 1, len(ctrs))
2404
	})
2405
}
2406

2407
func TestRemoveContainerFromPodSucceeds(t *testing.T) {
2408
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2409
		testPod, err := getTestPod1(manager)
2410
		assert.NoError(t, err)
2411

2412
		testCtr, err := getTestCtr2(manager)
2413
		assert.NoError(t, err)
2414
		testCtr.config.Pod = testPod.ID()
2415

2416
		err = state.AddPod(testPod)
2417
		assert.NoError(t, err)
2418

2419
		err = state.AddContainerToPod(testPod, testCtr)
2420
		assert.NoError(t, err)
2421

2422
		err = state.RemoveContainerFromPod(testPod, testCtr)
2423
		assert.NoError(t, err)
2424

2425
		ctrs, err := state.PodContainers(testPod)
2426
		assert.NoError(t, err)
2427
		assert.Equal(t, 0, len(ctrs))
2428

2429
		allCtrs, err := state.AllContainers(false)
2430
		assert.NoError(t, err)
2431
		assert.Equal(t, 0, len(allCtrs))
2432
	})
2433
}
2434

2435
func TestRemoveContainerFromPodWithDependencyFails(t *testing.T) {
2436
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2437
		testPod, err := getTestPod1(manager)
2438
		assert.NoError(t, err)
2439

2440
		testCtr1, err := getTestCtr2(manager)
2441
		assert.NoError(t, err)
2442
		testCtr1.config.Pod = testPod.ID()
2443

2444
		testCtr2, err := getTestCtrN("3", manager)
2445
		assert.NoError(t, err)
2446
		testCtr2.config.Pod = testPod.ID()
2447
		testCtr2.config.IPCNsCtr = testCtr1.ID()
2448

2449
		err = state.AddPod(testPod)
2450
		assert.NoError(t, err)
2451

2452
		err = state.AddContainerToPod(testPod, testCtr1)
2453
		assert.NoError(t, err)
2454

2455
		err = state.AddContainerToPod(testPod, testCtr2)
2456
		assert.NoError(t, err)
2457

2458
		err = state.RemoveContainerFromPod(testPod, testCtr1)
2459
		assert.Error(t, err)
2460

2461
		ctrs, err := state.PodContainers(testPod)
2462
		assert.NoError(t, err)
2463
		assert.Equal(t, 2, len(ctrs))
2464

2465
		allCtrs, err := state.AllContainers(false)
2466
		assert.NoError(t, err)
2467
		assert.Equal(t, 2, len(allCtrs))
2468
	})
2469
}
2470

2471
func TestRemoveContainerFromPodWithDependencySucceedsAfterDepRemoved(t *testing.T) {
2472
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2473
		testPod, err := getTestPod1(manager)
2474
		assert.NoError(t, err)
2475

2476
		testCtr1, err := getTestCtr2(manager)
2477
		assert.NoError(t, err)
2478
		testCtr1.config.Pod = testPod.ID()
2479

2480
		testCtr2, err := getTestCtrN("3", manager)
2481
		assert.NoError(t, err)
2482
		testCtr2.config.Pod = testPod.ID()
2483
		testCtr2.config.IPCNsCtr = testCtr1.ID()
2484

2485
		err = state.AddPod(testPod)
2486
		assert.NoError(t, err)
2487

2488
		err = state.AddContainerToPod(testPod, testCtr1)
2489
		assert.NoError(t, err)
2490

2491
		err = state.AddContainerToPod(testPod, testCtr2)
2492
		assert.NoError(t, err)
2493

2494
		err = state.RemoveContainerFromPod(testPod, testCtr2)
2495
		assert.NoError(t, err)
2496

2497
		err = state.RemoveContainerFromPod(testPod, testCtr1)
2498
		assert.NoError(t, err)
2499

2500
		ctrs, err := state.PodContainers(testPod)
2501
		assert.NoError(t, err)
2502
		assert.Equal(t, 0, len(ctrs))
2503

2504
		allCtrs, err := state.AllContainers(false)
2505
		assert.NoError(t, err)
2506
		assert.Equal(t, 0, len(allCtrs))
2507
	})
2508
}
2509

2510
func TestUpdatePodInvalidPod(t *testing.T) {
2511
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2512
		err := state.UpdatePod(&Pod{config: &PodConfig{}})
2513
		assert.Error(t, err)
2514
	})
2515
}
2516

2517
func TestUpdatePodPodNotInStateFails(t *testing.T) {
2518
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2519
		testPod, err := getTestPod1(manager)
2520
		assert.NoError(t, err)
2521

2522
		err = state.UpdatePod(testPod)
2523
		assert.Error(t, err)
2524
	})
2525
}
2526

2527
func TestSavePodInvalidPod(t *testing.T) {
2528
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2529
		err := state.SavePod(&Pod{config: &PodConfig{}})
2530
		assert.Error(t, err)
2531
	})
2532
}
2533

2534
func TestSavePodPodNotInStateFails(t *testing.T) {
2535
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2536
		testPod, err := getTestPod1(manager)
2537
		assert.NoError(t, err)
2538

2539
		err = state.SavePod(testPod)
2540
		assert.Error(t, err)
2541
	})
2542
}
2543

2544
func TestSaveAndUpdatePod(t *testing.T) {
2545
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2546
		testPod, err := getTestPod1(manager)
2547
		assert.NoError(t, err)
2548

2549
		err = state.AddPod(testPod)
2550
		assert.NoError(t, err)
2551

2552
		statePod, err := state.Pod(testPod.ID())
2553
		assert.NoError(t, err)
2554

2555
		testPodsEqual(t, statePod, testPod, true)
2556

2557
		testPod.state.CgroupPath = "/new/path/for/test"
2558

2559
		err = state.SavePod(testPod)
2560
		assert.NoError(t, err)
2561

2562
		err = state.UpdatePod(statePod)
2563
		assert.NoError(t, err)
2564

2565
		testPodsEqual(t, statePod, testPod, false)
2566
	})
2567
}
2568

2569
func TestGetContainerConfigSucceeds(t *testing.T) {
2570
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2571
		testCtr, err := getTestCtr1(manager)
2572
		assert.NoError(t, err)
2573

2574
		err = state.AddContainer(testCtr)
2575
		assert.NoError(t, err)
2576

2577
		ctrCfg, err := state.GetContainerConfig(testCtr.ID())
2578
		assert.NoError(t, err)
2579
		assert.Equal(t, ctrCfg, testCtr.Config())
2580
	})
2581
}
2582

2583
func TestGetContainerConfigEmptyIDFails(t *testing.T) {
2584
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2585
		_, err := state.GetContainerConfig("")
2586
		assert.Error(t, err)
2587
	})
2588
}
2589
func TestGetContainerConfigNonExistentIDFails(t *testing.T) {
2590
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2591
		_, err := state.GetContainerConfig("does not exist")
2592
		assert.Error(t, err)
2593
	})
2594
}
2595

2596
// Test that the state will convert the ports to the new format
2597
func TestConvertPortMapping(t *testing.T) {
2598
	runForAllStates(t, func(t *testing.T, state State, manager lock.Manager) {
2599
		testCtr, err := getTestCtr1(manager)
2600
		assert.NoError(t, err)
2601

2602
		ports := testCtr.config.PortMappings
2603

2604
		oldPorts := []types.OCICNIPortMapping{
2605
			{
2606
				HostPort:      80,
2607
				ContainerPort: 90,
2608
				Protocol:      "tcp",
2609
				HostIP:        "192.168.3.3",
2610
			},
2611
			{
2612
				HostPort:      100,
2613
				ContainerPort: 110,
2614
				Protocol:      "udp",
2615
				HostIP:        "192.168.4.4",
2616
			},
2617
		}
2618

2619
		testCtr.config.OldPortMappings = oldPorts
2620
		testCtr.config.PortMappings = nil
2621

2622
		err = state.AddContainer(testCtr)
2623
		assert.NoError(t, err)
2624

2625
		retrievedCtr, err := state.Container(testCtr.ID())
2626
		assert.NoError(t, err)
2627

2628
		// set values to expected ones
2629
		testCtr.config.PortMappings = ports
2630

2631
		testContainersEqual(t, retrievedCtr, testCtr, true)
2632
	})
2633
}
2634
podman

Использование cookies
