303 lines
8.5 KiB
Go
303 lines
8.5 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 isogen
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
api "opendev.org/airship/airshipctl/pkg/api/v1alpha1"
|
|
"opendev.org/airship/airshipctl/pkg/config"
|
|
"opendev.org/airship/airshipctl/pkg/document"
|
|
"opendev.org/airship/airshipctl/pkg/log"
|
|
"opendev.org/airship/airshipctl/testutil"
|
|
)
|
|
|
|
type mockContainer struct {
|
|
imagePull func() error
|
|
runCommand func() error
|
|
runCommandOutput func() (io.ReadCloser, error)
|
|
rmContainer func() error
|
|
getID func() string
|
|
}
|
|
|
|
func (mc *mockContainer) ImagePull() error {
|
|
return mc.imagePull()
|
|
}
|
|
|
|
func (mc *mockContainer) RunCommand([]string, io.Reader, []string, []string, bool) error {
|
|
return mc.runCommand()
|
|
}
|
|
|
|
func (mc *mockContainer) RunCommandOutput([]string, io.Reader, []string, []string) (io.ReadCloser, error) {
|
|
return mc.runCommandOutput()
|
|
}
|
|
|
|
func (mc *mockContainer) RmContainer() error {
|
|
return mc.rmContainer()
|
|
}
|
|
|
|
func (mc *mockContainer) GetID() string {
|
|
return mc.getID()
|
|
}
|
|
|
|
func TestBootstrapIso(t *testing.T) {
|
|
bundle, err := document.NewBundleByPath("testdata/primary/site/test-site/ephemeral/bootstrap")
|
|
require.NoError(t, err, "Building Bundle Failed")
|
|
|
|
tempVol, cleanup := testutil.TempDir(t, "bootstrap-test")
|
|
defer cleanup(t)
|
|
|
|
volBind := tempVol + ":/dst"
|
|
testErr := fmt.Errorf("TestErr")
|
|
testCfg := &api.ImageConfiguration{
|
|
Container: &api.Container{
|
|
Volume: volBind,
|
|
ContainerRuntime: "docker",
|
|
},
|
|
Builder: &api.Builder{
|
|
UserDataFileName: "user-data",
|
|
NetworkConfigFileName: "net-conf",
|
|
},
|
|
}
|
|
testDoc := &MockDocument{
|
|
MockAsYAML: func() ([]byte, error) { return []byte("TESTDOC"), nil },
|
|
}
|
|
testBuilder := &mockContainer{
|
|
runCommand: func() error { return nil },
|
|
getID: func() string { return "TESTID" },
|
|
rmContainer: func() error { return nil },
|
|
}
|
|
|
|
expOut := []string{
|
|
"Creating cloud-init for ephemeral K8s",
|
|
fmt.Sprintf("Running default container command. Mounted dir: [%s]", volBind),
|
|
"ISO successfully built.",
|
|
"Debug flag is set. Container TESTID stopped but not deleted.",
|
|
"Removing container.",
|
|
}
|
|
|
|
tests := []struct {
|
|
builder *mockContainer
|
|
cfg *api.ImageConfiguration
|
|
doc *MockDocument
|
|
debug bool
|
|
expectedOut []string
|
|
expectedErr error
|
|
}{
|
|
{
|
|
builder: &mockContainer{
|
|
runCommand: func() error { return testErr },
|
|
},
|
|
cfg: testCfg,
|
|
doc: testDoc,
|
|
debug: false,
|
|
expectedOut: []string{expOut[0], expOut[1]},
|
|
expectedErr: testErr,
|
|
},
|
|
{
|
|
builder: testBuilder,
|
|
cfg: testCfg,
|
|
doc: testDoc,
|
|
debug: true,
|
|
expectedOut: []string{expOut[0], expOut[1], expOut[2], expOut[3]},
|
|
expectedErr: nil,
|
|
},
|
|
{
|
|
builder: &mockContainer{
|
|
runCommand: func() error { return nil },
|
|
getID: func() string { return "TESTID" },
|
|
rmContainer: func() error { return testErr },
|
|
},
|
|
cfg: testCfg,
|
|
doc: testDoc,
|
|
debug: false,
|
|
expectedOut: []string{expOut[0], expOut[1], expOut[2], expOut[4]},
|
|
expectedErr: testErr,
|
|
},
|
|
{
|
|
builder: testBuilder,
|
|
cfg: testCfg,
|
|
doc: &MockDocument{
|
|
MockAsYAML: func() ([]byte, error) { return nil, testErr },
|
|
},
|
|
debug: false,
|
|
expectedOut: []string{expOut[0]},
|
|
expectedErr: testErr,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
outBuf := &bytes.Buffer{}
|
|
log.Init(tt.debug, outBuf)
|
|
actualErr := createBootstrapIso(bundle, tt.builder, tt.doc, tt.cfg, tt.debug)
|
|
actualOut := outBuf.String()
|
|
|
|
for _, line := range tt.expectedOut {
|
|
assert.True(t, strings.Contains(actualOut, line))
|
|
}
|
|
|
|
assert.Equal(t, tt.expectedErr, actualErr)
|
|
}
|
|
}
|
|
|
|
func TestVerifyInputs(t *testing.T) {
|
|
tempVol, cleanup := testutil.TempDir(t, "bootstrap-test")
|
|
defer cleanup(t)
|
|
|
|
tests := []struct {
|
|
name string
|
|
cfg *api.ImageConfiguration
|
|
args []string
|
|
expectedErr error
|
|
}{
|
|
{
|
|
name: "missing-container-field",
|
|
cfg: &api.ImageConfiguration{
|
|
Container: &api.Container{},
|
|
},
|
|
expectedErr: config.ErrMissingConfig{
|
|
What: "Must specify volume bind for ISO builder container",
|
|
},
|
|
},
|
|
{
|
|
name: "missing-filenames",
|
|
cfg: &api.ImageConfiguration{
|
|
Container: &api.Container{
|
|
Volume: tempVol + ":/dst",
|
|
},
|
|
Builder: &api.Builder{},
|
|
},
|
|
expectedErr: config.ErrMissingConfig{
|
|
What: "UserDataFileName or NetworkConfigFileName are not specified in ISO builder config",
|
|
},
|
|
},
|
|
{
|
|
name: "invalid-host-path",
|
|
cfg: &api.ImageConfiguration{
|
|
Container: &api.Container{
|
|
Volume: tempVol + ":/dst:/dst1",
|
|
},
|
|
Builder: &api.Builder{
|
|
UserDataFileName: "user-data",
|
|
NetworkConfigFileName: "net-conf",
|
|
},
|
|
},
|
|
expectedErr: config.ErrInvalidConfig{
|
|
What: "Bad container volume format. Use hostPath:contPath",
|
|
},
|
|
},
|
|
{
|
|
name: "success",
|
|
cfg: &api.ImageConfiguration{
|
|
Container: &api.Container{
|
|
Volume: tempVol,
|
|
},
|
|
Builder: &api.Builder{
|
|
UserDataFileName: "user-data",
|
|
NetworkConfigFileName: "net-conf",
|
|
},
|
|
},
|
|
expectedErr: nil,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(subTest *testing.T) {
|
|
actualErr := verifyInputs(tt.cfg)
|
|
assert.Equal(subTest, tt.expectedErr, actualErr)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenerateBootstrapIso(t *testing.T) {
|
|
airshipConfigPath := "testdata/config/config"
|
|
kubeConfigPath := "testdata/config/kubeconfig"
|
|
|
|
t.Run("EnsureCompleteError", func(t *testing.T) {
|
|
settings, err := config.CreateFactory(&airshipConfigPath, &kubeConfigPath)()
|
|
require.NoError(t, err)
|
|
expectedErr := config.ErrMissingConfig{What: "Context with name ''"}
|
|
settings.CurrentContext = ""
|
|
actualErr := GenerateBootstrapIso(func() (*config.Config, error) {
|
|
return settings, nil
|
|
})
|
|
assert.Equal(t, expectedErr, actualErr)
|
|
})
|
|
|
|
t.Run("ContextEntryPointError", func(t *testing.T) {
|
|
settings, err := config.CreateFactory(&airshipConfigPath, &kubeConfigPath)()
|
|
require.NoError(t, err)
|
|
expectedErr := config.ErrMissingPrimaryRepo{}
|
|
settings.Manifests["default"].Repositories = make(map[string]*config.Repository)
|
|
actualErr := GenerateBootstrapIso(func() (*config.Config, error) {
|
|
return settings, nil
|
|
})
|
|
assert.Equal(t, expectedErr, actualErr)
|
|
})
|
|
|
|
t.Run("NewBundleByPathError", func(t *testing.T) {
|
|
settings, err := config.CreateFactory(&airshipConfigPath, &kubeConfigPath)()
|
|
require.NoError(t, err)
|
|
expectedErr := config.ErrMissingPhaseDocument{PhaseName: "bootstrap"}
|
|
settings.Manifests["default"].TargetPath = "/nonexistent"
|
|
actualErr := GenerateBootstrapIso(func() (*config.Config, error) {
|
|
return settings, nil
|
|
})
|
|
assert.Equal(t, expectedErr, actualErr)
|
|
})
|
|
|
|
t.Run("SelectOneError", func(t *testing.T) {
|
|
settings, err := config.CreateFactory(&airshipConfigPath, &kubeConfigPath)()
|
|
require.NoError(t, err)
|
|
expectedErr := document.ErrDocNotFound{
|
|
Selector: document.NewSelector().ByGvk("airshipit.org", "v1alpha1", "ImageConfiguration")}
|
|
settings.Manifests["default"].SubPath = "missingkinddoc/site/test-site"
|
|
actualErr := GenerateBootstrapIso(func() (*config.Config, error) {
|
|
return settings, nil
|
|
})
|
|
assert.Equal(t, expectedErr, actualErr)
|
|
})
|
|
|
|
t.Run("ToObjectError", func(t *testing.T) {
|
|
settings, err := config.CreateFactory(&airshipConfigPath, &kubeConfigPath)()
|
|
require.NoError(t, err)
|
|
expectedErrMessage := "missing metadata.name in object"
|
|
settings.Manifests["default"].SubPath = "missingmetadoc/site/test-site"
|
|
actualErr := GenerateBootstrapIso(func() (*config.Config, error) {
|
|
return settings, nil
|
|
})
|
|
assert.Contains(t, actualErr.Error(), expectedErrMessage)
|
|
})
|
|
|
|
t.Run("verifyInputsError", func(t *testing.T) {
|
|
settings, err := config.CreateFactory(&airshipConfigPath, &kubeConfigPath)()
|
|
require.NoError(t, err)
|
|
expectedErr := config.ErrMissingConfig{What: "Must specify volume bind for ISO builder container"}
|
|
settings.Manifests["default"].SubPath = "missingvoldoc/site/test-site"
|
|
actualErr := GenerateBootstrapIso(func() (*config.Config, error) {
|
|
return settings, nil
|
|
})
|
|
assert.Equal(t, expectedErr, actualErr)
|
|
})
|
|
}
|