Improve plugins management

pkg/controller/jenkins/configuration/base/reconcile.go

@@ -106,7 +106,7 @@ func (r *ReconcileJenkinsBaseConfiguration) Reconcile() (reconcile.Result, jenki
 	}
 	r.logger.V(log.VDebug).Info("Jenkins API client set")
 
-	ok, err := r.verifyPlugins(jenkinsClient, plugins.BasePluginsMap)
+	ok, err := r.verifyPlugins(jenkinsClient)
 	if err != nil {
 		return reconcile.Result{}, nil, err
 	}
@@ -187,7 +187,7 @@ func (r *ReconcileJenkinsBaseConfiguration) waitForVolumes() (reconcile.Result,
 	return reconcile.Result{}, nil
 }
 
-func (r *ReconcileJenkinsBaseConfiguration) verifyPlugins(jenkinsClient jenkinsclient.Jenkins, basePlugins map[string][]plugins.Plugin) (bool, error) {
+func (r *ReconcileJenkinsBaseConfiguration) verifyPlugins(jenkinsClient jenkinsclient.Jenkins) (bool, error) {
 	allPluginsInJenkins, err := jenkinsClient.GetPlugins(fetchAllPlugins)
 	if err != nil {
 		return false, stackerr.WithStack(err)
@@ -201,46 +201,16 @@ func (r *ReconcileJenkinsBaseConfiguration) verifyPlugins(jenkinsClient jenkinsc
 	}
 	r.logger.V(log.VDebug).Info(fmt.Sprintf("Installed plugins '%+v'", installedPlugins))
 
-	userPlugins := map[string][]plugins.Plugin{}
-	for rootPlugin, dependentPluginNames := range r.jenkins.Spec.Master.Plugins {
-		var dependentPlugins []plugins.Plugin
-		for _, pluginNameWithVersion := range dependentPluginNames {
-			plugin, err := plugins.New(pluginNameWithVersion)
-			if err != nil {
-				return false, err
-			}
-			dependentPlugins = append(dependentPlugins, *plugin)
-		}
-		userPlugins[rootPlugin] = dependentPlugins
-	}
-
 	status := true
-	allRequiredPlugins := []map[string][]plugins.Plugin{basePlugins, userPlugins}
+	allRequiredPlugins := [][]v1alpha2.Plugin{r.jenkins.Spec.Master.BasePlugins, r.jenkins.Spec.Master.Plugins}
 	for _, requiredPlugins := range allRequiredPlugins {
-		for rootPluginName, p := range requiredPlugins {
-			rootPlugin, _ := plugins.New(rootPluginName)
-			if found, ok := isPluginInstalled(allPluginsInJenkins, *rootPlugin); !ok {
-				r.logger.V(log.VWarn).Info(fmt.Sprintf("Missing plugin '%s', actual '%+v'", rootPlugin, found))
+		for _, plugin := range requiredPlugins {
+			if found, ok := isPluginInstalled(allPluginsInJenkins, plugin); !ok {
+				r.logger.V(log.VWarn).Info(fmt.Sprintf("Missing plugin '%s', actual '%+v'", plugin, found))
 				status = false
 			}
-			for _, requiredPlugin := range p {
-				if found, ok := isPluginInstalled(allPluginsInJenkins, requiredPlugin); !ok {
-					r.logger.V(log.VWarn).Info(fmt.Sprintf("Missing plugin '%s', actual '%+v'", requiredPlugin, found))
-					status = false
-				}
-			}
-		}
-	}
-
-	for rootPluginName, p := range userPlugins {
-		rootPlugin, _ := plugins.New(rootPluginName)
-		if found, ok := isPluginVersionCompatible(allPluginsInJenkins, *rootPlugin); !ok {
-			r.logger.V(log.VWarn).Info(fmt.Sprintf("Incompatible plugin '%s' version, actual '%+v'", rootPlugin, found.Version))
-			status = false
-		}
-		for _, requiredPlugin := range p {
-			if found, ok := isPluginInstalled(allPluginsInJenkins, requiredPlugin); !ok {
-				r.logger.V(log.VWarn).Info(fmt.Sprintf("Incompatible plugin '%s' version, actual '%+v'", requiredPlugin, found.Version))
+			if found, ok := isPluginVersionCompatible(allPluginsInJenkins, plugin); !ok {
+				r.logger.V(log.VWarn).Info(fmt.Sprintf("Incompatible plugin '%s' version, actual '%+v'", plugin, found.Version))
 				status = false
 			}
 		}
@@ -249,7 +219,7 @@ func (r *ReconcileJenkinsBaseConfiguration) verifyPlugins(jenkinsClient jenkinsc
 	return status, nil
 }
 
-func isPluginVersionCompatible(plugins *gojenkins.Plugins, plugin plugins.Plugin) (gojenkins.Plugin, bool) {
+func isPluginVersionCompatible(plugins *gojenkins.Plugins, plugin v1alpha2.Plugin) (gojenkins.Plugin, bool) {
 	p := plugins.Contains(plugin.Name)
 	if p == nil {
 		return gojenkins.Plugin{}, false
@@ -262,7 +232,7 @@ func isValidPlugin(plugin gojenkins.Plugin) bool {
 	return plugin.Active && plugin.Enabled && !plugin.Deleted
 }
 
-func isPluginInstalled(plugins *gojenkins.Plugins, requiredPlugin plugins.Plugin) (gojenkins.Plugin, bool) {
+func isPluginInstalled(plugins *gojenkins.Plugins, requiredPlugin v1alpha2.Plugin) (gojenkins.Plugin, bool) {
 	p := plugins.Contains(requiredPlugin.Name)
 	if p == nil {
 		return gojenkins.Plugin{}, false

pkg/controller/jenkins/configuration/base/reconcile_test.go

@@ -6,7 +6,6 @@ import (
 	"github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2"
 	"github.com/jenkinsci/kubernetes-operator/pkg/controller/jenkins/client"
 	"github.com/jenkinsci/kubernetes-operator/pkg/controller/jenkins/configuration/base/resources"
-	"github.com/jenkinsci/kubernetes-operator/pkg/controller/jenkins/plugins"
 	"github.com/jenkinsci/kubernetes-operator/pkg/log"
 
 	"github.com/bndr/gojenkins"
@@ -167,19 +166,67 @@ func TestReconcileJenkinsBaseConfiguration_verifyPlugins(t *testing.T) {
 		pluginsInJenkins := &gojenkins.Plugins{
 			Raw: &gojenkins.PluginResponse{},
 		}
-		basePlugins := map[string][]plugins.Plugin{}
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
 		jenkinsClient := client.NewMockJenkins(ctrl)
 		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
 
-		got, err := r.verifyPlugins(jenkinsClient, basePlugins)
+		got, err := r.verifyPlugins(jenkinsClient)
+
+		assert.NoError(t, err)
+		assert.True(t, got)
+	})
+	t.Run("happy, not empty base and user plugins", func(t *testing.T) {
+		jenkins := &v1alpha2.Jenkins{
+			Spec: v1alpha2.JenkinsSpec{
+				Master: v1alpha2.JenkinsMaster{
+					BasePlugins: []v1alpha2.Plugin{{Name: "plugin-name1", Version: "0.0.1"}},
+					Plugins:     []v1alpha2.Plugin{{Name: "plugin-name2", Version: "0.0.1"}},
+				},
+			},
+		}
+		r := ReconcileJenkinsBaseConfiguration{
+			logger:  log.Log,
+			jenkins: jenkins,
+		}
+		pluginsInJenkins := &gojenkins.Plugins{
+			Raw: &gojenkins.PluginResponse{
+				Plugins: []gojenkins.Plugin{
+					{
+						ShortName: "plugin-name1",
+						Active:    true,
+						Deleted:   false,
+						Enabled:   true,
+						Version:   "0.0.1",
+					},
+					{
+						ShortName: "plugin-name2",
+						Active:    true,
+						Deleted:   false,
+						Enabled:   true,
+						Version:   "0.0.1",
+					},
+				},
+			},
+		}
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jenkinsClient := client.NewMockJenkins(ctrl)
+		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
+
+		got, err := r.verifyPlugins(jenkinsClient)
 
 		assert.NoError(t, err)
 		assert.True(t, got)
 	})
 	t.Run("happy, not empty base and empty user plugins", func(t *testing.T) {
-		jenkins := &v1alpha2.Jenkins{}
+		jenkins := &v1alpha2.Jenkins{
+			Spec: v1alpha2.JenkinsSpec{
+				Master: v1alpha2.JenkinsMaster{
+					BasePlugins: []v1alpha2.Plugin{{Name: "plugin-name", Version: "0.0.1"}},
+				},
+			},
+		}
 		r := ReconcileJenkinsBaseConfiguration{
 			logger:  log.Log,
 			jenkins: jenkins,
@@ -197,15 +244,12 @@ func TestReconcileJenkinsBaseConfiguration_verifyPlugins(t *testing.T) {
 				},
 			},
 		}
-		basePlugins := map[string][]plugins.Plugin{
-			"plugin-name:0.0.1": {},
-		}
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
 		jenkinsClient := client.NewMockJenkins(ctrl)
 		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
 
-		got, err := r.verifyPlugins(jenkinsClient, basePlugins)
+		got, err := r.verifyPlugins(jenkinsClient)
 
 		assert.NoError(t, err)
 		assert.True(t, got)
@@ -214,7 +258,7 @@ func TestReconcileJenkinsBaseConfiguration_verifyPlugins(t *testing.T) {
 		jenkins := &v1alpha2.Jenkins{
 			Spec: v1alpha2.JenkinsSpec{
 				Master: v1alpha2.JenkinsMaster{
-					Plugins: map[string][]string{"plugin-name:0.0.1": {}},
+					Plugins: []v1alpha2.Plugin{{Name: "plugin-name", Version: "0.0.1"}},
 				},
 			},
 		}
@@ -235,19 +279,24 @@ func TestReconcileJenkinsBaseConfiguration_verifyPlugins(t *testing.T) {
 				},
 			},
 		}
-		basePlugins := map[string][]plugins.Plugin{}
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
 		jenkinsClient := client.NewMockJenkins(ctrl)
 		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
 
-		got, err := r.verifyPlugins(jenkinsClient, basePlugins)
+		got, err := r.verifyPlugins(jenkinsClient)
 
 		assert.NoError(t, err)
 		assert.True(t, got)
 	})
-	t.Run("happy, plugin version doesn't matter for base plugins", func(t *testing.T) {
-		jenkins := &v1alpha2.Jenkins{}
+	t.Run("happy, plugin version matter for base plugins", func(t *testing.T) {
+		jenkins := &v1alpha2.Jenkins{
+			Spec: v1alpha2.JenkinsSpec{
+				Master: v1alpha2.JenkinsMaster{
+					BasePlugins: []v1alpha2.Plugin{{Name: "plugin-name", Version: "0.0.1"}},
+				},
+			},
+		}
 		r := ReconcileJenkinsBaseConfiguration{
 			logger:  log.Log,
 			jenkins: jenkins,
@@ -265,24 +314,21 @@ func TestReconcileJenkinsBaseConfiguration_verifyPlugins(t *testing.T) {
 				},
 			},
 		}
-		basePlugins := map[string][]plugins.Plugin{
-			"plugin-name:0.0.1": {},
-		}
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
 		jenkinsClient := client.NewMockJenkins(ctrl)
 		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
 
-		got, err := r.verifyPlugins(jenkinsClient, basePlugins)
+		got, err := r.verifyPlugins(jenkinsClient)
 
 		assert.NoError(t, err)
-		assert.True(t, got)
+		assert.False(t, got)
 	})
 	t.Run("plugin version matter for user plugins", func(t *testing.T) {
 		jenkins := &v1alpha2.Jenkins{
 			Spec: v1alpha2.JenkinsSpec{
 				Master: v1alpha2.JenkinsMaster{
-					Plugins: map[string][]string{"plugin-name:0.0.2": {}},
+					Plugins: []v1alpha2.Plugin{{Name: "plugin-name", Version: "0.0.2"}},
 				},
 			},
 		}
@@ -303,46 +349,21 @@ func TestReconcileJenkinsBaseConfiguration_verifyPlugins(t *testing.T) {
 				},
 			},
 		}
-		basePlugins := map[string][]plugins.Plugin{}
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
 		jenkinsClient := client.NewMockJenkins(ctrl)
 		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
 
-		got, err := r.verifyPlugins(jenkinsClient, basePlugins)
+		got, err := r.verifyPlugins(jenkinsClient)
 
 		assert.NoError(t, err)
 		assert.False(t, got)
 	})
 	t.Run("missing base plugin", func(t *testing.T) {
-		jenkins := &v1alpha2.Jenkins{}
-		r := ReconcileJenkinsBaseConfiguration{
-			logger:  log.Log,
-			jenkins: jenkins,
-		}
-		pluginsInJenkins := &gojenkins.Plugins{
-			Raw: &gojenkins.PluginResponse{
-				Plugins: []gojenkins.Plugin{},
-			},
-		}
-		basePlugins := map[string][]plugins.Plugin{
-			"plugin-name:0.0.2": {},
-		}
-		ctrl := gomock.NewController(t)
-		defer ctrl.Finish()
-		jenkinsClient := client.NewMockJenkins(ctrl)
-		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
-
-		got, err := r.verifyPlugins(jenkinsClient, basePlugins)
-
-		assert.NoError(t, err)
-		assert.False(t, got)
-	})
-	t.Run("missing user plugin", func(t *testing.T) {
 		jenkins := &v1alpha2.Jenkins{
 			Spec: v1alpha2.JenkinsSpec{
 				Master: v1alpha2.JenkinsMaster{
-					Plugins: map[string][]string{"plugin-name:0.0.2": {}},
+					BasePlugins: []v1alpha2.Plugin{{Name: "plugin-name", Version: "0.0.2"}},
 				},
 			},
 		}
@@ -355,13 +376,39 @@ func TestReconcileJenkinsBaseConfiguration_verifyPlugins(t *testing.T) {
 				Plugins: []gojenkins.Plugin{},
 			},
 		}
-		basePlugins := map[string][]plugins.Plugin{}
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
 		jenkinsClient := client.NewMockJenkins(ctrl)
 		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
 
-		got, err := r.verifyPlugins(jenkinsClient, basePlugins)
+		got, err := r.verifyPlugins(jenkinsClient)
+
+		assert.NoError(t, err)
+		assert.False(t, got)
+	})
+	t.Run("missing user plugin", func(t *testing.T) {
+		jenkins := &v1alpha2.Jenkins{
+			Spec: v1alpha2.JenkinsSpec{
+				Master: v1alpha2.JenkinsMaster{
+					Plugins: []v1alpha2.Plugin{{Name: "plugin-name", Version: "0.0.2"}},
+				},
+			},
+		}
+		r := ReconcileJenkinsBaseConfiguration{
+			logger:  log.Log,
+			jenkins: jenkins,
+		}
+		pluginsInJenkins := &gojenkins.Plugins{
+			Raw: &gojenkins.PluginResponse{
+				Plugins: []gojenkins.Plugin{},
+			},
+		}
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+		jenkinsClient := client.NewMockJenkins(ctrl)
+		jenkinsClient.EXPECT().GetPlugins(fetchAllPlugins).Return(pluginsInJenkins, nil)
+
+		got, err := r.verifyPlugins(jenkinsClient)
 
 		assert.NoError(t, err)
 		assert.False(t, got)

pkg/controller/jenkins/configuration/base/resources/base_configuration_configmap.go

@@ -94,7 +94,9 @@ def remove = { list ->
 remove(jenkins.getExtensionList(RootAction.class))
 remove(jenkins.actions)
 
-jenkins.getDescriptor("jenkins.CLI").get().setEnabled(false)
+if (jenkins.getDescriptor("jenkins.CLI") != null) {
+    jenkins.getDescriptor("jenkins.CLI").get().setEnabled(false)
+}
 
 jenkins.save()
 `

pkg/controller/jenkins/configuration/base/resources/scripts_configmap.go

@@ -255,17 +255,11 @@ chmod +x {{ .JenkinsHomePath }}/scripts/*.sh
 {{- $installPluginsCommand := .InstallPluginsCommand }}
 
 echo "Installing plugins required by Operator - begin"
-{{- range $rootPluginName, $plugins := .OperatorPlugins }}
-echo "Installing required plugins for '{{ $rootPluginName }}'"
-{{ $jenkinsHomePath }}/scripts/{{ $installPluginsCommand }} {{ $rootPluginName }} {{ range $index, $plugin := $plugins }}{{ . }} {{ end }}
-{{- end }}
+{{ $installPluginsCommand }} {{ range $index, $plugin := .BasePlugins }}{{ $plugin.Name }}:{{ $plugin.Version }} {{ end }}
 echo "Installing plugins required by Operator - end"
 
 echo "Installing plugins required by user - begin"
-{{- range $rootPluginName, $plugins := .UserPlugins }}
-echo "Installing required plugins for '{{ $rootPluginName }}'"
-{{ $jenkinsHomePath }}/scripts/{{ $installPluginsCommand }} {{ $rootPluginName }} {{ range $index, $plugin := $plugins }}{{ . }} {{ end }}
-{{- end }}
+{{ $installPluginsCommand }} {{ range $index, $plugin := .UserPlugins }}{{ $plugin.Name }}:{{ $plugin.Version }} {{ end }}
 echo "Installing plugins required by user - end"
 
 /sbin/tini -s -- /usr/local/bin/jenkins.sh
@@ -284,12 +278,12 @@ func buildInitBashScript(jenkins *v1alpha2.Jenkins) (*string, error) {
 		InitConfigurationPath    string
 		InstallPluginsCommand    string
 		JenkinsScriptsVolumePath string
-		OperatorPlugins          map[string][]string
-		UserPlugins              map[string][]string
+		BasePlugins              []v1alpha2.Plugin
+		UserPlugins              []v1alpha2.Plugin
 	}{
 		JenkinsHomePath:          jenkinsHomePath,
 		InitConfigurationPath:    jenkinsInitConfigurationVolumePath,
-		OperatorPlugins:          jenkins.Spec.Master.OperatorPlugins,
+		BasePlugins:              jenkins.Spec.Master.BasePlugins,
 		UserPlugins:              jenkins.Spec.Master.Plugins,
 		InstallPluginsCommand:    installPluginsCommand,
 		JenkinsScriptsVolumePath: jenkinsScriptsVolumePath,

pkg/controller/jenkins/configuration/base/validate.go

@@ -42,7 +42,7 @@ func (r *ReconcileJenkinsBaseConfiguration) Validate(jenkins *v1alpha2.Jenkins)
 		}
 	}
 
-	if !r.validatePlugins(jenkins.Spec.Master.OperatorPlugins, jenkins.Spec.Master.Plugins) {
+	if !r.validatePlugins(plugins.BasePlugins(), jenkins.Spec.Master.BasePlugins, jenkins.Spec.Master.Plugins) {
 		return false, nil
 	}
 
@@ -215,36 +215,60 @@ func (r *ReconcileJenkinsBaseConfiguration) validateJenkinsMasterPodEnvs() bool
 	return valid
 }
 
-func (r *ReconcileJenkinsBaseConfiguration) validatePlugins(pluginsWithVersionSlice ...map[string][]string) bool {
+func (r *ReconcileJenkinsBaseConfiguration) validatePlugins(requiredBasePlugins []plugins.Plugin, basePlugins, userPlugins []v1alpha2.Plugin) bool {
 	valid := true
 	allPlugins := map[plugins.Plugin][]plugins.Plugin{}
 
-	for _, pluginsWithVersions := range pluginsWithVersionSlice {
-		for rootPluginName, dependentPluginNames := range pluginsWithVersions {
-			rootPlugin, err := plugins.New(rootPluginName)
-			if err != nil {
-				r.logger.V(log.VWarn).Info(fmt.Sprintf("Invalid root plugin name '%s'", rootPluginName))
-				valid = false
-			}
+	for _, jenkinsPlugin := range basePlugins {
+		plugin, err := plugins.NewPlugin(jenkinsPlugin.Name, jenkinsPlugin.Version)
+		if err != nil {
+			r.logger.V(log.VWarn).Info(err.Error())
+			valid = false
+		}
 
-			var dependentPlugins []plugins.Plugin
-			for _, pluginName := range dependentPluginNames {
-				if p, err := plugins.New(pluginName); err != nil {
-					r.logger.V(log.VWarn).Info(fmt.Sprintf("Invalid dependent plugin name '%s' in root plugin '%s'", pluginName, rootPluginName))
-					valid = false
-				} else {
-					dependentPlugins = append(dependentPlugins, *p)
-				}
-			}
-
-			if rootPlugin != nil {
-				allPlugins[*rootPlugin] = dependentPlugins
-			}
+		if plugin != nil {
+			allPlugins[*plugin] = []plugins.Plugin{}
 		}
 	}
 
-	if valid {
-		return plugins.VerifyDependencies(allPlugins)
+	for _, jenkinsPlugin := range userPlugins {
+		plugin, err := plugins.NewPlugin(jenkinsPlugin.Name, jenkinsPlugin.Version)
+		if err != nil {
+			r.logger.V(log.VWarn).Info(err.Error())
+			valid = false
+		}
+
+		if plugin != nil {
+			allPlugins[*plugin] = []plugins.Plugin{}
+		}
+	}
+
+	if !plugins.VerifyDependencies(allPlugins) {
+		valid = false
+	}
+
+	if !r.verifyBasePlugins(requiredBasePlugins, basePlugins) {
+		valid = false
+	}
+
+	return valid
+}
+
+func (r *ReconcileJenkinsBaseConfiguration) verifyBasePlugins(requiredBasePlugins []plugins.Plugin, basePlugins []v1alpha2.Plugin) bool {
+	valid := true
+
+	for _, requiredBasePlugin := range requiredBasePlugins {
+		found := false
+		for _, basePlugin := range basePlugins {
+			if requiredBasePlugin.Name == basePlugin.Name {
+				found = true
+				break
+			}
+		}
+		if !found {
+			valid = false
+			r.logger.V(log.VWarn).Info(fmt.Sprintf("Missing plugin '%s' in spec.master.basePlugins", requiredBasePlugin.Name))
+		}
 	}
 
 	return valid

pkg/controller/jenkins/configuration/base/validate_test.go

@@ -6,6 +6,8 @@ import (
 
 	"github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2"
 	"github.com/jenkinsci/kubernetes-operator/pkg/controller/jenkins/configuration/base/resources"
+	"github.com/jenkinsci/kubernetes-operator/pkg/controller/jenkins/plugins"
+	"github.com/jenkinsci/kubernetes-operator/pkg/log"
 
 	"github.com/stretchr/testify/assert"
 	"k8s.io/api/core/v1"
@@ -16,62 +18,117 @@ import (
 )
 
 func TestValidatePlugins(t *testing.T) {
-	baseReconcileLoop := New(nil, nil, logf.ZapLogger(false),
+	log.SetupLogger(true)
+	baseReconcileLoop := New(nil, nil, log.Log,
 		nil, false, false)
-	t.Run("happy", func(t *testing.T) {
-		plugins := map[string][]string{
-			"valid-plugin-name:1.0": {
-				"valid-plugin-name:1.0",
-			},
-		}
-		got := baseReconcileLoop.validatePlugins(plugins)
-		assert.Equal(t, true, got)
-	})
-	t.Run("fail, no version in plugin name", func(t *testing.T) {
-		plugins := map[string][]string{
-			"invalid-plugin-name": {
-				"invalid-plugin-name",
-			},
-		}
-		got := baseReconcileLoop.validatePlugins(plugins)
-		assert.Equal(t, false, got)
-	})
-	t.Run("fail, no version in root plugin name", func(t *testing.T) {
-		plugins := map[string][]string{
-			"invalid-plugin-name": {
-				"invalid-plugin-name:1.0",
-			},
-		}
-		got := baseReconcileLoop.validatePlugins(plugins)
-		assert.Equal(t, false, got)
-	})
-	t.Run("fail, no version in plugin name", func(t *testing.T) {
-		plugins := map[string][]string{
-			"invalid-plugin-name:1.0": {
-				"invalid-plugin-name",
-			},
-		}
-		got := baseReconcileLoop.validatePlugins(plugins)
-		assert.Equal(t, false, got)
-	})
-	t.Run("happy", func(t *testing.T) {
-		plugins := map[string][]string{
-			"valid-plugin-name:1.0": {
-				"valid-plugin-name:1.0",
-				"valid-plugin-name2:1.0",
-			},
-		}
-		got := baseReconcileLoop.validatePlugins(plugins)
-		assert.Equal(t, true, got)
-	})
-	t.Run("hapy", func(t *testing.T) {
-		plugins := map[string][]string{
-			"valid-plugin-name:1.0": {},
-		}
-		got := baseReconcileLoop.validatePlugins(plugins)
-		assert.Equal(t, true, got)
-	})
+	t.Run("empty", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		var basePlugins []v1alpha2.Plugin
+		var userPlugins []v1alpha2.Plugin
 
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.True(t, got)
+	})
+	t.Run("valid user plugin", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		var basePlugins []v1alpha2.Plugin
+		userPlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.True(t, got)
+	})
+	t.Run("invalid user plugin name", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		var basePlugins []v1alpha2.Plugin
+		userPlugins := []v1alpha2.Plugin{{Name: "INVALID", Version: "0.0.1"}}
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.False(t, got)
+	})
+	t.Run("invalid user plugin version", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		var basePlugins []v1alpha2.Plugin
+		userPlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "invalid"}}
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.False(t, got)
+	})
+	t.Run("valid base plugin", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		basePlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+		var userPlugins []v1alpha2.Plugin
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.True(t, got)
+	})
+	t.Run("invalid base plugin name", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		basePlugins := []v1alpha2.Plugin{{Name: "INVALID", Version: "0.0.1"}}
+		var userPlugins []v1alpha2.Plugin
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.False(t, got)
+	})
+	t.Run("invalid base plugin version", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		basePlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "invalid"}}
+		var userPlugins []v1alpha2.Plugin
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.False(t, got)
+	})
+	t.Run("valid user and base plugin version", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		basePlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+		userPlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.True(t, got)
+	})
+	t.Run("invalid user and base plugin version", func(t *testing.T) {
+		var requiredBasePlugins []plugins.Plugin
+		basePlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+		userPlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.2"}}
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.False(t, got)
+	})
+	t.Run("required base plugin set with the same version", func(t *testing.T) {
+		requiredBasePlugins := []plugins.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+		basePlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+		var userPlugins []v1alpha2.Plugin
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.True(t, got)
+	})
+	t.Run("required base plugin set with different version", func(t *testing.T) {
+		requiredBasePlugins := []plugins.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+		basePlugins := []v1alpha2.Plugin{{Name: "simple-plugin", Version: "0.0.2"}}
+		var userPlugins []v1alpha2.Plugin
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.True(t, got)
+	})
+	t.Run("missign required base plugin", func(t *testing.T) {
+		requiredBasePlugins := []plugins.Plugin{{Name: "simple-plugin", Version: "0.0.1"}}
+		var basePlugins []v1alpha2.Plugin
+		var userPlugins []v1alpha2.Plugin
+
+		got := baseReconcileLoop.validatePlugins(requiredBasePlugins, basePlugins, userPlugins)
+
+		assert.False(t, got)
+	})
 }
 
 func TestValidateJenkinsMasterPodEnvs(t *testing.T) {