mirror of
https://github.com/kata-containers/kata-containers.git
synced 2025-10-22 04:18:53 +00:00
be72b6bd31
Some virtcontainers pieces of code are importing virtcontainers packages. We need to change those paths to point at kata-containers/runtime/virtcontainers Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
580 lines
13 KiB
Go
580 lines
13 KiB
Go
// 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))
|
|
}
|