From c237347a175bccc9705abff967590794c6073833 Mon Sep 17 00:00:00 2001 From: Aleksey Dukhovniy Date: Thu, 15 Oct 2020 14:00:56 +0200 Subject: [PATCH] Local and relative dependencies are now relative to their operators (#1709) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Summary: Previously the location of a dependency operator was always relative to the caller working director (the directory of the `kudo install ...` call). This made installing and testing operators with dependencies a brittle process as the working directory has to be set accordingly. This PR fixes this for *local operators in directories:* so with an operator structure like this: ``` . ├── child │ └── operator.yaml │ └── parent └── operator.yaml ``` child operator now has to be referenced like: ``` - name: child kind: KudoOperator spec: package: "../child" ``` *Note:* This fix does not apply to tarballs as the tarball reader does not expect any dependency operators' files/folders. Signed-off-by: Aleksey Dukhovniy --- .../instance/instance_controller.go | 2 +- pkg/kudoctl/cmd/install/install.go | 8 ++- pkg/kudoctl/cmd/upgrade.go | 10 ++- pkg/kudoctl/packages/install/package.go | 6 +- pkg/kudoctl/resources/dependencies/resolve.go | 64 +++++++++++++++--- .../resources/dependencies/resolve_test.go | 66 ++++++++++++++++++- .../child-operator/operator.yaml | 25 +++++++ .../child-operator/params.yaml | 6 ++ .../parent-operator/operator.yaml | 25 +++++++ .../parent-operator/params.yaml | 6 ++ pkg/kudoctl/resources/install/operator.go | 12 +--- .../resources/upgrade/operatorversion.go | 6 +- .../resources/upgrade/operatorversion_test.go | 18 ++--- .../parent-operator/operator.yaml | 2 +- .../operator-2.0/operator.yaml | 2 +- 15 files changed, 215 insertions(+), 43 deletions(-) create mode 100644 pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/operator.yaml create mode 100644 pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/params.yaml create mode 100644 pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/operator.yaml create mode 100644 pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/params.yaml diff --git a/pkg/controller/instance/instance_controller.go b/pkg/controller/instance/instance_controller.go index fd8385f64..9bbfa6be0 100644 --- a/pkg/controller/instance/instance_controller.go +++ b/pkg/controller/instance/instance_controller.go @@ -329,7 +329,7 @@ func (r *Reconciler) resolveDependencies(i *kudoapi.Instance, ov *kudoapi.Operat } resolver := &InClusterResolver{ns: ov.Namespace, c: r.Client} - _, err := dependencies.Resolve(ov, resolver) + _, err := dependencies.Resolve(ov.Name, ov, resolver) if err != nil { return engine.ExecutionError{Err: fmt.Errorf("%w%v", engine.ErrFatalExecution, err), EventName: "CircularDependency"} } diff --git a/pkg/kudoctl/cmd/install/install.go b/pkg/kudoctl/cmd/install/install.go index aea5cde46..d12b94a81 100644 --- a/pkg/kudoctl/cmd/install/install.go +++ b/pkg/kudoctl/cmd/install/install.go @@ -10,6 +10,7 @@ import ( "github.com/kudobuilder/kudo/pkg/kudoctl/env" "github.com/kudobuilder/kudo/pkg/kudoctl/packages/install" pkgresolver "github.com/kudobuilder/kudo/pkg/kudoctl/packages/resolver" + deps "github.com/kudobuilder/kudo/pkg/kudoctl/resources/dependencies" "github.com/kudobuilder/kudo/pkg/kudoctl/util/repo" ) @@ -91,6 +92,11 @@ func installOperator(operatorArgument string, options *Options, fs afero.Fs, set return fmt.Errorf("failed to resolve operator package for: %s %w", operatorArgument, err) } + dependencies, err := deps.Resolve(operatorArgument, pkg.Resources.OperatorVersion, resolver) + if err != nil { + return err + } + installOpts := install.Options{ SkipInstance: options.SkipInstance, CreateNamespace: options.CreateNameSpace, @@ -107,6 +113,6 @@ func installOperator(operatorArgument string, options *Options, fs afero.Fs, set settings.Namespace, *pkg.Resources, options.Parameters, - resolver, + dependencies, installOpts) } diff --git a/pkg/kudoctl/cmd/upgrade.go b/pkg/kudoctl/cmd/upgrade.go index 3fdef4d93..1b892c231 100644 --- a/pkg/kudoctl/cmd/upgrade.go +++ b/pkg/kudoctl/cmd/upgrade.go @@ -11,6 +11,7 @@ import ( "github.com/kudobuilder/kudo/pkg/kudoctl/cmd/params" "github.com/kudobuilder/kudo/pkg/kudoctl/env" pkgresolver "github.com/kudobuilder/kudo/pkg/kudoctl/packages/resolver" + deps "github.com/kudobuilder/kudo/pkg/kudoctl/resources/dependencies" "github.com/kudobuilder/kudo/pkg/kudoctl/resources/upgrade" "github.com/kudobuilder/kudo/pkg/kudoctl/util/repo" ) @@ -101,6 +102,7 @@ func runUpgrade(args []string, options *options, fs afero.Fs, settings *env.Sett if err != nil { return fmt.Errorf("could not build operator repository: %w", err) } + resolver := pkgresolver.New(repository) pkg, err := resolver.Resolve(packageToUpgrade, options.AppVersion, options.OperatorVersion) if err != nil { @@ -108,8 +110,12 @@ func runUpgrade(args []string, options *options, fs afero.Fs, settings *env.Sett } resources := pkg.Resources - resources.OperatorVersion.SetNamespace(settings.Namespace) - return upgrade.OperatorVersion(kc, resources.OperatorVersion, options.InstanceName, options.Parameters, resolver) + dependencies, err := deps.Resolve(packageToUpgrade, resources.OperatorVersion, resolver) + if err != nil { + return err + } + + return upgrade.OperatorVersion(kc, resources.OperatorVersion, options.InstanceName, options.Parameters, dependencies) } diff --git a/pkg/kudoctl/packages/install/package.go b/pkg/kudoctl/packages/install/package.go index eea40f8c0..0d078ea60 100644 --- a/pkg/kudoctl/packages/install/package.go +++ b/pkg/kudoctl/packages/install/package.go @@ -7,7 +7,7 @@ import ( kudoapi "github.com/kudobuilder/kudo/pkg/apis/kudo/v1beta1" "github.com/kudobuilder/kudo/pkg/kudoctl/clog" "github.com/kudobuilder/kudo/pkg/kudoctl/packages" - "github.com/kudobuilder/kudo/pkg/kudoctl/packages/resolver" + deps "github.com/kudobuilder/kudo/pkg/kudoctl/resources/dependencies" "github.com/kudobuilder/kudo/pkg/kudoctl/resources/install" "github.com/kudobuilder/kudo/pkg/kudoctl/util/kudo" ) @@ -34,7 +34,7 @@ func Package( namespace string, resources packages.Resources, parameters map[string]string, - resolver resolver.Resolver, + dependencies []deps.Dependency, options Options) error { clog.V(3).Printf( "Preparing %s/%s:%s for installation", @@ -65,7 +65,7 @@ func Package( } if err := install.OperatorAndOperatorVersion( - client, resources.Operator, resources.OperatorVersion, resolver); err != nil { + client, resources.Operator, resources.OperatorVersion, dependencies); err != nil { return err } diff --git a/pkg/kudoctl/resources/dependencies/resolve.go b/pkg/kudoctl/resources/dependencies/resolve.go index cfdc4d899..d639bdb8b 100644 --- a/pkg/kudoctl/resources/dependencies/resolve.go +++ b/pkg/kudoctl/resources/dependencies/resolve.go @@ -2,7 +2,10 @@ package dependencies import ( "fmt" + "path/filepath" + "strings" + "github.com/spf13/afero" "github.com/thoas/go-funk" "github.com/yourbasic/graph" @@ -49,10 +52,13 @@ type Dependency struct { PackageName string } -// Resolve resolves all dependencies of an OperatorVersion. -// Dependencies are resolved recursively. -// Cyclic dependencies are detected and result in an error. -func Resolve(operatorVersion *kudoapi.OperatorVersion, resolver pkgresolver.Resolver) ([]Dependency, error) { +// Resolve resolves all dependencies of an OperatorVersion. Dependencies are resolved recursively. +// Cyclic dependencies are detected and result in an error. operatorArgument parameter is string that +// the user passed to install/upgrade an operator which is used to determine whether this is a local +// operator in a directory. In that case all its relative dependencies (if any exist) will be relative +// to the operator directory (the one with `operator.yaml` file). +// See github.com/kudobuilder/kudo/issues/1701 for additional context. +func Resolve(operatorArgument string, operatorVersion *kudoapi.OperatorVersion, resolver pkgresolver.Resolver) ([]Dependency, error) { root := packages.Resources{ OperatorVersion: operatorVersion, } @@ -66,7 +72,10 @@ func Resolve(operatorVersion *kudoapi.OperatorVersion, resolver pkgresolver.Reso edges: []map[int]struct{}{{}}, } - if err := dependencyWalk(&dependencies, &g, root, 0, resolver); err != nil { + // Here we only care whether the path is absolute or not so we can ignore the error + operatorDir, _ := operatorAbsPath(operatorArgument) + + if err := dependencyWalk(&dependencies, &g, root, 0, resolver, operatorDir); err != nil { return nil, err } @@ -79,15 +88,34 @@ func dependencyWalk( g *dependencyGraph, parent packages.Resources, parentIndex int, - resolver pkgresolver.Resolver) error { + resolver pkgresolver.Resolver, + operatorDirectory *string) error { //nolint:errcheck childrenTasks := funk.Filter(parent.OperatorVersion.Spec.Tasks, func(task kudoapi.Task) bool { return task.Kind == engtask.KudoOperatorTaskKind }).([]kudoapi.Task) for _, childTask := range childrenTasks { + childPackageName := childTask.Spec.KudoOperatorTaskSpec.Package + + // if the path to a child dependency is a relative one, we construct the absolute path for the + // resolver by combining the absolute path for the operator directory with the relative dependency path + // a relative dependency path must begin with either './' or '../' + isRelativePackage := strings.HasPrefix(childPackageName, "./") || strings.HasPrefix(childPackageName, "../") + if isRelativePackage { + if operatorDirectory == nil { + return fmt.Errorf("a dependency with a relative path %q is only allowed in a parent %v when it is a local directory", childPackageName, parent.OperatorVersion.FullyQualifiedName()) + } + childDirectory, err := operatorAbsPath(filepath.Join(*operatorDirectory, childPackageName)) + if err != nil { + return fmt.Errorf("local dependency %s of the parent %s has an invalid path: %v", fullyQualifiedName(childTask.Spec.KudoOperatorTaskSpec), parent.OperatorVersion.FullyQualifiedName(), err) + } + childPackageName = *childDirectory + + } + childPkg, err := resolver.Resolve( - childTask.Spec.KudoOperatorTaskSpec.Package, + childPackageName, childTask.Spec.KudoOperatorTaskSpec.AppVersion, childTask.Spec.KudoOperatorTaskSpec.OperatorVersion) if err != nil { @@ -123,7 +151,11 @@ func dependencyWalk( // We only need to walk the dependencies if the package is new if newPackage { - if err := dependencyWalk(dependencies, g, *childPkg.Resources, childIndex, resolver); err != nil { + var childOperatorDirectory *string + if isRelativePackage { + childOperatorDirectory = &childPackageName + } + if err := dependencyWalk(dependencies, g, *childPkg.Resources, childIndex, resolver, childOperatorDirectory); err != nil { return err } } @@ -157,3 +189,19 @@ func fullyQualifiedName(kt kudoapi.KudoOperatorTaskSpec) string { return fmt.Sprintf("Operator: %q, OperatorVersion: %q, AppVersion %q", kt.Package, operatorVersion, appVersion) } + +func operatorAbsPath(path string) (*string, error) { + fs := afero.NewOsFs() + + ok, err := afero.IsDir(fs, path) + // force local operators usage to be either absolute or express a relative path + // or put another way, a name can NOT be mistaken to be the name of a local folder + if ok && filepath.Base(path) != path { + abs, err := filepath.Abs(path) + if err == nil { + return &abs, nil + } + return nil, fmt.Errorf("failed to detect an absolute path for %q: %v", path, err) + } + return nil, fmt.Errorf("%q is not a valid directory: %v", path, err) +} diff --git a/pkg/kudoctl/resources/dependencies/resolve_test.go b/pkg/kudoctl/resources/dependencies/resolve_test.go index a9ff32190..e03aca70e 100644 --- a/pkg/kudoctl/resources/dependencies/resolve_test.go +++ b/pkg/kudoctl/resources/dependencies/resolve_test.go @@ -12,6 +12,7 @@ import ( kudoapi "github.com/kudobuilder/kudo/pkg/apis/kudo/v1beta1" engtask "github.com/kudobuilder/kudo/pkg/engine/task" "github.com/kudobuilder/kudo/pkg/kudoctl/packages" + pkgresolver "github.com/kudobuilder/kudo/pkg/kudoctl/packages/resolver" ) type nameResolver struct { @@ -223,7 +224,8 @@ func TestResolve(t *testing.T) { tt := tt t.Run(tt.name, func(t *testing.T) { resolver := nameResolver{tt.pkgs} - got, err := Resolve(tt.pkgs[0].Resources.OperatorVersion, resolver) + operatorArg := tt.pkgs[0].Resources.OperatorVersion.Name + got, err := Resolve(operatorArg, tt.pkgs[0].Resources.OperatorVersion, resolver) assert.Equal(t, err == nil, tt.wantErr == "") @@ -241,3 +243,65 @@ func TestResolve(t *testing.T) { }) } } + +func Test_isLocalDirPackage(t *testing.T) { + tests := []struct { + name string + path string + wantNilPath bool + wantErr bool + }{ + { + name: "./", + path: "./", + wantNilPath: false, + wantErr: false, + }, + { + name: "../install", + path: "../install", + wantNilPath: false, + wantErr: false, + }, + { + name: "./some-fake-path", + path: "./some-fake-path", + wantNilPath: true, + wantErr: true, + }, + { + name: "./", + path: "./resolve_test.go", + wantNilPath: true, + wantErr: true, + }, + } + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + absPath, err := operatorAbsPath(tt.path) + assert.Equal(t, tt.wantErr, err != nil) + assert.Equal(t, tt.wantNilPath, absPath == nil) + }) + } +} + +func TestResolveLocalDependencies(t *testing.T) { + var resolver = pkgresolver.NewLocal() + var operatorArgument = "./testdata/operator-with-dependencies/parent-operator" + + pkg, err := resolver.Resolve(operatorArgument, "", "") + assert.NoError(t, err, "failed to resolve operator package for %s", operatorArgument) + + dependencies, err := Resolve(operatorArgument, pkg.Resources.OperatorVersion, resolver) + assert.NoError(t, err, "failed to resolve dependencies for %s", operatorArgument) + assert.Equal(t, len(dependencies), 1, "expecting to find child-operator dependency") + + assert.NotNil(t, dependencies[0].Operator, "expecting to find child-operator OperatorVersion resource") + assert.NotNil(t, dependencies[0].OperatorVersion, "expecting to find child-operator OperatorVersion resource") + assert.NotNil(t, dependencies[0].Instance, "expecting to find child-operator OperatorVersion resource") + + assert.Equal(t, dependencies[0].Operator.Name, "child") + assert.Equal(t, dependencies[0].OperatorVersion.Name, kudoapi.OperatorVersionName("child", "0.0.1")) + assert.Equal(t, dependencies[0].Instance.Name, kudoapi.OperatorInstanceName("child")) +} diff --git a/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/operator.yaml b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/operator.yaml new file mode 100644 index 000000000..3854b4260 --- /dev/null +++ b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/operator.yaml @@ -0,0 +1,25 @@ +apiVersion: kudo.dev/v1beta1 +name: "child" +operatorVersion: "0.0.1" +kubernetesVersion: 1.15.0 +maintainers: + - name: zen-dog + email: +url: https://kudo.dev +tasks: + - name: deploy + kind: Dummy + spec: + done: true + wantErr: false + +plans: + deploy: + strategy: serial + phases: + - name: main + strategy: parallel + steps: + - name: deploy + tasks: + - deploy diff --git a/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/params.yaml b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/params.yaml new file mode 100644 index 000000000..bd9e4cabc --- /dev/null +++ b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/child-operator/params.yaml @@ -0,0 +1,6 @@ +apiVersion: kudo.dev/v1beta1 +parameters: + - name: deploy + description: Triggers the deploy plan + default: 1 + trigger: deploy \ No newline at end of file diff --git a/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/operator.yaml b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/operator.yaml new file mode 100644 index 000000000..3632f6818 --- /dev/null +++ b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/operator.yaml @@ -0,0 +1,25 @@ +apiVersion: kudo.dev/v1beta1 +name: "parent" +operatorVersion: "0.1.0" +kubernetesVersion: 1.15.0 +maintainers: + - name: zen-dog + email: +url: https://kudo.dev +tasks: + - name: deploy-child + kind: KudoOperator + spec: + package: "../child-operator" + operatorVersion: 0.0.1 + +plans: + deploy: + strategy: serial + phases: + - name: main + strategy: parallel + steps: + - name: deploy + tasks: + - deploy-child \ No newline at end of file diff --git a/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/params.yaml b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/params.yaml new file mode 100644 index 000000000..bd9e4cabc --- /dev/null +++ b/pkg/kudoctl/resources/dependencies/testdata/operator-with-dependencies/parent-operator/params.yaml @@ -0,0 +1,6 @@ +apiVersion: kudo.dev/v1beta1 +parameters: + - name: deploy + description: Triggers the deploy plan + default: 1 + trigger: deploy \ No newline at end of file diff --git a/pkg/kudoctl/resources/install/operator.go b/pkg/kudoctl/resources/install/operator.go index 434f6145c..9e27bbcc3 100644 --- a/pkg/kudoctl/resources/install/operator.go +++ b/pkg/kudoctl/resources/install/operator.go @@ -8,7 +8,6 @@ import ( kudoapi "github.com/kudobuilder/kudo/pkg/apis/kudo/v1beta1" engtask "github.com/kudobuilder/kudo/pkg/engine/task" "github.com/kudobuilder/kudo/pkg/kudoctl/clog" - "github.com/kudobuilder/kudo/pkg/kudoctl/packages/resolver" deps "github.com/kudobuilder/kudo/pkg/kudoctl/resources/dependencies" "github.com/kudobuilder/kudo/pkg/kudoctl/util/kudo" ) @@ -20,7 +19,7 @@ func OperatorAndOperatorVersion( client *kudo.Client, operator *kudoapi.Operator, operatorVersion *kudoapi.OperatorVersion, - resolver resolver.Resolver) error { + dependencies []deps.Dependency) error { if !client.OperatorExistsInCluster(operator.Name, operator.Namespace) { if _, err := client.InstallOperatorObjToCluster(operator, operator.Namespace); err != nil { return fmt.Errorf( @@ -42,7 +41,7 @@ func OperatorAndOperatorVersion( } if !funk.ContainsString(versionsInstalled, operatorVersion.Spec.Version) { - if err := installDependencies(client, operatorVersion, resolver); err != nil { + if err := installDependencies(client, operatorVersion, dependencies); err != nil { return fmt.Errorf( "failed to install dependencies of operatorversion %s/%s: %v", operatorVersion.Namespace, @@ -67,12 +66,7 @@ func OperatorAndOperatorVersion( return nil } -func installDependencies(client *kudo.Client, ov *kudoapi.OperatorVersion, resolver resolver.Resolver) error { - dependencies, err := deps.Resolve(ov, resolver) - if err != nil { - return err - } - +func installDependencies(client *kudo.Client, ov *kudoapi.OperatorVersion, dependencies []deps.Dependency) error { // The KUDO controller will create Instances for the dependencies. For this // it needs to resolve the dependencies again from 'KudoOperatorTaskSpec'. // But it cannot resolve packages like the CLI, because it may diff --git a/pkg/kudoctl/resources/upgrade/operatorversion.go b/pkg/kudoctl/resources/upgrade/operatorversion.go index 79258e8f3..fbb77a3e8 100644 --- a/pkg/kudoctl/resources/upgrade/operatorversion.go +++ b/pkg/kudoctl/resources/upgrade/operatorversion.go @@ -7,7 +7,7 @@ import ( kudoapi "github.com/kudobuilder/kudo/pkg/apis/kudo/v1beta1" "github.com/kudobuilder/kudo/pkg/kudoctl/clog" - "github.com/kudobuilder/kudo/pkg/kudoctl/packages/resolver" + deps "github.com/kudobuilder/kudo/pkg/kudoctl/resources/dependencies" "github.com/kudobuilder/kudo/pkg/kudoctl/resources/install" "github.com/kudobuilder/kudo/pkg/kudoctl/util/kudo" "github.com/kudobuilder/kudo/pkg/util/convert" @@ -20,7 +20,7 @@ func OperatorVersion( newOv *kudoapi.OperatorVersion, instanceName string, parameters map[string]string, - resolver resolver.Resolver) error { + dependencies []deps.Dependency) error { ov, err := operatorVersionFromInstance(kc, instanceName, newOv.Namespace) if err != nil { @@ -36,7 +36,7 @@ func OperatorVersion( return fmt.Errorf("failed to retrieve operator %s/%s: %v", newOv.Namespace, newOv.Spec.Operator.Name, err) } - if err := install.OperatorAndOperatorVersion(kc, o, newOv, resolver); err != nil { + if err := install.OperatorAndOperatorVersion(kc, o, newOv, dependencies); err != nil { return fmt.Errorf("failed to install new operatorversion %s/%s: %v", newOv.Namespace, newOv.Name, err) } diff --git a/pkg/kudoctl/resources/upgrade/operatorversion_test.go b/pkg/kudoctl/resources/upgrade/operatorversion_test.go index 165b8775c..8d27f8108 100644 --- a/pkg/kudoctl/resources/upgrade/operatorversion_test.go +++ b/pkg/kudoctl/resources/upgrade/operatorversion_test.go @@ -14,6 +14,7 @@ import ( "github.com/kudobuilder/kudo/pkg/client/clientset/versioned/fake" engtask "github.com/kudobuilder/kudo/pkg/engine/task" "github.com/kudobuilder/kudo/pkg/kudoctl/packages" + deps "github.com/kudobuilder/kudo/pkg/kudoctl/resources/dependencies" "github.com/kudobuilder/kudo/pkg/kudoctl/util/kudo" util "github.com/kudobuilder/kudo/pkg/util/kudo" ) @@ -122,14 +123,6 @@ func Test_UpgradeOperatorVersion(t *testing.T) { } } -type testResolver struct { - pkg packages.Package -} - -func (r *testResolver) Resolve(name string, appVersion string, operatorVersion string) (*packages.Package, error) { - return &r.pkg, nil -} - func Test_UpgradeOperatorVersionWithDependency(t *testing.T) { testO := kudoapi.Operator{ TypeMeta: metav1.TypeMeta{ @@ -175,8 +168,8 @@ func Test_UpgradeOperatorVersionWithDependency(t *testing.T) { }, } - testDependency := packages.Package{ - Resources: &packages.Resources{ + testDependency := deps.Dependency{ + Resources: packages.Resources{ Operator: &kudoapi.Operator{ ObjectMeta: metav1.ObjectMeta{ Name: "dependency", @@ -188,6 +181,7 @@ func Test_UpgradeOperatorVersionWithDependency(t *testing.T) { }, }, }, + PackageName: "dependency", } c := kudo.NewClientFromK8s(fake.NewSimpleClientset(), kubefake.NewSimpleClientset()) @@ -215,9 +209,7 @@ func Test_UpgradeOperatorVersionWithDependency(t *testing.T) { }) newOv.SetNamespace(installNamespace) - resolver := &testResolver{testDependency} - - err = OperatorVersion(c, &newOv, "test", nil, resolver) + err = OperatorVersion(c, &newOv, "test", nil, []deps.Dependency{testDependency}) assert.NoError(t, err) assert.True(t, c.OperatorExistsInCluster("dependency", "default")) diff --git a/test/integration/operator-with-dependencies/parent-operator/operator.yaml b/test/integration/operator-with-dependencies/parent-operator/operator.yaml index 068da09a8..3632f6818 100644 --- a/test/integration/operator-with-dependencies/parent-operator/operator.yaml +++ b/test/integration/operator-with-dependencies/parent-operator/operator.yaml @@ -10,7 +10,7 @@ tasks: - name: deploy-child kind: KudoOperator spec: - package: "./child-operator" + package: "../child-operator" operatorVersion: 0.0.1 plans: diff --git a/test/integration/upgrade-with-dependencies/operator-2.0/operator.yaml b/test/integration/upgrade-with-dependencies/operator-2.0/operator.yaml index 73b91facc..b9ed1a363 100644 --- a/test/integration/upgrade-with-dependencies/operator-2.0/operator.yaml +++ b/test/integration/upgrade-with-dependencies/operator-2.0/operator.yaml @@ -10,7 +10,7 @@ tasks: - name: dependency kind: KudoOperator spec: - package: "./dependency" + package: "../dependency" operatorVersion: "1.0" plans: