Rework state tests to avoid boilerplate. Begin adding pod tests.

Signed-off-by: Matthew Heon <matthew.heon@gmail.com>

Closes: #268
Approved by: rhatdan

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)
+	})
 }