filesystem_test.go

//
// Copyright (c) 2016 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

package virtcontainers

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"reflect"
	"testing"
)

func TestFilesystemCreateAllResourcesSuccessful(t *testing.T) {
	fs := &filesystem{}

	contConfigs := []ContainerConfig{
		{ID: "1"},
		{ID: "10"},
		{ID: "100"},
	}

	pod := Pod{
		id:      testPodID,
		storage: fs,
	}

	containers, err := createContainers(&pod, contConfigs)
	if err != nil {
		t.Fatal(err)
	}

	pod.containers = containers

	podConfigPath := filepath.Join(configStoragePath, testPodID)
	podRunPath := filepath.Join(runStoragePath, testPodID)

	os.RemoveAll(podConfigPath)
	os.RemoveAll(podRunPath)

	for _, container := range contConfigs {
		configPath := filepath.Join(configStoragePath, testPodID, container.ID)
		os.RemoveAll(configPath)

		runPath := filepath.Join(runStoragePath, testPodID, container.ID)
		os.RemoveAll(runPath)
	}

	err = fs.createAllResources(pod)
	if err != nil {
		t.Fatal(err)
	}

	// Check resources
	_, err = os.Stat(podConfigPath)
	if err != nil {
		t.Fatal(err)
	}

	_, err = os.Stat(podRunPath)
	if err != nil {
		t.Fatal(err)
	}

	for _, container := range contConfigs {
		configPath := filepath.Join(configStoragePath, testPodID, container.ID)
		_, err = os.Stat(configPath)
		if err != nil {
			t.Fatal(err)
		}

		runPath := filepath.Join(runStoragePath, testPodID, container.ID)
		_, err = os.Stat(runPath)
		if err != nil {
			t.Fatal(err)
		}
	}
}

func TestFilesystemCreateAllResourcesFailingPodIDEmpty(t *testing.T) {
	fs := &filesystem{}

	pod := Pod{}

	err := fs.createAllResources(pod)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemCreateAllResourcesFailingContainerIDEmpty(t *testing.T) {
	fs := &filesystem{}

	containers := []*Container{
		{id: ""},
	}

	pod := Pod{
		id:         testPodID,
		containers: containers,
	}

	err := fs.createAllResources(pod)
	if err == nil {
		t.Fatal()
	}
}

type TestNoopStructure struct {
	Field1 string
	Field2 string
}

func TestFilesystemStoreFileSuccessfulNotExisting(t *testing.T) {
	fs := &filesystem{}

	path := filepath.Join(testDir, "testFilesystem")
	os.Remove(path)

	data := TestNoopStructure{
		Field1: "value1",
		Field2: "value2",
	}

	expected := "{\"Field1\":\"value1\",\"Field2\":\"value2\"}"

	err := fs.storeFile(path, data)
	if err != nil {
		t.Fatal(err)
	}

	fileData, err := ioutil.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}

	if string(fileData) != expected {
		t.Fatal()
	}
}

func TestFilesystemStoreFileSuccessfulExisting(t *testing.T) {
	fs := &filesystem{}

	path := filepath.Join(testDir, "testFilesystem")
	os.Remove(path)

	f, err := os.Create(path)
	if err != nil {
		t.Fatal(err)
	}
	f.Close()

	data := TestNoopStructure{
		Field1: "value1",
		Field2: "value2",
	}

	expected := "{\"Field1\":\"value1\",\"Field2\":\"value2\"}"

	err = fs.storeFile(path, data)
	if err != nil {
		t.Fatal(err)
	}

	fileData, err := ioutil.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}

	if string(fileData) != expected {
		t.Fatal()
	}
}

func TestFilesystemStoreFileFailingMarshalling(t *testing.T) {
	fs := &filesystem{}

	path := filepath.Join(testDir, "testFilesystem")
	os.Remove(path)

	data := make(chan bool)

	err := fs.storeFile(path, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemFetchFileSuccessful(t *testing.T) {
	fs := &filesystem{}
	data := TestNoopStructure{}

	path := filepath.Join(testDir, "testFilesystem")
	os.Remove(path)

	f, err := os.Create(path)
	if err != nil {
		t.Fatal(err)
	}

	dataToWrite := "{\"Field1\":\"value1\",\"Field2\":\"value2\"}"
	n, err := f.WriteString(dataToWrite)
	if err != nil || n != len(dataToWrite) {
		f.Close()
		t.Fatal(err)
	}
	f.Close()

	err = fs.fetchFile(path, &data)
	if err != nil {
		t.Fatal(err)
	}

	expected := TestNoopStructure{
		Field1: "value1",
		Field2: "value2",
	}

	if reflect.DeepEqual(data, expected) == false {
		t.Fatal()
	}
}

func TestFilesystemFetchFileFailingNoFile(t *testing.T) {
	fs := &filesystem{}
	data := TestNoopStructure{}

	path := filepath.Join(testDir, "testFilesystem")
	os.Remove(path)

	err := fs.fetchFile(path, &data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemFetchFileFailingUnMarshalling(t *testing.T) {
	fs := &filesystem{}
	data := TestNoopStructure{}

	path := filepath.Join(testDir, "testFilesystem")
	os.Remove(path)

	f, err := os.Create(path)
	if err != nil {
		t.Fatal(err)
	}
	f.Close()

	err = fs.fetchFile(path, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemFetchContainerConfigSuccessful(t *testing.T) {
	fs := &filesystem{}
	contID := "100"
	rootFs := "rootfs"

	contConfigDir := filepath.Join(configStoragePath, testPodID, contID)
	os.MkdirAll(contConfigDir, dirMode)

	path := filepath.Join(contConfigDir, configFile)
	os.Remove(path)

	f, err := os.Create(path)
	if err != nil {
		t.Fatal(err)
	}

	configData := fmt.Sprintf("{\"ID\":\"%s\",\"RootFs\":\"%s\"}", contID, rootFs)
	n, err := f.WriteString(configData)
	if err != nil || n != len(configData) {
		f.Close()
		t.Fatal(err)
	}
	f.Close()

	data, err := fs.fetchContainerConfig(testPodID, contID)
	if err != nil {
		t.Fatal(err)
	}

	expected := ContainerConfig{
		ID:     contID,
		RootFs: rootFs,
	}

	if reflect.DeepEqual(data, expected) == false {
		t.Fatal()
	}
}

func TestFilesystemFetchContainerConfigFailingContIDEmpty(t *testing.T) {
	fs := &filesystem{}

	_, err := fs.fetchContainerConfig(testPodID, "")
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemFetchContainerConfigFailingPodIDEmpty(t *testing.T) {
	fs := &filesystem{}

	_, err := fs.fetchContainerConfig("", "100")
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemResourceDirFailingPodIDEmpty(t *testing.T) {
	_, err := resourceDir("", "", configFileType)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemResourceDirFailingInvalidResource(t *testing.T) {
	_, err := resourceDir(testPodID, "100", podResource(-1))
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemResourceURIFailingResourceDir(t *testing.T) {
	fs := &filesystem{}

	_, _, err := fs.resourceURI(testPodID, "100", podResource(-1))
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemStoreResourceFailingPodConfigStateFileType(t *testing.T) {
	fs := &filesystem{}
	data := PodConfig{}

	err := fs.storeResource(testPodID, "100", stateFileType, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemStoreResourceFailingContainerConfigStateFileType(t *testing.T) {
	fs := &filesystem{}
	data := ContainerConfig{}

	err := fs.storeResource(testPodID, "100", stateFileType, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemStoreResourceFailingPodConfigResourceURI(t *testing.T) {
	fs := &filesystem{}
	data := PodConfig{}

	err := fs.storeResource("", "100", configFileType, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemStoreResourceFailingContainerConfigResourceURI(t *testing.T) {
	fs := &filesystem{}
	data := ContainerConfig{}

	err := fs.storeResource("", "100", configFileType, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemStoreResourceFailingStateConfigFileType(t *testing.T) {
	fs := &filesystem{}
	data := State{}

	err := fs.storeResource(testPodID, "100", configFileType, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemStoreResourceFailingStateResourceURI(t *testing.T) {
	fs := &filesystem{}
	data := State{}

	err := fs.storeResource("", "100", stateFileType, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemStoreResourceFailingWrongDataType(t *testing.T) {
	fs := &filesystem{}
	data := TestNoopStructure{}

	err := fs.storeResource(testPodID, "100", configFileType, data)
	if err == nil {
		t.Fatal()
	}
}

func TestFilesystemFetchResourceFailingWrongResourceType(t *testing.T) {
	fs := &filesystem{}

	_, err := fs.fetchResource(testPodID, "100", lockFileType)
	if err == nil {
		t.Fatal()
	}
}