490 lines
14 KiB
Go
490 lines
14 KiB
Go
/*
|
|
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
|
|
|
|
https://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 executors_test
|
|
|
|
import (
|
|
"bytes"
|
|
goerrors "errors"
|
|
"fmt"
|
|
"io"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"opendev.org/airship/airshipctl/pkg/api/v1alpha1"
|
|
"opendev.org/airship/airshipctl/pkg/cluster/clustermap"
|
|
"opendev.org/airship/airshipctl/pkg/container"
|
|
"opendev.org/airship/airshipctl/pkg/document"
|
|
"opendev.org/airship/airshipctl/pkg/events"
|
|
"opendev.org/airship/airshipctl/pkg/k8s/kubeconfig"
|
|
"opendev.org/airship/airshipctl/pkg/phase/executors"
|
|
"opendev.org/airship/airshipctl/pkg/phase/executors/errors"
|
|
"opendev.org/airship/airshipctl/pkg/phase/ifc"
|
|
)
|
|
|
|
var (
|
|
executorConfigTmpl = `
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: Clusterctl
|
|
metadata:
|
|
name: clusterctl-v1
|
|
action: %s
|
|
init-options:
|
|
core-provider: "cluster-api:v0.3.2"
|
|
kubeConfigRef:
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: KubeConfig
|
|
name: sample-name
|
|
providers:
|
|
- name: "cluster-api"
|
|
type: "CoreProvider"
|
|
url: functions/capi/v0.3.2`
|
|
|
|
executorConfigTmplGood = `
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: Clusterctl
|
|
metadata:
|
|
name: clusterctl-v1
|
|
action: %s
|
|
init-options:
|
|
core-provider: "cluster-api:v0.3.2"
|
|
kubeConfigRef:
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: KubeConfig
|
|
name: sample-name
|
|
namespace: some-namespace
|
|
move-options:
|
|
namespace: some-namespace
|
|
providers:
|
|
- name: "cluster-api"
|
|
type: "CoreProvider"
|
|
url: functions/capi/v0.3.2`
|
|
|
|
renderedDocs = `---
|
|
apiVersion: v1
|
|
kind: Namespace
|
|
metadata:
|
|
labels:
|
|
control-plane: controller-manager
|
|
name: version-two
|
|
...
|
|
`
|
|
krmExecDoc = `---
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: GenericContainer
|
|
metadata:
|
|
name: clusterctl
|
|
labels:
|
|
airshipit.org/deploy-k8s: "false"
|
|
spec:
|
|
type: krm
|
|
image: localhost/clusterctl:latest
|
|
hostNetwork: true
|
|
`
|
|
)
|
|
|
|
func TestNewClusterctlExecutor(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
targetPath string
|
|
phaseCfgBundle document.Bundle
|
|
execDoc document.Document
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "invalid executor document",
|
|
execDoc: executorDoc(t, `
|
|
apiVersion: test.org/v1alpha1
|
|
kind: testkind
|
|
metadata:
|
|
name: testname
|
|
`),
|
|
errContains: "no kind \"testkind\" is registered for version \"test.org/v1alpha1\"",
|
|
},
|
|
{
|
|
name: "broken kustomize entrypoint",
|
|
targetPath: "/not/exist",
|
|
execDoc: executorDoc(t, `
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: Clusterctl
|
|
metadata:
|
|
name: clusterctl
|
|
providers:
|
|
- name: "cluster-api"
|
|
type: "CoreProvider"
|
|
url: functions/capi/v0.3.2"
|
|
`),
|
|
errContains: "no such file or directory",
|
|
},
|
|
{
|
|
name: "no metadata available",
|
|
targetPath: "./testdata",
|
|
execDoc: executorDoc(t, `
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: Clusterctl
|
|
metadata:
|
|
name: clusterctl
|
|
providers:
|
|
- name: "cluster-api"
|
|
type: "CoreProvider"
|
|
url: functions/capi/v0.3.2/no-metadata
|
|
`),
|
|
errContains: "document filtered by selector " +
|
|
"[Group=\"clusterctl.cluster.x-k8s.io\", Version=\"v1alpha3\", Kind=\"Metadata\"] found no documents",
|
|
},
|
|
{
|
|
name: "no container executor available",
|
|
targetPath: "./testdata",
|
|
phaseCfgBundle: executorBundle(t, ""),
|
|
execDoc: executorDoc(t, `
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: Clusterctl
|
|
metadata:
|
|
name: clusterctl
|
|
providers:
|
|
- name: "cluster-api"
|
|
type: "CoreProvider"
|
|
url: functions/capi/v0.3.2
|
|
`),
|
|
errContains: "document filtered by selector [Group=\"airshipit.org\", " +
|
|
"Version=\"v1alpha1\", Kind=\"GenericContainer\", Name=\"clusterctl\"] found no documents",
|
|
},
|
|
{
|
|
name: "successfully create executor",
|
|
targetPath: "./testdata",
|
|
phaseCfgBundle: executorBundle(t, krmExecDoc),
|
|
execDoc: executorDoc(t, `
|
|
apiVersion: airshipit.org/v1alpha1
|
|
kind: Clusterctl
|
|
metadata:
|
|
name: clusterctl
|
|
providers:
|
|
- name: "cluster-api"
|
|
type: "CoreProvider"
|
|
url: functions/capi/v0.3.2
|
|
`),
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
tt := test
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
executor, actualErr := executors.NewClusterctlExecutor(ifc.ExecutorConfig{
|
|
ExecutorDocument: tt.execDoc,
|
|
TargetPath: tt.targetPath,
|
|
PhaseConfigBundle: tt.phaseCfgBundle,
|
|
})
|
|
if tt.errContains != "" {
|
|
require.Nil(t, executor)
|
|
require.NotNil(t, actualErr)
|
|
require.Contains(t, actualErr.Error(), tt.errContains)
|
|
} else {
|
|
require.NoError(t, actualErr)
|
|
require.NotNil(t, executor)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
var _ clustermap.ClusterMap = &ClusterMapMockInterface{}
|
|
|
|
type ClusterMapMockInterface struct {
|
|
MockClusterKubeconfigContext func(string) (string, error)
|
|
MockParentCluster func(string) (string, error)
|
|
}
|
|
|
|
func (c ClusterMapMockInterface) ValidateClusterMap() error {
|
|
panic("implement me")
|
|
}
|
|
|
|
func (c ClusterMapMockInterface) ParentCluster(s string) (string, error) {
|
|
return c.MockParentCluster(s)
|
|
}
|
|
|
|
func (c ClusterMapMockInterface) AllClusters() []string {
|
|
panic("implement me")
|
|
}
|
|
|
|
func (c ClusterMapMockInterface) ClusterKubeconfigContext(s string) (string, error) {
|
|
return c.MockClusterKubeconfigContext(s)
|
|
}
|
|
|
|
func (c ClusterMapMockInterface) Sources(_ string) ([]v1alpha1.KubeconfigSource, error) {
|
|
panic("implement me")
|
|
}
|
|
|
|
func (c ClusterMapMockInterface) Write(_ io.Writer, _ clustermap.WriteOptions) error {
|
|
panic("implement me")
|
|
}
|
|
|
|
var _ container.ClientV1Alpha1 = &MockClientFuncInterface{}
|
|
|
|
type MockClientFuncInterface struct {
|
|
MockRun func() error
|
|
}
|
|
|
|
func (c MockClientFuncInterface) Run() error {
|
|
return c.MockRun()
|
|
}
|
|
|
|
func TestClusterctlExecutorRun(t *testing.T) {
|
|
errTmpFile := goerrors.New("TmpFile error")
|
|
errCtx := goerrors.New("context error")
|
|
errParent := goerrors.New("parent cluster error")
|
|
testCases := []struct {
|
|
name string
|
|
cfgDoc document.Document
|
|
kubecfg kubeconfig.Interface
|
|
expectedEvt []events.Event
|
|
clusterMap clustermap.ClusterMap
|
|
clientFunc container.ClientV1Alpha1FactoryFunc
|
|
}{
|
|
{
|
|
name: "Error unknown action",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "someAction")),
|
|
expectedEvt: []events.Event{
|
|
wrapError(errors.ErrUnknownExecutorAction{Action: "someAction", ExecutorName: "clusterctl"}),
|
|
},
|
|
clusterMap: clustermap.NewClusterMap(v1alpha1.DefaultClusterMap()),
|
|
},
|
|
{
|
|
name: "Failed get kubeconfig file - init",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "init")),
|
|
kubecfg: fakeKubeConfig{getFile: func() (string, kubeconfig.Cleanup, error) {
|
|
return "", nil, errTmpFile
|
|
}},
|
|
expectedEvt: []events.Event{
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlInitStart,
|
|
}),
|
|
wrapError(errTmpFile),
|
|
},
|
|
clusterMap: clustermap.NewClusterMap(v1alpha1.DefaultClusterMap()),
|
|
},
|
|
{
|
|
name: "Failed get kubeconfig file - move",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "move")),
|
|
kubecfg: fakeKubeConfig{getFile: func() (string, kubeconfig.Cleanup, error) {
|
|
return "", nil, errTmpFile
|
|
}},
|
|
expectedEvt: []events.Event{
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlMoveStart,
|
|
}),
|
|
wrapError(errTmpFile),
|
|
},
|
|
clusterMap: clustermap.NewClusterMap(v1alpha1.DefaultClusterMap()),
|
|
},
|
|
{
|
|
name: "Failed get kubeconfig context - init",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "init")),
|
|
kubecfg: fakeKubeConfig{getFile: func() (string, kubeconfig.Cleanup, error) {
|
|
return "", func() {}, nil
|
|
}},
|
|
expectedEvt: []events.Event{
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlInitStart,
|
|
}),
|
|
wrapError(errCtx),
|
|
},
|
|
clusterMap: ClusterMapMockInterface{MockClusterKubeconfigContext: func(s string) (string, error) {
|
|
return "", errCtx
|
|
}},
|
|
},
|
|
{
|
|
name: "Failed get kubeconfig context - move",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "move")),
|
|
kubecfg: fakeKubeConfig{getFile: func() (string, kubeconfig.Cleanup, error) {
|
|
return "", func() {}, nil
|
|
}},
|
|
expectedEvt: []events.Event{
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlMoveStart,
|
|
}),
|
|
wrapError(errCtx),
|
|
},
|
|
clusterMap: ClusterMapMockInterface{MockClusterKubeconfigContext: func(s string) (string, error) {
|
|
return "", errCtx
|
|
}},
|
|
},
|
|
{
|
|
name: "Failed get parent cluster",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "move")),
|
|
kubecfg: fakeKubeConfig{getFile: func() (string, kubeconfig.Cleanup, error) {
|
|
return "", func() {}, nil
|
|
}},
|
|
expectedEvt: []events.Event{
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlMoveStart,
|
|
}),
|
|
wrapError(errParent),
|
|
},
|
|
clusterMap: ClusterMapMockInterface{MockClusterKubeconfigContext: func(s string) (string, error) {
|
|
return "ctx", nil
|
|
},
|
|
MockParentCluster: func(s string) (string, error) {
|
|
return "", errParent
|
|
}},
|
|
},
|
|
{
|
|
name: "Regular Run init",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "init")),
|
|
kubecfg: fakeKubeConfig{getFile: func() (string, kubeconfig.Cleanup, error) {
|
|
return "", func() {}, nil
|
|
}},
|
|
clusterMap: ClusterMapMockInterface{MockClusterKubeconfigContext: func(s string) (string, error) {
|
|
return "cluster", nil
|
|
}},
|
|
clientFunc: func(_ string, _ io.Reader, _ io.Writer,
|
|
_ *v1alpha1.GenericContainer, _ string) container.ClientV1Alpha1 {
|
|
return MockClientFuncInterface{MockRun: func() error {
|
|
return nil
|
|
}}
|
|
},
|
|
expectedEvt: []events.Event{
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlInitStart,
|
|
}),
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlInitEnd,
|
|
}),
|
|
},
|
|
},
|
|
{
|
|
name: "Regular Run move",
|
|
cfgDoc: executorDoc(t, fmt.Sprintf(executorConfigTmplGood, "move")),
|
|
kubecfg: fakeKubeConfig{getFile: func() (string, kubeconfig.Cleanup, error) {
|
|
return "", func() {}, nil
|
|
}},
|
|
clusterMap: ClusterMapMockInterface{MockClusterKubeconfigContext: func(s string) (string, error) {
|
|
return "cluster", nil
|
|
},
|
|
MockParentCluster: func(s string) (string, error) {
|
|
return "parentCluster", nil
|
|
}},
|
|
clientFunc: func(_ string, _ io.Reader, _ io.Writer,
|
|
_ *v1alpha1.GenericContainer, _ string) container.ClientV1Alpha1 {
|
|
return MockClientFuncInterface{MockRun: func() error {
|
|
return nil
|
|
}}
|
|
},
|
|
expectedEvt: []events.Event{
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlMoveStart,
|
|
}),
|
|
events.NewEvent().WithClusterctlEvent(events.ClusterctlEvent{
|
|
Operation: events.ClusterctlMoveEnd,
|
|
}),
|
|
},
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
tt := test
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
executor, err := executors.NewClusterctlExecutor(
|
|
ifc.ExecutorConfig{
|
|
TargetPath: "testdata",
|
|
PhaseConfigBundle: executorBundle(t, krmExecDoc),
|
|
ExecutorDocument: tt.cfgDoc,
|
|
KubeConfig: tt.kubecfg,
|
|
ClusterMap: tt.clusterMap,
|
|
ContainerFunc: tt.clientFunc,
|
|
})
|
|
require.NoError(t, err)
|
|
ch := make(chan events.Event)
|
|
go executor.Run(ch, ifc.RunOptions{DryRun: true})
|
|
var actualEvt []events.Event
|
|
for evt := range ch {
|
|
// Skip timestamp for comparison
|
|
evt.Timestamp = time.Time{}
|
|
if evt.Type == events.ClusterctlType {
|
|
// Set message to empty string, so it's not compared
|
|
evt.ClusterctlEvent.Message = ""
|
|
}
|
|
actualEvt = append(actualEvt, evt)
|
|
}
|
|
for i := range tt.expectedEvt {
|
|
// Skip timestamp for comparison
|
|
tt.expectedEvt[i].Timestamp = time.Time{}
|
|
}
|
|
assert.Equal(t, tt.expectedEvt, actualEvt)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClusterctlExecutorValidate(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
actionType string
|
|
bundlePath string
|
|
executorConfigTmpl string
|
|
expectedErrString string
|
|
}{
|
|
{
|
|
name: "Success init action",
|
|
actionType: "init",
|
|
executorConfigTmpl: executorConfigTmplGood,
|
|
},
|
|
{
|
|
name: "Error any other action",
|
|
actionType: "any",
|
|
executorConfigTmpl: executorConfigTmplGood,
|
|
expectedErrString: "unknown action type 'any'",
|
|
},
|
|
{
|
|
name: "Error empty action",
|
|
actionType: "",
|
|
executorConfigTmpl: executorConfigTmplGood,
|
|
expectedErrString: "invalid phase: ClusterctlExecutor.Action is empty",
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
tt := test
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
sampleCfgDoc := executorDoc(t, fmt.Sprintf(test.executorConfigTmpl, test.actionType))
|
|
executor, err := executors.NewClusterctlExecutor(
|
|
ifc.ExecutorConfig{
|
|
TargetPath: "testdata",
|
|
ExecutorDocument: sampleCfgDoc,
|
|
PhaseConfigBundle: executorBundle(t, krmExecDoc),
|
|
})
|
|
require.NoError(t, err)
|
|
err = executor.Validate()
|
|
if test.expectedErrString != "" {
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), test.expectedErrString)
|
|
} else {
|
|
require.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClusterctlExecutorRender(t *testing.T) {
|
|
sampleCfgDoc := executorDoc(t, fmt.Sprintf(executorConfigTmpl, "init"))
|
|
executor, err := executors.NewClusterctlExecutor(
|
|
ifc.ExecutorConfig{
|
|
TargetPath: "testdata",
|
|
ExecutorDocument: sampleCfgDoc,
|
|
PhaseConfigBundle: executorBundle(t, krmExecDoc),
|
|
})
|
|
require.NoError(t, err)
|
|
actualOut := &bytes.Buffer{}
|
|
actualErr := executor.Render(actualOut, ifc.RenderOptions{})
|
|
assert.Equal(t, renderedDocs, actualOut.String())
|
|
assert.NoError(t, actualErr)
|
|
}
|