lint: Rename vcMock to vcmock

As recommended by `golint`, renamed the `vcMock` package to `vcmock`.

Signed-off-by: James O. D. Hunt <james.o.hunt@intel.com>

virtcontainers/pkg/vcmock/mock_test.go

@@ -0,0 +1,579 @@
+// Copyright (c) 2017 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 vcmock
+
+import (
+	"reflect"
+	"syscall"
+	"testing"
+
+	vc "github.com/kata-containers/runtime/virtcontainers"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	testPodID       = "testPodID"
+	testContainerID = "testContainerID"
+)
+
+var loggerTriggered = 0
+
+func TestVCImplementations(t *testing.T) {
+	// official implementation
+	mainImpl := &vc.VCImpl{}
+
+	// test implementation
+	testImpl := &VCMock{}
+
+	var interfaceType vc.VC
+
+	// check that the official implementation implements the
+	// interface
+	mainImplType := reflect.TypeOf(mainImpl)
+	mainImplementsIF := mainImplType.Implements(reflect.TypeOf(&interfaceType).Elem())
+	assert.True(t, mainImplementsIF)
+
+	// check that the test implementation implements the
+	// interface
+	testImplType := reflect.TypeOf(testImpl)
+	testImplementsIF := testImplType.Implements(reflect.TypeOf(&interfaceType).Elem())
+	assert.True(t, testImplementsIF)
+}
+
+func TestVCPodImplementations(t *testing.T) {
+	// official implementation
+	mainImpl := &vc.Pod{}
+
+	// test implementation
+	testImpl := &Pod{}
+
+	var interfaceType vc.VCPod
+
+	// check that the official implementation implements the
+	// interface
+	mainImplType := reflect.TypeOf(mainImpl)
+	mainImplementsIF := mainImplType.Implements(reflect.TypeOf(&interfaceType).Elem())
+	assert.True(t, mainImplementsIF)
+
+	// check that the test implementation implements the
+	// interface
+	testImplType := reflect.TypeOf(testImpl)
+	testImplementsIF := testImplType.Implements(reflect.TypeOf(&interfaceType).Elem())
+	assert.True(t, testImplementsIF)
+}
+
+func TestVCContainerImplementations(t *testing.T) {
+	// official implementation
+	mainImpl := &vc.Container{}
+
+	// test implementation
+	testImpl := &Container{}
+
+	var interfaceType vc.VCContainer
+
+	// check that the official implementation implements the
+	// interface
+	mainImplType := reflect.TypeOf(mainImpl)
+	mainImplementsIF := mainImplType.Implements(reflect.TypeOf(&interfaceType).Elem())
+	assert.True(t, mainImplementsIF)
+
+	// check that the test implementation implements the
+	// interface
+	testImplType := reflect.TypeOf(testImpl)
+	testImplementsIF := testImplType.Implements(reflect.TypeOf(&interfaceType).Elem())
+	assert.True(t, testImplementsIF)
+}
+
+func TestVCMockSetLogger(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.SetLoggerFunc)
+
+	logger := logrus.New()
+
+	assert.Equal(loggerTriggered, 0)
+	m.SetLogger(logger)
+	assert.Equal(loggerTriggered, 0)
+
+	m.SetLoggerFunc = func(logger logrus.FieldLogger) {
+		loggerTriggered = 1
+	}
+
+	m.SetLogger(logger)
+	assert.Equal(loggerTriggered, 1)
+}
+
+func TestVCMockCreatePod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.CreatePodFunc)
+
+	_, err := m.CreatePod(vc.PodConfig{})
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.CreatePodFunc = func(podConfig vc.PodConfig) (vc.VCPod, error) {
+		return &Pod{}, nil
+	}
+
+	pod, err := m.CreatePod(vc.PodConfig{})
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+
+	// reset
+	m.CreatePodFunc = nil
+
+	_, err = m.CreatePod(vc.PodConfig{})
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockDeletePod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.DeletePodFunc)
+
+	_, err := m.DeletePod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.DeletePodFunc = func(podID string) (vc.VCPod, error) {
+		return &Pod{}, nil
+	}
+
+	pod, err := m.DeletePod(testPodID)
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+
+	// reset
+	m.DeletePodFunc = nil
+
+	_, err = m.DeletePod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockListPod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.ListPodFunc)
+
+	_, err := m.ListPod()
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.ListPodFunc = func() ([]vc.PodStatus, error) {
+		return []vc.PodStatus{}, nil
+	}
+
+	pods, err := m.ListPod()
+	assert.NoError(err)
+	assert.Equal(pods, []vc.PodStatus{})
+
+	// reset
+	m.ListPodFunc = nil
+
+	_, err = m.ListPod()
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockPausePod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.PausePodFunc)
+
+	_, err := m.PausePod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.PausePodFunc = func(podID string) (vc.VCPod, error) {
+		return &Pod{}, nil
+	}
+
+	pod, err := m.PausePod(testPodID)
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+
+	// reset
+	m.PausePodFunc = nil
+
+	_, err = m.PausePod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockResumePod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.ResumePodFunc)
+
+	_, err := m.ResumePod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.ResumePodFunc = func(podID string) (vc.VCPod, error) {
+		return &Pod{}, nil
+	}
+
+	pod, err := m.ResumePod(testPodID)
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+
+	// reset
+	m.ResumePodFunc = nil
+
+	_, err = m.ResumePod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockRunPod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.RunPodFunc)
+
+	_, err := m.RunPod(vc.PodConfig{})
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.RunPodFunc = func(podConfig vc.PodConfig) (vc.VCPod, error) {
+		return &Pod{}, nil
+	}
+
+	pod, err := m.RunPod(vc.PodConfig{})
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+
+	// reset
+	m.RunPodFunc = nil
+
+	_, err = m.RunPod(vc.PodConfig{})
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockStartPod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.StartPodFunc)
+
+	_, err := m.StartPod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.StartPodFunc = func(podID string) (vc.VCPod, error) {
+		return &Pod{}, nil
+	}
+
+	pod, err := m.StartPod(testPodID)
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+
+	// reset
+	m.StartPodFunc = nil
+
+	_, err = m.StartPod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockStatusPod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.StatusPodFunc)
+
+	_, err := m.StatusPod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.StatusPodFunc = func(podID string) (vc.PodStatus, error) {
+		return vc.PodStatus{}, nil
+	}
+
+	pod, err := m.StatusPod(testPodID)
+	assert.NoError(err)
+	assert.Equal(pod, vc.PodStatus{})
+
+	// reset
+	m.StatusPodFunc = nil
+
+	_, err = m.StatusPod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockStopPod(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.StopPodFunc)
+
+	_, err := m.StopPod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.StopPodFunc = func(podID string) (vc.VCPod, error) {
+		return &Pod{}, nil
+	}
+
+	pod, err := m.StopPod(testPodID)
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+
+	// reset
+	m.StopPodFunc = nil
+
+	_, err = m.StopPod(testPodID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockCreateContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.CreateContainerFunc)
+
+	config := vc.ContainerConfig{}
+	_, _, err := m.CreateContainer(testPodID, config)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.CreateContainerFunc = func(podID string, containerConfig vc.ContainerConfig) (vc.VCPod, vc.VCContainer, error) {
+		return &Pod{}, &Container{}, nil
+	}
+
+	pod, container, err := m.CreateContainer(testPodID, config)
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+	assert.Equal(container, &Container{})
+
+	// reset
+	m.CreateContainerFunc = nil
+
+	_, _, err = m.CreateContainer(testPodID, config)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockDeleteContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.DeleteContainerFunc)
+
+	_, err := m.DeleteContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.DeleteContainerFunc = func(podID, containerID string) (vc.VCContainer, error) {
+		return &Container{}, nil
+	}
+
+	container, err := m.DeleteContainer(testPodID, testContainerID)
+	assert.NoError(err)
+	assert.Equal(container, &Container{})
+
+	// reset
+	m.DeleteContainerFunc = nil
+
+	_, err = m.DeleteContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockEnterContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.EnterContainerFunc)
+
+	cmd := vc.Cmd{}
+	_, _, _, err := m.EnterContainer(testPodID, testContainerID, cmd)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.EnterContainerFunc = func(podID, containerID string, cmd vc.Cmd) (vc.VCPod, vc.VCContainer, *vc.Process, error) {
+		return &Pod{}, &Container{}, &vc.Process{}, nil
+	}
+
+	pod, container, process, err := m.EnterContainer(testPodID, testContainerID, cmd)
+	assert.NoError(err)
+	assert.Equal(pod, &Pod{})
+	assert.Equal(container, &Container{})
+	assert.Equal(process, &vc.Process{})
+
+	// reset
+	m.EnterContainerFunc = nil
+
+	_, _, _, err = m.EnterContainer(testPodID, testContainerID, cmd)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockKillContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.KillContainerFunc)
+
+	sig := syscall.SIGTERM
+
+	for _, all := range []bool{true, false} {
+		err := m.KillContainer(testPodID, testContainerID, sig, all)
+		assert.Error(err)
+		assert.True(IsMockError(err))
+	}
+
+	m.KillContainerFunc = func(podID, containerID string, signal syscall.Signal, all bool) error {
+		return nil
+	}
+
+	for _, all := range []bool{true, false} {
+		err := m.KillContainer(testPodID, testContainerID, sig, all)
+		assert.NoError(err)
+	}
+
+	// reset
+	m.KillContainerFunc = nil
+
+	for _, all := range []bool{true, false} {
+		err := m.KillContainer(testPodID, testContainerID, sig, all)
+		assert.Error(err)
+		assert.True(IsMockError(err))
+	}
+}
+
+func TestVCMockStartContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.StartContainerFunc)
+
+	_, err := m.StartContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.StartContainerFunc = func(podID, containerID string) (vc.VCContainer, error) {
+		return &Container{}, nil
+	}
+
+	container, err := m.StartContainer(testPodID, testContainerID)
+	assert.NoError(err)
+	assert.Equal(container, &Container{})
+
+	// reset
+	m.StartContainerFunc = nil
+
+	_, err = m.StartContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockStatusContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.StatusContainerFunc)
+
+	_, err := m.StatusContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.StatusContainerFunc = func(podID, containerID string) (vc.ContainerStatus, error) {
+		return vc.ContainerStatus{}, nil
+	}
+
+	status, err := m.StatusContainer(testPodID, testContainerID)
+	assert.NoError(err)
+	assert.Equal(status, vc.ContainerStatus{})
+
+	// reset
+	m.StatusContainerFunc = nil
+
+	_, err = m.StatusContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockStopContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.StopContainerFunc)
+
+	_, err := m.StopContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	m.StopContainerFunc = func(podID, containerID string) (vc.VCContainer, error) {
+		return &Container{}, nil
+	}
+
+	container, err := m.StopContainer(testPodID, testContainerID)
+	assert.NoError(err)
+	assert.Equal(container, &Container{})
+
+	// reset
+	m.StopContainerFunc = nil
+
+	_, err = m.StopContainer(testPodID, testContainerID)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}
+
+func TestVCMockProcessListContainer(t *testing.T) {
+	assert := assert.New(t)
+
+	m := &VCMock{}
+	assert.Nil(m.ProcessListContainerFunc)
+
+	options := vc.ProcessListOptions{
+		Format: "json",
+		Args:   []string{"-ef"},
+	}
+
+	_, err := m.ProcessListContainer(testPodID, testContainerID, options)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+
+	processList := vc.ProcessList("hi")
+
+	m.ProcessListContainerFunc = func(podID, containerID string, options vc.ProcessListOptions) (vc.ProcessList, error) {
+		return processList, nil
+	}
+
+	pList, err := m.ProcessListContainer(testPodID, testContainerID, options)
+	assert.NoError(err)
+	assert.Equal(pList, processList)
+
+	// reset
+	m.ProcessListContainerFunc = nil
+
+	_, err = m.ProcessListContainer(testPodID, testContainerID, options)
+	assert.Error(err)
+	assert.True(IsMockError(err))
+}