chore: Refactor available module

internal/manifest/parser/template_to_module.go

@@ -45,7 +45,7 @@ func (p *Parser) GenerateModulesFromTemplates(kyma *v1beta2.Kyma, templates temp
 	// (since we do not know which module we are dealing with)
 	modules := make(common.Modules, 0)
 
-	for _, module := range templatelookup.FindAvailableModules(kyma) {
+	for _, module := range templatelookup.FetchModuleInfo(kyma) {
 		template := templates[module.Name]
 		modules = p.appendModuleWithInformation(module, kyma, template, modules)
 	}
@@ -67,7 +67,7 @@ func (p *Parser) GenerateMandatoryModulesFromTemplates(ctx context.Context,
 			moduleName = template.Name
 		}
 
-		modules = p.appendModuleWithInformation(templatelookup.AvailableModule{
+		modules = p.appendModuleWithInformation(templatelookup.ModuleInfo{
 			Module: v1beta2.Module{
 				Name:                 moduleName,
 				CustomResourcePolicy: v1beta2.CustomResourcePolicyCreateAndDelete,
@@ -79,7 +79,7 @@ func (p *Parser) GenerateMandatoryModulesFromTemplates(ctx context.Context,
 	return modules
 }
 
-func (p *Parser) appendModuleWithInformation(module templatelookup.AvailableModule, kyma *v1beta2.Kyma,
+func (p *Parser) appendModuleWithInformation(module templatelookup.ModuleInfo, kyma *v1beta2.Kyma,
 	template *templatelookup.ModuleTemplateInfo, modules common.Modules,
 ) common.Modules {
 	if template.Err != nil && !errors.Is(template.Err, templatelookup.ErrTemplateNotAllowed) {

pkg/templatelookup/availableModules.go → pkg/templatelookup/moduleinfo.go

@@ -13,35 +13,36 @@ var (
 	ErrInvalidModuleInStatus = errors.New("invalid module entry in Kyma status")
 )
 
-type AvailableModule struct {
+type ModuleInfo struct {
 	v1beta2.Module
 	Enabled         bool
 	ValidationError error
 	Unmanaged       bool
 }
 
-func (a AvailableModule) IsInstalledByVersion() bool {
+func (a ModuleInfo) IsInstalledByVersion() bool {
 	return a.configuredWithVersionInSpec() || a.installedwithVersionInStatus()
 }
 
 // configuredWithVersionInSpec returns true if the Module is enabled in Spec using a specific version instead of a channel.
-func (a AvailableModule) configuredWithVersionInSpec() bool {
+func (a ModuleInfo) configuredWithVersionInSpec() bool {
 	return a.Enabled && a.Version != "" && a.Channel == ""
 }
 
 // installedwithVersionInStatus returns true if the Module installed using a specific version (instead of a channel) is reported in Status.
-func (a AvailableModule) installedwithVersionInStatus() bool {
+func (a ModuleInfo) installedwithVersionInStatus() bool {
 	return !a.Enabled && shared.NoneChannel.Equals(a.Channel) && a.Version != ""
 }
 
-// FindAvailableModules returns a list of AvailableModule objects based on the Kyma CR Spec and Status.
-func FindAvailableModules(kyma *v1beta2.Kyma) []AvailableModule {
+// FetchModuleInfo returns a list of ModuleInfo objects containing information about modules referenced by the Kyma CR.
+// This includes modules that are enabled in `.spec.modules[]` and modules that are not enabled in `.spec.modules[]` but still contain an entry in `.status.modules[]`.
+func FetchModuleInfo(kyma *v1beta2.Kyma) []ModuleInfo {
 	moduleMap := make(map[string]bool)
-	modules := make([]AvailableModule, 0)
+	modules := make([]ModuleInfo, 0)
 	for _, module := range kyma.Spec.Modules {
 		moduleMap[module.Name] = true
 		if shared.NoneChannel.Equals(module.Channel) {
-			modules = append(modules, AvailableModule{
+			modules = append(modules, ModuleInfo{
 				Module:          module,
 				Enabled:         true,
 				ValidationError: fmt.Errorf("%w for module %s: Channel \"none\" is not allowed", ErrInvalidModuleInSpec, module.Name),
@@ -50,15 +51,15 @@ func FindAvailableModules(kyma *v1beta2.Kyma) []AvailableModule {
 			continue
 		}
 		if module.Version != "" && module.Channel != "" {
-			modules = append(modules, AvailableModule{
+			modules = append(modules, ModuleInfo{
 				Module:          module,
 				Enabled:         true,
 				ValidationError: fmt.Errorf("%w for module %s: Version and channel are mutually exclusive options", ErrInvalidModuleInSpec, module.Name),
 				Unmanaged:       !module.Managed,
 			})
 			continue
 		}
-		modules = append(modules, AvailableModule{Module: module, Enabled: true, Unmanaged: !module.Managed})
+		modules = append(modules, ModuleInfo{Module: module, Enabled: true, Unmanaged: !module.Managed})
 	}
 
 	for _, moduleInStatus := range kyma.Status.Modules {
@@ -67,7 +68,7 @@ func FindAvailableModules(kyma *v1beta2.Kyma) []AvailableModule {
 			continue
 		}
 
-		modules = append(modules, AvailableModule{
+		modules = append(modules, ModuleInfo{
 			Module: v1beta2.Module{
 				Name:    moduleInStatus.Name,
 				Channel: moduleInStatus.Channel,

pkg/templatelookup/availableModules_test.go → pkg/templatelookup/moduleinfo_test.go

@@ -11,11 +11,46 @@ import (
 	"github.com/kyma-project/lifecycle-manager/pkg/templatelookup"
 )
 
-func Test_GetAvailableModules_When_ModuleInSpecOnly(t *testing.T) {
+func Test_FetchModuleInfo_When_EmptySpecAndStatus(t *testing.T) {
+	tests := []struct {
+		name       string
+		KymaSpec   v1beta2.KymaSpec
+		KymaStatus v1beta2.KymaStatus
+		want       []moduleInfo
+	}{
+		{
+			name:       "When KymaSpec and KymaStatus are both empty, the output should be empty",
+			KymaSpec:   v1beta2.KymaSpec{},
+			KymaStatus: v1beta2.KymaStatus{},
+			want:       []moduleInfo{}, // Expect empty result
+		},
+	}
+	for ti := range tests {
+		testcase := tests[ti]
+		t.Run(testcase.name, func(t *testing.T) {
+			kyma := &v1beta2.Kyma{
+				Spec:   testcase.KymaSpec,
+				Status: testcase.KymaStatus,
+			}
+
+			got := templatelookup.FetchModuleInfo(kyma)
+			if len(got) != len(testcase.want) {
+				t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
+			}
+			for gi := range got {
+				if !testcase.want[gi].Equals(got[gi]) {
+					t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
+				}
+			}
+		})
+	}
+}
+
+func Test_FetchModuleInfo_When_ModuleInSpecOnly(t *testing.T) {
 	tests := []struct {
 		name     string
 		KymaSpec v1beta2.KymaSpec
-		want     []availableModuleDescription
+		want     []moduleInfo
 	}{
 		{
 			name: "When Channel \"none\" is used, then the module is invalid",
@@ -24,7 +59,7 @@ func Test_GetAvailableModules_When_ModuleInSpecOnly(t *testing.T) {
 					{Name: "Module1", Channel: "none"},
 				},
 			},
-			want: []availableModuleDescription{
+			want: []moduleInfo{
 				{
 					Module:                  v1beta2.Module{Name: "Module1", Channel: "none"},
 					Enabled:                 true,
@@ -39,7 +74,7 @@ func Test_GetAvailableModules_When_ModuleInSpecOnly(t *testing.T) {
 					{Name: "Module1", Channel: "regular", Version: "v1.0"},
 				},
 			},
-			want: []availableModuleDescription{
+			want: []moduleInfo{
 				{
 					Module:                  v1beta2.Module{Name: "Module1", Channel: "regular", Version: "v1.0"},
 					Enabled:                 true,
@@ -54,7 +89,7 @@ func Test_GetAvailableModules_When_ModuleInSpecOnly(t *testing.T) {
 					{Name: "Module1", Channel: "regular"},
 				},
 			},
-			want: []availableModuleDescription{
+			want: []moduleInfo{
 				{Module: v1beta2.Module{Name: "Module1", Channel: "regular"}, Enabled: true},
 			},
 		},
@@ -65,7 +100,7 @@ func Test_GetAvailableModules_When_ModuleInSpecOnly(t *testing.T) {
 					{Name: "Module1", Version: "v1.0"},
 				},
 			},
-			want: []availableModuleDescription{
+			want: []moduleInfo{
 				{Module: v1beta2.Module{Name: "Module1", Version: "v1.0"}, Enabled: true},
 			},
 		},
@@ -77,24 +112,24 @@ func Test_GetAvailableModules_When_ModuleInSpecOnly(t *testing.T) {
 				Spec: testcase.KymaSpec,
 			}
 
-			got := templatelookup.FindAvailableModules(kyma)
+			got := templatelookup.FetchModuleInfo(kyma)
 			if len(got) != len(testcase.want) {
-				t.Errorf("GetAvailableModules() = %v, want %v", got, testcase.want)
+				t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
 			}
 			for gi := range got {
 				if !testcase.want[gi].Equals(got[gi]) {
-					t.Errorf("GetAvailableModules() = %v, want %v", got, testcase.want)
+					t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
 				}
 			}
 		})
 	}
 }
 
-func Test_GetAvailableModules_When_ModuleInStatusOnly(t *testing.T) {
+func Test_FetchModuleInfo_When_ModuleInStatusOnly(t *testing.T) {
 	tests := []struct {
 		name       string
 		KymaStatus v1beta2.KymaStatus
-		want       []availableModuleDescription
+		want       []moduleInfo
 	}{
 		{
 			name: "When Template exists, then the module is valid",
@@ -108,7 +143,7 @@ func Test_GetAvailableModules_When_ModuleInStatusOnly(t *testing.T) {
 					},
 				},
 			},
-			want: []availableModuleDescription{
+			want: []moduleInfo{
 				{Module: v1beta2.Module{Name: "Module1", Channel: "regular", Version: "v1.0"}, Enabled: false},
 			},
 		},
@@ -124,7 +159,7 @@ func Test_GetAvailableModules_When_ModuleInStatusOnly(t *testing.T) {
 					},
 				},
 			},
-			want: []availableModuleDescription{
+			want: []moduleInfo{
 				{
 					Module:                  v1beta2.Module{Name: "Module1", Channel: "regular", Version: "v1.0"},
 					Enabled:                 false,
@@ -140,25 +175,25 @@ func Test_GetAvailableModules_When_ModuleInStatusOnly(t *testing.T) {
 				Status: testcase.KymaStatus,
 			}
 
-			got := templatelookup.FindAvailableModules(kyma)
+			got := templatelookup.FetchModuleInfo(kyma)
 			if len(got) != len(testcase.want) {
-				t.Errorf("GetAvailableModules() = %v, want %v", got, testcase.want)
+				t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
 			}
 			for gi := range got {
 				if !testcase.want[gi].Equals(got[gi]) {
-					t.Errorf("GetAvailableModules() = %v, want %v", got, testcase.want)
+					t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
 				}
 			}
 		})
 	}
 }
 
-func Test_GetAvailableModules_When_ModuleExistsInSpecAndStatus(t *testing.T) {
+func Test_FetchModuleInfo_When_ModuleExistsInSpecAndStatus(t *testing.T) {
 	tests := []struct {
 		name       string
 		KymaSpec   v1beta2.KymaSpec
 		KymaStatus v1beta2.KymaStatus
-		want       []availableModuleDescription
+		want       []moduleInfo
 	}{
 		{
 			name: "When Module have different version between Spec and Status, the output should be based on Spec",
@@ -175,7 +210,7 @@ func Test_GetAvailableModules_When_ModuleExistsInSpecAndStatus(t *testing.T) {
 					},
 				},
 			},
-			want: []availableModuleDescription{
+			want: []moduleInfo{
 				{Module: v1beta2.Module{Name: "Module1", Version: "v1.1"}, Enabled: true},
 			},
 		},
@@ -187,50 +222,50 @@ func Test_GetAvailableModules_When_ModuleExistsInSpecAndStatus(t *testing.T) {
 				Spec:   testcase.KymaSpec,
 				Status: testcase.KymaStatus,
 			}
-			got := templatelookup.FindAvailableModules(kyma)
+			got := templatelookup.FetchModuleInfo(kyma)
 			if len(got) != len(testcase.want) {
-				t.Errorf("GetAvailableModules() = %v, want %v", got, testcase.want)
+				t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
 			}
 			for gi := range got {
 				if !testcase.want[gi].Equals(got[gi]) {
-					t.Errorf("GetAvailableModules() = %v, want %v", got, testcase.want)
+					t.Errorf("FetchModuleInfo() = %v, want %v", got, testcase.want)
 				}
 			}
 		})
 	}
 }
 
-type availableModuleDescription struct {
+type moduleInfo struct {
 	Module                  v1beta2.Module
 	Enabled                 bool
 	ValidationErrorContains string
 	ExpectedError           error
 }
 
-func (amd availableModuleDescription) Equals(other templatelookup.AvailableModule) bool {
-	if amd.Module.Name != other.Name {
+func (m moduleInfo) Equals(other templatelookup.ModuleInfo) bool {
+	if m.Module.Name != other.Name {
 		return false
 	}
-	if amd.Module.Channel != other.Channel {
+	if m.Module.Channel != other.Channel {
 		return false
 	}
-	if amd.Module.Version != other.Version {
+	if m.Module.Version != other.Version {
 		return false
 	}
-	if amd.Enabled != other.Enabled {
+	if m.Enabled != other.Enabled {
 		return false
 	}
-	if amd.ExpectedError != nil && other.ValidationError == nil {
+	if m.ExpectedError != nil && other.ValidationError == nil {
 		return false
 	}
-	if amd.ExpectedError == nil && other.ValidationError != nil {
+	if m.ExpectedError == nil && other.ValidationError != nil {
 		return false
 	}
-	if amd.ExpectedError != nil && other.ValidationError != nil {
-		if !errors.Is(other.ValidationError, amd.ExpectedError) {
+	if m.ExpectedError != nil && other.ValidationError != nil {
+		if !errors.Is(other.ValidationError, m.ExpectedError) {
 			return false
 		}
-		if !strings.Contains(other.ValidationError.Error(), amd.ValidationErrorContains) {
+		if !strings.Contains(other.ValidationError.Error(), m.ValidationErrorContains) {
 			return false
 		}
 	}

pkg/templatelookup/regular.go

@@ -47,7 +47,7 @@ type ModuleTemplatesByModuleName map[string]*ModuleTemplateInfo
 
 func (t *TemplateLookup) GetRegularTemplates(ctx context.Context, kyma *v1beta2.Kyma) ModuleTemplatesByModuleName {
 	templates := make(ModuleTemplatesByModuleName)
-	for _, module := range FindAvailableModules(kyma) {
+	for _, module := range FetchModuleInfo(kyma) {
 		_, found := templates[module.Name]
 		if found {
 			continue
@@ -92,7 +92,7 @@ func (t *TemplateLookup) GetRegularTemplates(ctx context.Context, kyma *v1beta2.
 }
 
 func (t *TemplateLookup) PopulateModuleTemplateInfo(ctx context.Context,
-	module AvailableModule, namespace, kymaChannel string, moduleReleaseMeta *v1beta2.ModuleReleaseMeta,
+	module ModuleInfo, namespace, kymaChannel string, moduleReleaseMeta *v1beta2.ModuleReleaseMeta,
 ) ModuleTemplateInfo {
 	if moduleReleaseMeta == nil {
 		return t.populateModuleTemplateInfoWithoutModuleReleaseMeta(ctx, module, kymaChannel)
@@ -102,7 +102,7 @@ func (t *TemplateLookup) PopulateModuleTemplateInfo(ctx context.Context,
 }
 
 func (t *TemplateLookup) populateModuleTemplateInfoWithoutModuleReleaseMeta(ctx context.Context,
-	module AvailableModule, kymaChannel string,
+	module ModuleInfo, kymaChannel string,
 ) ModuleTemplateInfo {
 	var templateInfo ModuleTemplateInfo
 	if module.IsInstalledByVersion() {
@@ -114,7 +114,7 @@ func (t *TemplateLookup) populateModuleTemplateInfoWithoutModuleReleaseMeta(ctx
 }
 
 func (t *TemplateLookup) populateModuleTemplateInfoUsingModuleReleaseMeta(ctx context.Context,
-	module AvailableModule,
+	module ModuleInfo,
 	moduleReleaseMeta *v1beta2.ModuleReleaseMeta, kymaChannel, namespace string,
 ) ModuleTemplateInfo {
 	var templateInfo ModuleTemplateInfo

pkg/templatelookup/regular_test.go

@@ -816,7 +816,7 @@ func TestNewTemplateLookup_GetRegularTemplates_WhenModuleTemplateContainsInvalid
 		t.Run(testCase.name, func(t *testing.T) {
 			givenTemplateList := &v1beta2.ModuleTemplateList{}
 			moduleReleaseMetas := v1beta2.ModuleReleaseMetaList{}
-			for _, module := range templatelookup.FindAvailableModules(testCase.kyma) {
+			for _, module := range templatelookup.FetchModuleInfo(testCase.kyma) {
 				givenTemplateList.Items = append(givenTemplateList.Items, *builder.NewModuleTemplateBuilder().
 					WithName(fmt.Sprintf("%s-%s", module.Name, testModule.Version)).
 					WithModuleName(module.Name).
@@ -1010,7 +1010,7 @@ func TestTemplateLookup_GetRegularTemplates_WhenModuleTemplateExists(t *testing.
 		t.Run(testCase.name, func(t *testing.T) {
 			givenTemplateList := &v1beta2.ModuleTemplateList{}
 			moduleReleaseMetas := v1beta2.ModuleReleaseMetaList{}
-			for _, module := range templatelookup.FindAvailableModules(testCase.kyma) {
+			for _, module := range templatelookup.FetchModuleInfo(testCase.kyma) {
 				if testCase.mrmExist {
 					givenTemplateList.Items = append(givenTemplateList.Items, *builder.NewModuleTemplateBuilder().
 						WithName(fmt.Sprintf("%s-%s", module.Name, testModule.Version)).

pkg/testutils/moduletemplate.go

@@ -34,7 +34,7 @@ func GetModuleTemplate(ctx context.Context,
 ) (*v1beta2.ModuleTemplate, error) {
 	descriptorProvider := provider.NewCachedDescriptorProvider()
 	templateLookup := templatelookup.NewTemplateLookup(clnt, descriptorProvider)
-	availableModule := templatelookup.AvailableModule{
+	availableModule := templatelookup.ModuleInfo{
 		Module: module,
 	}