diff options
Diffstat (limited to 'libpod/state_test.go')
| -rw-r--r-- | libpod/state_test.go | 989 |
1 files changed, 640 insertions, 349 deletions
diff --git a/libpod/state_test.go b/libpod/state_test.go index 0a18c988d..6c4ee30af 100644 --- a/libpod/state_test.go +++ b/libpod/state_test.go @@ -4,6 +4,7 @@ import ( "io/ioutil" "os" "path/filepath" + "strings" "testing" "time" @@ -79,544 +80,834 @@ func getEmptySQLState() (s State, p string, p2 string, err error) { return state, tmpDir, lockDir, nil } -func runForAllStates(t *testing.T, testName string, testFunc func(*testing.T, State, string)) { +func runForAllStates(t *testing.T, testFunc func(*testing.T, State, string)) { for stateName, stateFunc := range testedStates { state, path, lockPath, err := stateFunc() if err != nil { - t.Fatalf("Error initializing state %s", stateName) + t.Fatalf("Error initializing state %s: %v", stateName, err) } defer os.RemoveAll(path) defer state.Close() - testName = testName + "-" + stateName - - success := t.Run(testName, func(t *testing.T) { + success := t.Run(stateName, func(t *testing.T) { testFunc(t, state, lockPath) }) if !success { t.Fail() - t.Logf("%s failed for state %s", testName, stateName) } } } -func TestAddAndGetContainer(t *testing.T) { - runForAllStates(t, "TestAddAndGetContainer", addAndGetContainer) +func getTestCtrN(n, lockPath string) (*Container, error) { + return getTestContainer(strings.Repeat(n, 32), "test"+n, lockPath) } -func addAndGetContainer(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) - - err = state.AddContainer(testCtr) - assert.NoError(t, err) +func getTestCtr1(lockPath string) (*Container, error) { + return getTestCtrN("1", lockPath) +} - retrievedCtr, err := state.Container(testCtr.ID()) - assert.NoError(t, err) +func getTestCtr2(lockPath string) (*Container, error) { + return getTestCtrN("2", lockPath) +} - // Use assert.EqualValues if the test fails to pretty print diff - // between actual and expected - if !testContainersEqual(testCtr, retrievedCtr) { - assert.EqualValues(t, testCtr, retrievedCtr) - } +func getTestPodN(n, lockPath string) (*Pod, error) { + return getTestPod(strings.Repeat(n, 32), "test"+n, lockPath) } -func TestAddAndGetContainerFromMultiple(t *testing.T) { - runForAllStates(t, "TestAddAndGetContainerFromMultiple", addAndGetContainerFromMultiple) +func getTestPod1(lockPath string) (*Pod, error) { + return getTestPodN("1", lockPath) } -func addAndGetContainerFromMultiple(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("22222222222222222222222222222222", "test2", lockPath) - assert.NoError(t, err) +func getTestPod2(lockPath string) (*Pod, error) { + return getTestPodN("2", lockPath) +} - err = state.AddContainer(testCtr1) - assert.NoError(t, err) +func TestAddAndGetContainer(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr2) - assert.NoError(t, err) + err = state.AddContainer(testCtr) + assert.NoError(t, err) - retrievedCtr, err := state.Container(testCtr1.ID()) - assert.NoError(t, err) + retrievedCtr, err := state.Container(testCtr.ID()) + assert.NoError(t, err) - // Use assert.EqualValues if the test fails to pretty print diff - // between actual and expected - if !testContainersEqual(testCtr1, retrievedCtr) { - assert.EqualValues(t, testCtr1, retrievedCtr) - } + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testContainersEqual(testCtr, retrievedCtr) { + assert.EqualValues(t, testCtr, retrievedCtr) + } + }) } -func TestAddInvalidContainerFails(t *testing.T) { - runForAllStates(t, "TestAddInvalidContainerFails", addInvalidContainerFails) +func TestAddAndGetContainerFromMultiple(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) + + err = state.AddContainer(testCtr1) + assert.NoError(t, err) + + err = state.AddContainer(testCtr2) + assert.NoError(t, err) + + retrievedCtr, err := state.Container(testCtr1.ID()) + assert.NoError(t, err) + + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testContainersEqual(testCtr1, retrievedCtr) { + assert.EqualValues(t, testCtr1, retrievedCtr) + } + }) } -func addInvalidContainerFails(t *testing.T, state State, lockPath string) { - err := state.AddContainer(&Container{config: &ContainerConfig{ID: "1234"}}) - assert.Error(t, err) +func TestGetContainerPodSameIDFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) + + err = state.AddPod(testPod) + assert.NoError(t, err) + + _, err = state.Container(testPod.ID()) + assert.Error(t, err) + }) } -func TestAddDuplicateCtrIDFails(t *testing.T) { - runForAllStates(t, "TestAddDuplicateCtrIDFails", addDuplicateCtrIDFails) +func TestAddInvalidContainerFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + err := state.AddContainer(&Container{config: &ContainerConfig{ID: "1234"}}) + assert.Error(t, err) + }) } -func addDuplicateCtrIDFails(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer(testCtr1.ID(), "test2", lockPath) - assert.NoError(t, err) +func TestAddDuplicateCtrIDFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestContainer(testCtr1.ID(), "test2", lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + err = state.AddContainer(testCtr1) + assert.NoError(t, err) - err = state.AddContainer(testCtr2) - assert.Error(t, err) + err = state.AddContainer(testCtr2) + assert.Error(t, err) + }) } func TestAddDuplicateCtrNameFails(t *testing.T) { - runForAllStates(t, "TestAddDuplicateCtrNameFails", addDuplicateCtrNameFails) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestContainer(strings.Repeat("2", 32), testCtr1.Name(), lockPath) + assert.NoError(t, err) + + err = state.AddContainer(testCtr1) + assert.NoError(t, err) + + err = state.AddContainer(testCtr2) + assert.Error(t, err) + }) } -func addDuplicateCtrNameFails(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("22222222222222222222222222222222", testCtr1.Name(), lockPath) - assert.NoError(t, err) +func TestAddCtrPodDupIDFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) + testCtr, err := getTestContainer(testPod.ID(), "testCtr", lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + err = state.AddPod(testPod) + assert.NoError(t, err) - err = state.AddContainer(testCtr2) - assert.Error(t, err) + err = state.AddContainer(testCtr) + assert.Error(t, err) + }) } -func TestGetNonexistentContainerFails(t *testing.T) { - runForAllStates(t, "TestGetNonexistentContainerFails", getNonexistentContainerFails) -} +func TestAddCtrPodDupNameFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) + testCtr, err := getTestContainer(strings.Repeat("2", 32), testPod.Name(), lockPath) + assert.NoError(t, err) -func getNonexistentContainerFails(t *testing.T, state State, lockPath string) { - _, err := state.Container("does not exist") - assert.Error(t, err) -} + err = state.AddPod(testPod) + assert.NoError(t, err) -func TestGetContainerWithEmptyIDFails(t *testing.T) { - runForAllStates(t, "TestGetContainerWithEmptyIDFails", getContainerWithEmptyIDFails) + err = state.AddContainer(testCtr) + assert.Error(t, err) + }) } -func getContainerWithEmptyIDFails(t *testing.T, state State, lockPath string) { - _, err := state.Container("") - assert.Error(t, err) +func TestGetNonexistentContainerFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.Container("does not exist") + assert.Error(t, err) + }) } -func TestLookupContainerWithEmptyIDFails(t *testing.T) { - runForAllStates(t, "TestLookupContainerWithEmptyIDFails", lookupContainerWithEmptyIDFails) +func TestGetContainerWithEmptyIDFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.Container("") + assert.Error(t, err) + }) } -func lookupContainerWithEmptyIDFails(t *testing.T, state State, lockPath string) { - _, err := state.LookupContainer("") - assert.Error(t, err) +func TestLookupContainerWithEmptyIDFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.LookupContainer("") + assert.Error(t, err) + }) } func TestLookupNonexistentContainerFails(t *testing.T) { - runForAllStates(t, "TestLookupNonexistantContainerFails", lookupNonexistentContainerFails) -} - -func lookupNonexistentContainerFails(t *testing.T, state State, lockPath string) { - _, err := state.LookupContainer("does not exist") - assert.Error(t, err) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.LookupContainer("does not exist") + assert.Error(t, err) + }) } func TestLookupContainerByFullID(t *testing.T) { - runForAllStates(t, "TestLookupContainerByFullID", lookupContainerByFullID) -} - -func lookupContainerByFullID(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr) - assert.NoError(t, err) + err = state.AddContainer(testCtr) + assert.NoError(t, err) - retrievedCtr, err := state.LookupContainer(testCtr.ID()) - assert.NoError(t, err) + retrievedCtr, err := state.LookupContainer(testCtr.ID()) + assert.NoError(t, err) - // Use assert.EqualValues if the test fails to pretty print diff - // between actual and expected - if !testContainersEqual(testCtr, retrievedCtr) { - assert.EqualValues(t, testCtr, retrievedCtr) - } + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testContainersEqual(testCtr, retrievedCtr) { + assert.EqualValues(t, testCtr, retrievedCtr) + } + }) } func TestLookupContainerByUniquePartialID(t *testing.T) { - runForAllStates(t, "TestLookupContainerByUniquePartialID", lookupContainerByUniquePartialID) -} + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) -func lookupContainerByUniquePartialID(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) + err = state.AddContainer(testCtr) + assert.NoError(t, err) - err = state.AddContainer(testCtr) - assert.NoError(t, err) + retrievedCtr, err := state.LookupContainer(testCtr.ID()[0:8]) + assert.NoError(t, err) - retrievedCtr, err := state.LookupContainer(testCtr.ID()[0:8]) - assert.NoError(t, err) - - // Use assert.EqualValues if the test fails to pretty print diff - // between actual and expected - if !testContainersEqual(testCtr, retrievedCtr) { - assert.EqualValues(t, testCtr, retrievedCtr) - } + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testContainersEqual(testCtr, retrievedCtr) { + assert.EqualValues(t, testCtr, retrievedCtr) + } + }) } func TestLookupContainerByNonUniquePartialIDFails(t *testing.T) { - runForAllStates(t, "TestLookupContainerByNonUniquePartialIDFails", lookupContainerByNonUniquePartialIDFails) -} + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestContainer(strings.Repeat("0", 32), "test1", lockPath) + assert.NoError(t, err) + testCtr2, err := getTestContainer(strings.Repeat("0", 31)+"1", "test2", lockPath) + assert.NoError(t, err) -func lookupContainerByNonUniquePartialIDFails(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("00000000000000000000000000000000", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("00000000000000000000000000000001", "test2", lockPath) - assert.NoError(t, err) + err = state.AddContainer(testCtr1) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + err = state.AddContainer(testCtr2) + assert.NoError(t, err) - err = state.AddContainer(testCtr2) - assert.NoError(t, err) - - _, err = state.LookupContainer(testCtr1.ID()[0:8]) - assert.Error(t, err) + _, err = state.LookupContainer(testCtr1.ID()[0:8]) + assert.Error(t, err) + }) } func TestLookupContainerByName(t *testing.T) { - runForAllStates(t, "TestLookupContainerByName", lookupContainerByName) -} + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) -func lookupContainerByName(t *testing.T, state State, lockPath string) { - state, path, lockPath, err := getEmptySQLState() - assert.NoError(t, err) - defer os.RemoveAll(path) - defer state.Close() + err = state.AddContainer(testCtr) + assert.NoError(t, err) - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) + retrievedCtr, err := state.LookupContainer(testCtr.Name()) + assert.NoError(t, err) - err = state.AddContainer(testCtr) - assert.NoError(t, err) + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testContainersEqual(testCtr, retrievedCtr) { + assert.EqualValues(t, testCtr, retrievedCtr) + } + }) +} - retrievedCtr, err := state.LookupContainer(testCtr.Name()) - assert.NoError(t, err) +func TestLookupCtrByPodNameFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) - // Use assert.EqualValues if the test fails to pretty print diff - // between actual and expected - if !testContainersEqual(testCtr, retrievedCtr) { - assert.EqualValues(t, testCtr, retrievedCtr) - } -} + err = state.AddPod(testPod) + assert.NoError(t, err) -func TestHasContainerEmptyIDFails(t *testing.T) { - runForAllStates(t, "TestHasContainerEmptyIDFails", hasContainerEmptyIDFails) + _, err = state.LookupContainer(testPod.Name()) + assert.Error(t, err) + }) } -func hasContainerEmptyIDFails(t *testing.T, state State, lockPath string) { - _, err := state.HasContainer("") - assert.Error(t, err) +func TestLookupCtrByPodIDFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) + + err = state.AddPod(testPod) + assert.NoError(t, err) + + _, err = state.LookupContainer(testPod.ID()) + assert.Error(t, err) + }) } -func TestHasContainerNoSuchContainerReturnsFalse(t *testing.T) { - runForAllStates(t, "TestHasContainerNoSuchContainerReturnsFalse", hasContainerNoSuchContainerReturnsFalse) +func TestHasContainerEmptyIDFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.HasContainer("") + assert.Error(t, err) + }) } -func hasContainerNoSuchContainerReturnsFalse(t *testing.T, state State, lockPath string) { - exists, err := state.HasContainer("does not exist") - assert.NoError(t, err) - assert.False(t, exists) +func TestHasContainerNoSuchContainerReturnsFalse(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + exists, err := state.HasContainer("does not exist") + assert.NoError(t, err) + assert.False(t, exists) + }) } func TestHasContainerFindsContainer(t *testing.T) { - runForAllStates(t, "TestHasContainerFindsContainer", hasContainerFindsContainer) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) + + err = state.AddContainer(testCtr) + assert.NoError(t, err) + + exists, err := state.HasContainer(testCtr.ID()) + assert.NoError(t, err) + assert.True(t, exists) + }) } -func hasContainerFindsContainer(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) +func TestHasContainerPodIDIsFalse(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr) - assert.NoError(t, err) + err = state.AddPod(testPod) + assert.NoError(t, err) - exists, err := state.HasContainer(testCtr.ID()) - assert.NoError(t, err) - assert.True(t, exists) + exists, err := state.HasContainer(testPod.ID()) + assert.NoError(t, err) + assert.False(t, exists) + }) } func TestSaveAndUpdateContainer(t *testing.T) { - runForAllStates(t, "TestSaveAndUpdateContainer", saveAndUpdateContainer) -} - -func saveAndUpdateContainer(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr) - assert.NoError(t, err) + err = state.AddContainer(testCtr) + assert.NoError(t, err) - retrievedCtr, err := state.Container(testCtr.ID()) - assert.NoError(t, err) + retrievedCtr, err := state.Container(testCtr.ID()) + assert.NoError(t, err) - retrievedCtr.state.State = ContainerStateStopped - retrievedCtr.state.ExitCode = 127 - retrievedCtr.state.FinishedTime = time.Now() + retrievedCtr.state.State = ContainerStateStopped + retrievedCtr.state.ExitCode = 127 + retrievedCtr.state.FinishedTime = time.Now() - err = state.SaveContainer(retrievedCtr) - assert.NoError(t, err) + err = state.SaveContainer(retrievedCtr) + assert.NoError(t, err) - err = state.UpdateContainer(testCtr) - assert.NoError(t, err) + err = state.UpdateContainer(testCtr) + assert.NoError(t, err) - // Use assert.EqualValues if the test fails to pretty print diff - // between actual and expected - if !testContainersEqual(testCtr, retrievedCtr) { - assert.EqualValues(t, testCtr, retrievedCtr) - } + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testContainersEqual(testCtr, retrievedCtr) { + assert.EqualValues(t, testCtr, retrievedCtr) + } + }) } func TestUpdateContainerNotInDatabaseReturnsError(t *testing.T) { - runForAllStates(t, "TestUpdateContainerNotInDatabaseReturnsError", updateContainerNotInDatabaseReturnsError) -} - -func updateContainerNotInDatabaseReturnsError(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - err = state.UpdateContainer(testCtr) - assert.Error(t, err) - assert.False(t, testCtr.valid) + err = state.UpdateContainer(testCtr) + assert.Error(t, err) + assert.False(t, testCtr.valid) + }) } func TestUpdateInvalidContainerReturnsError(t *testing.T) { - runForAllStates(t, "TestUpdateInvalidContainerReturnsError", updateInvalidContainerReturnsError) -} - -func updateInvalidContainerReturnsError(t *testing.T, state State, lockPath string) { - err := state.UpdateContainer(&Container{config: &ContainerConfig{ID: "1234"}}) - assert.Error(t, err) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + err := state.UpdateContainer(&Container{config: &ContainerConfig{ID: "1234"}}) + assert.Error(t, err) + }) } func TestSaveInvalidContainerReturnsError(t *testing.T) { - runForAllStates(t, "TestSaveInvalidContainerReturnsError", saveInvalidContainerReturnsError) + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + err := state.SaveContainer(&Container{config: &ContainerConfig{ID: "1234"}}) + assert.Error(t, err) + }) } -func saveInvalidContainerReturnsError(t *testing.T, state State, lockPath string) { - err := state.SaveContainer(&Container{config: &ContainerConfig{ID: "1234"}}) - assert.Error(t, err) +func TestSaveContainerNotInStateReturnsError(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) + + err = state.SaveContainer(testCtr) + assert.Error(t, err) + assert.False(t, testCtr.valid) + }) } -func TestSaveContainerNotInStateReturnsError(t *testing.T) { - runForAllStates(t, "TestSaveContainerNotInStateReturnsError", saveContainerNotInStateReturnsError) +func TestRemoveContainer(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) + + err = state.AddContainer(testCtr) + assert.NoError(t, err) + + ctrs, err := state.AllContainers() + assert.NoError(t, err) + assert.Equal(t, 1, len(ctrs)) + + err = state.RemoveContainer(testCtr) + assert.NoError(t, err) + + ctrs2, err := state.AllContainers() + assert.NoError(t, err) + assert.Equal(t, 0, len(ctrs2)) + }) } -func saveContainerNotInStateReturnsError(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) +func TestRemoveNonexistantContainerFails(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - err = state.SaveContainer(testCtr) - assert.Error(t, err) - assert.False(t, testCtr.valid) + err = state.RemoveContainer(testCtr) + assert.Error(t, err) + }) } -func TestRemoveContainer(t *testing.T) { - runForAllStates(t, "TestRemoveContainer", removeContainer) +func TestGetAllContainersOnNewStateIsEmpty(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + ctrs, err := state.AllContainers() + assert.NoError(t, err) + assert.Equal(t, 0, len(ctrs)) + }) } -func removeContainer(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) +func TestGetAllContainersWithOneContainer(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) + + err = state.AddContainer(testCtr) + assert.NoError(t, err) + + ctrs, err := state.AllContainers() + assert.NoError(t, err) + assert.Equal(t, 1, len(ctrs)) + + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testContainersEqual(testCtr, ctrs[0]) { + assert.EqualValues(t, testCtr, ctrs[0]) + } + }) +} - err = state.AddContainer(testCtr) - assert.NoError(t, err) +func TestGetAllContainersTwoContainers(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) - ctrs, err := state.AllContainers() - assert.NoError(t, err) - assert.Equal(t, 1, len(ctrs)) + err = state.AddContainer(testCtr1) + assert.NoError(t, err) - err = state.RemoveContainer(testCtr) - assert.NoError(t, err) + err = state.AddContainer(testCtr2) + assert.NoError(t, err) - ctrs2, err := state.AllContainers() - assert.NoError(t, err) - assert.Equal(t, 0, len(ctrs2)) + ctrs, err := state.AllContainers() + assert.NoError(t, err) + assert.Equal(t, 2, len(ctrs)) + }) } -func TestRemoveNonexistantContainerFails(t *testing.T) { - runForAllStates(t, "TestRemoveNonexistantContainerFails", removeNonexistantContainerFails) +func TestContainerInUseInvalidContainer(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.ContainerInUse(&Container{}) + assert.Error(t, err) + }) } -func removeNonexistantContainerFails(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) +func TestContainerInUseOneContainer(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) - err = state.RemoveContainer(testCtr) - assert.Error(t, err) -} + testCtr2.config.UserNsCtr = testCtr1.config.ID -func TestGetAllContainersOnNewStateIsEmpty(t *testing.T) { - runForAllStates(t, "TestGetAllContainersOnNewStateIsEmpty", getAllContainersOnNewStateIsEmpty) + err = state.AddContainer(testCtr1) + assert.NoError(t, err) + + err = state.AddContainer(testCtr2) + assert.NoError(t, err) + + ids, err := state.ContainerInUse(testCtr1) + assert.NoError(t, err) + assert.Equal(t, 1, len(ids)) + assert.Equal(t, testCtr2.config.ID, ids[0]) + }) } -func getAllContainersOnNewStateIsEmpty(t *testing.T, state State, lockPath string) { - ctrs, err := state.AllContainers() - assert.NoError(t, err) - assert.Equal(t, 0, len(ctrs)) +func TestContainerInUseTwoContainers(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) + testCtr3, err := getTestCtrN("3", lockPath) + assert.NoError(t, err) + + testCtr2.config.UserNsCtr = testCtr1.config.ID + testCtr3.config.IPCNsCtr = testCtr1.config.ID + + err = state.AddContainer(testCtr1) + assert.NoError(t, err) + + err = state.AddContainer(testCtr2) + assert.NoError(t, err) + + err = state.AddContainer(testCtr3) + assert.NoError(t, err) + + ids, err := state.ContainerInUse(testCtr1) + assert.NoError(t, err) + assert.Equal(t, 2, len(ids)) + }) } -func TestGetAllContainersWithOneContainer(t *testing.T) { - runForAllStates(t, "TestGetAllContainersWithOneContainer", getAllContainersWithOneContainer) +func TestContainerInUseOneContainerMultipleDependencies(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) + + testCtr2.config.UserNsCtr = testCtr1.config.ID + testCtr2.config.IPCNsCtr = testCtr1.config.ID + + err = state.AddContainer(testCtr1) + assert.NoError(t, err) + + err = state.AddContainer(testCtr2) + assert.NoError(t, err) + + ids, err := state.ContainerInUse(testCtr1) + assert.NoError(t, err) + assert.Equal(t, 1, len(ids)) + assert.Equal(t, testCtr2.config.ID, ids[0]) + }) } -func getAllContainersWithOneContainer(t *testing.T, state State, lockPath string) { - testCtr, err := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test", lockPath) - assert.NoError(t, err) +func TestCannotRemoveContainerWithDependency(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr) - assert.NoError(t, err) + testCtr2.config.UserNsCtr = testCtr1.config.ID - ctrs, err := state.AllContainers() - assert.NoError(t, err) - assert.Equal(t, 1, len(ctrs)) + err = state.AddContainer(testCtr1) + assert.NoError(t, err) - // Use assert.EqualValues if the test fails to pretty print diff - // between actual and expected - if !testContainersEqual(testCtr, ctrs[0]) { - assert.EqualValues(t, testCtr, ctrs[0]) - } + err = state.AddContainer(testCtr2) + assert.NoError(t, err) + + err = state.RemoveContainer(testCtr1) + assert.Error(t, err) + }) } -func TestGetAllContainersTwoContainers(t *testing.T) { - runForAllStates(t, "TestGetAllContainersTwoContainers", getAllContainersTwoContainers) +func TestCanRemoveContainerAfterDependencyRemoved(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) + + testCtr2.config.UserNsCtr = testCtr1.ID() + + err = state.AddContainer(testCtr1) + assert.NoError(t, err) + + err = state.AddContainer(testCtr2) + assert.NoError(t, err) + + err = state.RemoveContainer(testCtr2) + assert.NoError(t, err) + + err = state.RemoveContainer(testCtr1) + assert.NoError(t, err) + }) } -func getAllContainersTwoContainers(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("22222222222222222222222222222222", "test2", lockPath) - assert.NoError(t, err) +func TestCanRemoveContainerAfterDependencyRemovedDuplicate(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr1, err := getTestCtr1(lockPath) + assert.NoError(t, err) + testCtr2, err := getTestCtr2(lockPath) + assert.NoError(t, err) + + testCtr2.config.UserNsCtr = testCtr1.ID() + testCtr2.config.IPCNsCtr = testCtr1.ID() + + err = state.AddContainer(testCtr1) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + err = state.AddContainer(testCtr2) + assert.NoError(t, err) - err = state.AddContainer(testCtr2) - assert.NoError(t, err) + err = state.RemoveContainer(testCtr2) + assert.NoError(t, err) - ctrs, err := state.AllContainers() - assert.NoError(t, err) - assert.Equal(t, 2, len(ctrs)) + err = state.RemoveContainer(testCtr1) + assert.NoError(t, err) + }) } -func TestContainerInUseInvalidContainer(t *testing.T) { - runForAllStates(t, "TestContainerInUseInvalidContainer", containerInUseInvalidContainer) +func TestGetPodDoesNotExist(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.Pod("doesnotexist") + assert.Error(t, err) + }) } -func containerInUseInvalidContainer(t *testing.T, state State, lockPath string) { - _, err := state.ContainerInUse(&Container{}) - assert.Error(t, err) +func TestGetPodEmptyID(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.Pod("") + assert.Error(t, err) + }) } -func TestContainerInUseOneContainer(t *testing.T) { - runForAllStates(t, "TestContainerInUseOneContainer", containerInUseOneContainer) +func TestGetPodOnePod(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) + + err = state.AddPod(testPod) + assert.NoError(t, err) + + statePod, err := state.Pod(testPod.ID()) + assert.NoError(t, err) + + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testPodsEqual(testPod, statePod) { + assert.EqualValues(t, testPod, statePod) + } + }) } -func containerInUseOneContainer(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("22222222222222222222222222222222", "test2", lockPath) - assert.NoError(t, err) +func TestGetOnePodFromTwo(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod1, err := getTestPod1(lockPath) + assert.NoError(t, err) + + testPod2, err := getTestPod2(lockPath) + assert.NoError(t, err) - testCtr2.config.UserNsCtr = testCtr1.config.ID + err = state.AddPod(testPod1) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + err = state.AddPod(testPod2) + assert.NoError(t, err) - err = state.AddContainer(testCtr2) - assert.NoError(t, err) + statePod, err := state.Pod(testPod1.ID()) + assert.NoError(t, err) - ids, err := state.ContainerInUse(testCtr1) - assert.NoError(t, err) - assert.Equal(t, 1, len(ids)) - assert.Equal(t, testCtr2.config.ID, ids[0]) + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testPodsEqual(testPod1, statePod) { + assert.EqualValues(t, testPod1, statePod) + } + }) } -func TestContainerInUseTwoContainers(t *testing.T) { - runForAllStates(t, "TestContainerInUseTwoContainers", containerInUseTwoContainers) +func TestGetNotExistPodWithPods(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod1, err := getTestPod1(lockPath) + assert.NoError(t, err) + + testPod2, err := getTestPod2(lockPath) + assert.NoError(t, err) + + err = state.AddPod(testPod1) + assert.NoError(t, err) + + err = state.AddPod(testPod2) + assert.NoError(t, err) + + _, err = state.Pod("notexist") + assert.Error(t, err) + }) } -func containerInUseTwoContainers(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("22222222222222222222222222222222", "test2", lockPath) - assert.NoError(t, err) - testCtr3, err := getTestContainer("33333333333333333333333333333333", "test3", lockPath) - assert.NoError(t, err) +func TestGetPodByCtrID(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - testCtr2.config.UserNsCtr = testCtr1.config.ID - testCtr3.config.IPCNsCtr = testCtr1.config.ID + err = state.AddContainer(testCtr) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + _, err = state.Pod(testCtr.ID()) + assert.Error(t, err) + }) +} + +func TestLookupPodEmptyID(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.LookupPod("") + assert.Error(t, err) + }) +} + +func TestLookupNotExistPod(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + _, err := state.LookupPod("doesnotexist") + assert.Error(t, err) + }) +} - err = state.AddContainer(testCtr2) - assert.NoError(t, err) +func TestLookupPodFullID(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr3) - assert.NoError(t, err) + err = state.AddPod(testPod) + assert.NoError(t, err) - ids, err := state.ContainerInUse(testCtr1) - assert.NoError(t, err) - assert.Equal(t, 2, len(ids)) + statePod, err := state.LookupPod(testPod.ID()) + assert.NoError(t, err) + + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testPodsEqual(testPod, statePod) { + assert.EqualValues(t, testPod, statePod) + } + }) } -func TestCannotRemoveContainerWithDependency(t *testing.T) { - runForAllStates(t, "TestCannotRemoveContainerWithDependency", cannotRemoveContainerWithDependency) +func TestLookupPodUniquePartialID(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) + + err = state.AddPod(testPod) + assert.NoError(t, err) + + statePod, err := state.LookupPod(testPod.ID()[0:8]) + assert.NoError(t, err) + + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testPodsEqual(testPod, statePod) { + assert.EqualValues(t, testPod, statePod) + } + }) } -func cannotRemoveContainerWithDependency(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("22222222222222222222222222222222", "test2", lockPath) - assert.NoError(t, err) +func TestLookupPodNonUniquePartialID(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod1, err := getTestPod(strings.Repeat("1", 32), "test1", lockPath) + assert.NoError(t, err) - testCtr2.config.UserNsCtr = testCtr1.config.ID + testPod2, err := getTestPod(strings.Repeat("1", 31)+"2", "test2", lockPath) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + err = state.AddPod(testPod1) + assert.NoError(t, err) - err = state.AddContainer(testCtr2) - assert.NoError(t, err) + err = state.AddPod(testPod2) + assert.NoError(t, err) - err = state.RemoveContainer(testCtr1) - assert.Error(t, err) + _, err = state.LookupPod(testPod1.ID()[0:8]) + assert.Error(t, err) + }) } -func TestCanRemoveContainerAfterDependencyRemoved(t *testing.T) { - runForAllStates(t, "TestCanRemoveContainerAfterDependencyRemoved", canRemoveContainerAfterDependencyRemoved) +func TestLookupPodByName(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testPod, err := getTestPod1(lockPath) + assert.NoError(t, err) + + err = state.AddPod(testPod) + assert.NoError(t, err) + + statePod, err := state.LookupPod(testPod.Name()) + assert.NoError(t, err) + + // Use assert.EqualValues if the test fails to pretty print diff + // between actual and expected + if !testPodsEqual(testPod, statePod) { + assert.EqualValues(t, testPod, statePod) + } + }) } -func canRemoveContainerAfterDependencyRemoved(t *testing.T, state State, lockPath string) { - testCtr1, err := getTestContainer("11111111111111111111111111111111", "test1", lockPath) - assert.NoError(t, err) - testCtr2, err := getTestContainer("22222222222222222222222222222222", "test2", lockPath) - assert.NoError(t, err) +func TestLookupPodByCtrID(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - testCtr2.config.UserNsCtr = testCtr1.config.ID + err = state.AddContainer(testCtr) + assert.NoError(t, err) - err = state.AddContainer(testCtr1) - assert.NoError(t, err) + _, err = state.LookupPod(testCtr.ID()) + assert.Error(t, err) + }) +} - err = state.AddContainer(testCtr2) - assert.NoError(t, err) +func TestLookupPodByCtrName(t *testing.T) { + runForAllStates(t, func(t *testing.T, state State, lockPath string) { + testCtr, err := getTestCtr1(lockPath) + assert.NoError(t, err) - err = state.RemoveContainer(testCtr2) - assert.NoError(t, err) + err = state.AddContainer(testCtr) + assert.NoError(t, err) - err = state.RemoveContainer(testCtr1) - assert.NoError(t, err) + _, err = state.LookupPod(testCtr.Name()) + assert.Error(t, err) + }) } |