package libpod import ( "encoding/json" "io/ioutil" "os" "path/filepath" "reflect" "testing" "time" "github.com/opencontainers/runtime-tools/generate" "github.com/stretchr/testify/assert" ) func getTestContainer(id, name string) *Container { ctr := &Container{ config: &containerConfig{ ID: id, Name: name, RootfsImageID: id, RootfsImageName: "testimg", UseImageConfig: true, StaticDir: "/does/not/exist/", Stdin: true, Labels: make(map[string]string), StopSignal: 0, CreatedTime: time.Now(), }, state: &containerRuntimeInfo{ State: ContainerStateRunning, ConfigPath: "/does/not/exist/specs/" + id, RunDir: "/does/not/exist/tmp/", Mounted: true, Mountpoint: "/does/not/exist/tmp/" + id, }, valid: true, } g := generate.New() ctr.config.Spec = g.Spec() ctr.config.Labels["test"] = "testing" return ctr } // This horrible hack tests if containers are equal in a way that should handle // empty arrays being dropped to nil pointers in the spec JSON func testContainersEqual(a, b *Container) bool { if a == nil && b == nil { return true } else if a == nil || b == nil { return false } if a.valid != b.valid { return false } aConfigJSON, err := json.Marshal(a.config) if err != nil { return false } bConfigJSON, err := json.Marshal(b.config) if err != nil { return false } if !reflect.DeepEqual(aConfigJSON, bConfigJSON) { return false } aStateJSON, err := json.Marshal(a.state) if err != nil { return false } bStateJSON, err := json.Marshal(b.state) if err != nil { return false } return reflect.DeepEqual(aStateJSON, bStateJSON) } // Get an empty state for use in tests // An empty Runtime is provided func getEmptyState() (s State, p string, err error) { tmpDir, err := ioutil.TempDir("", "libpod_state_test_") if err != nil { return nil, "", err } defer func() { if err != nil { os.RemoveAll(tmpDir) } }() dbPath := filepath.Join(tmpDir, "db.sql") lockPath := filepath.Join(tmpDir, "db.lck") state, err := NewSQLState(dbPath, lockPath, tmpDir, nil) if err != nil { return nil, "", err } return state, tmpDir, nil } func TestAddAndGetContainer(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.AddContainer(testCtr) 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(testCtr, retrievedCtr) { assert.EqualValues(t, testCtr, retrievedCtr) } } func TestAddAndGetContainerFromMultiple(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr1 := getTestContainer("11111111111111111111111111111111", "test1") testCtr2 := getTestContainer("22222222222222222222222222222222", "test2") 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 TestAddInvalidContainerFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() err = state.AddContainer(&Container{}) assert.Error(t, err) } func TestAddDuplicateIDFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr1 := getTestContainer("11111111111111111111111111111111", "test1") testCtr2 := getTestContainer(testCtr1.ID(), "test2") err = state.AddContainer(testCtr1) assert.NoError(t, err) err = state.AddContainer(testCtr2) assert.Error(t, err) } func TestAddDuplicateNameFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr1 := getTestContainer("11111111111111111111111111111111", "test1") testCtr2 := getTestContainer("22222222222222222222222222222222", testCtr1.Name()) err = state.AddContainer(testCtr1) assert.NoError(t, err) err = state.AddContainer(testCtr2) assert.Error(t, err) } func TestGetNonexistantContainerFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() _, err = state.Container("does not exist") assert.Error(t, err) } func TestGetContainerWithEmptyIDFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() _, err = state.Container("") assert.Error(t, err) } func TestLookupContainerWithEmptyIDFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() _, err = state.LookupContainer("") assert.Error(t, err) } func TestLookupNonexistantContainerFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) _, err = state.LookupContainer("does not exist") assert.Error(t, err) } func TestLookupContainerByFullID(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.AddContainer(testCtr) 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) } } func TestLookupContainerByUniquePartialID(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.AddContainer(testCtr) 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) } } func TestLookupContainerByNonUniquePartialIDFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr1 := getTestContainer("00000000000000000000000000000000", "test1") testCtr2 := getTestContainer("00000000000000000000000000000001", "test2") err = state.AddContainer(testCtr1) assert.NoError(t, err) err = state.AddContainer(testCtr2) assert.NoError(t, err) _, err = state.LookupContainer(testCtr1.ID()[0:8]) assert.Error(t, err) } func TestLookupContainerByName(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.AddContainer(testCtr) assert.NoError(t, err) retrievedCtr, err := state.LookupContainer(testCtr.Name()) 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) } } func TestHasContainerEmptyIDFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() _, err = state.HasContainer("") assert.Error(t, err) } func TestHasContainerNoSuchContainerReturnsFalse(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() exists, err := state.HasContainer("does not exist") assert.NoError(t, err) assert.False(t, exists) } func TestHasContainerFindsContainer(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.AddContainer(testCtr) assert.NoError(t, err) exists, err := state.HasContainer(testCtr.ID()) assert.NoError(t, err) assert.True(t, exists) } func TestSaveAndUpdateContainer(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.AddContainer(testCtr) 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() err = state.SaveContainer(retrievedCtr) 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) } } func TestUpdateContainerNotInDatabaseReturnsError(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.UpdateContainer(testCtr) assert.Error(t, err) assert.False(t, testCtr.valid) } func TestUpdateInvalidContainerReturnsError(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() err = state.UpdateContainer(&Container{}) assert.Error(t, err) } func TestSaveInvalidContainerReturnsError(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() err = state.SaveContainer(&Container{}) assert.Error(t, err) } func TestSaveContainerNotInStateReturnsError(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.SaveContainer(testCtr) assert.Error(t, err) } func TestRemoveContainer(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") 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 TestRemoveNonexistantContainerFails(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") err = state.RemoveContainer(testCtr) assert.Error(t, err) } func TestGetAllContainersOnNewStateIsEmpty(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() ctrs, err := state.AllContainers() assert.NoError(t, err) assert.Equal(t, 0, len(ctrs)) } func TestGetAllContainersWithOneContainer(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr := getTestContainer("0123456789ABCDEF0123456789ABCDEF", "test") 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]) } } func TestGetAllContainersTwoContainers(t *testing.T) { state, path, err := getEmptyState() assert.NoError(t, err) defer os.RemoveAll(path) defer state.Close() testCtr1 := getTestContainer("11111111111111111111111111111111", "test1") testCtr2 := getTestContainer("22222222222222222222222222222222", "test2") err = state.AddContainer(testCtr1) assert.NoError(t, err) err = state.AddContainer(testCtr2) assert.NoError(t, err) ctrs, err := state.AllContainers() assert.NoError(t, err) assert.Equal(t, 2, len(ctrs)) }