feat: add a forced status of premium instance

Required for use cases where user token does not have admin permissions

Author: BoxBoxJason

.gitignore

@@ -64,3 +64,4 @@ unit-tests.xml
 coverage.out
 .scannerwork/
 *-report*
+.sonarlint/

cmd/main.go

@@ -77,6 +77,7 @@ func main() {
 	rootCmd.Flags().StringVar(&args.DestinationGitlabURL, "destination-url", os.Getenv("DESTINATION_GITLAB_URL"), "Destination GitLab URL")
 	rootCmd.Flags().StringVar(&args.DestinationGitlabToken, "destination-token", os.Getenv("DESTINATION_GITLAB_TOKEN"), "Destination GitLab Token")
 	rootCmd.Flags().BoolVar(&args.DestinationGitlabIsBig, "destination-big", strings.TrimSpace(os.Getenv("DESTINATION_GITLAB_BIG")) != "", "Destination GitLab is a big instance")
+	rootCmd.Flags().BoolVarP(&args.DestinationGitlabForcePremium, "destination-force-premium", "p", false, "Force the destination GitLab to be treated as a premium instance")
 	rootCmd.Flags().BoolVarP(&args.Verbose, "verbose", "v", false, "Enable verbose output")
 	rootCmd.Flags().BoolVarP(&args.NoPrompt, "no-prompt", "n", strings.TrimSpace(os.Getenv("NO_PROMPT")) != "", "Disable prompting for missing values")
 	rootCmd.Flags().StringVar(&mirrorMappingPath, "mirror-mapping", os.Getenv("MIRROR_MAPPING"), "Path to the mirror mapping file")

internal/mirroring/get_test.go

@@ -6,6 +6,10 @@ import (
 	"testing"
 )
 
+const (
+	EXPECTED_ERROR_MESSAGE = "expected error: %v, got: %v"
+)
+
 func TestCheckPathMatchesFilters(t *testing.T) {
 	tests := []struct {
 		name           string
@@ -112,7 +116,7 @@ func TestGetParentNamespaceID(t *testing.T) {
 
 			// Check if an error was expected
 			if (err != nil) != test.expectedError {
-				t.Errorf("expected error: %v, got: %v", test.expectedError, err)
+				t.Errorf(EXPECTED_ERROR_MESSAGE, test.expectedError, err)
 			}
 		})
 	}
@@ -180,7 +184,7 @@ func TestFetchAll(t *testing.T) {
 
 			// Check if an error was expected
 			if (err != nil) != test.expectedError {
-				t.Errorf("expected error: %v, got: %v", test.expectedError, err)
+				t.Errorf(EXPECTED_ERROR_MESSAGE, test.expectedError, err)
 			}
 
 			//Check if the instance cache contains the expected projects and groups
@@ -261,7 +265,7 @@ func TestIsVersionGreaterThanThreshold(t *testing.T) {
 
 			thresholdOk, err := gitlabInstance.IsVersionGreaterThanThreshold()
 			if (err != nil) != test.expectedError {
-				t.Fatalf("expected error: %v, got: %v", test.expectedError, err)
+				t.Fatalf(EXPECTED_ERROR_MESSAGE, test.expectedError, err)
 			}
 			if thresholdOk != test.expectedResponse {
 				t.Errorf("expected thresholdOk: %v, got: %v", test.expectedResponse, thresholdOk)
@@ -327,7 +331,7 @@ func TestIsLicensePremium(t *testing.T) {
 
 			isPremium, err := gitlabInstance.IsLicensePremium()
 			if (err != nil) != test.expectedError {
-				t.Fatalf("expected error: %v, got: %v", test.expectedError, err)
+				t.Fatalf(EXPECTED_ERROR_MESSAGE, test.expectedError, err)
 			}
 			if isPremium != test.expectedResponse {
 				t.Errorf("expected isPremium: %v, got: %v", test.expectedResponse, isPremium)

internal/mirroring/main.go

@@ -48,7 +48,7 @@ func MirrorGitlabs(gitlabMirrorArgs *utils.ParserArgs) []error {
 	if err != nil {
 		return []error{err}
 	}
-	pullMirrorAvailable, err := destinationGitlabInstance.IsPullMirrorAvailable()
+	pullMirrorAvailable, err := destinationGitlabInstance.IsPullMirrorAvailable(gitlabMirrorArgs.DestinationGitlabForcePremium)
 	if err != nil {
 		return []error{err}
 	} else if pullMirrorAvailable {
@@ -178,7 +178,7 @@ func (destinationGitlabInstance *GitlabInstance) DryRunReleases(sourceGitlabInst
 }
 
 // IsPullMirrorAvailable checks the destination GitLab instance for version and license compatibility.
-func (g *GitlabInstance) IsPullMirrorAvailable() (bool, error) {
+func (g *GitlabInstance) IsPullMirrorAvailable(forcePremium bool) (bool, error) {
 	zap.L().Info("Checking destination GitLab instance")
 	thresholdOk, err := g.IsVersionGreaterThanThreshold()
 	if err != nil {
@@ -187,8 +187,10 @@ func (g *GitlabInstance) IsPullMirrorAvailable() (bool, error) {
 
 	isPremium, err := g.IsLicensePremium()
 	if err != nil {
-		return false, fmt.Errorf("failed to check if destination GitLab instance is premium: %w", err)
+		if !forcePremium {
+			return false, fmt.Errorf("failed to check if destination GitLab instance is premium: %w", err)
+		}
 	}
 
-	return thresholdOk && isPremium, nil
+	return thresholdOk && (isPremium || forcePremium), nil
 }

internal/mirroring/main_test.go

@@ -175,53 +175,63 @@ func TestDryRun(t *testing.T) {
 }
 
 func TestIsPullMirrorAvailable(t *testing.T) {
+	const supportedVersion = "18.0.0"
+	const unsupportedVersion = "17.0.0"
 	tests := []struct {
 		name           string
 		licensePlan    string
 		version        string
 		expectedError  bool
 		expectedResult bool
+		forcePremium   bool
 	}{
 		{
 			name:           "Premium license, good version",
 			licensePlan:    PREMIUM_PLAN,
-			version:        "18.0.0",
+			version:        supportedVersion,
 			expectedResult: true,
 		},
 		{
 			name:           "Ultimate license, good version",
 			licensePlan:    ULTIMATE_PLAN,
-			version:        "18.0.0",
+			version:        supportedVersion,
 			expectedResult: true,
 		},
 		{
 			name:           "Free license, good version",
 			licensePlan:    "free",
-			version:        "18.0.0",
+			version:        supportedVersion,
 			expectedResult: false,
 		},
+		{
+			name:           "Free license, good version, force premium",
+			licensePlan:    "free",
+			version:        supportedVersion,
+			expectedResult: true,
+			forcePremium:   true,
+		},
 		{
 			name:           "Premium license, bad version",
 			licensePlan:    PREMIUM_PLAN,
-			version:        "17.0.0",
+			version:        unsupportedVersion,
 			expectedResult: false,
 		},
 		{
 			name:           "Ultimate license, bad version",
 			licensePlan:    ULTIMATE_PLAN,
-			version:        "17.0.0",
+			version:        unsupportedVersion,
 			expectedResult: false,
 		},
 		{
 			name:           "Bad license, good version",
 			licensePlan:    "bad_license",
-			version:        "18.0.0",
+			version:        supportedVersion,
 			expectedResult: false,
 		},
 		{
 			name:           "Bad license, bad version",
 			licensePlan:    "bad_license",
-			version:        "17.0.0",
+			version:        unsupportedVersion,
 			expectedResult: false,
 		},
 		{
@@ -247,7 +257,7 @@ func TestIsPullMirrorAvailable(t *testing.T) {
 				})
 			}
 
-			pullMirrorAvailable, err := gitlabInstance.IsPullMirrorAvailable()
+			pullMirrorAvailable, err := gitlabInstance.IsPullMirrorAvailable(tt.forcePremium)
 			if (err != nil) != tt.expectedError {
 				t.Fatalf("CheckDestinationInstance() error = %v, expectedError %v", err, tt.expectedError)
 			}

internal/mirroring/post_test.go

@@ -212,7 +212,7 @@ func TestCreateProjects(t *testing.T) {
 			},
 		}
 		err := destinationGitlabInstance.createProjects(sourceGitlabInstance, mirrorMapping)
-		if err != nil && len(err) > 0 {
+		if len(err) > 0 {
 			t.Errorf("Unexpected error when creating projects: %v", err)
 		}
 		if len(destinationGitlabInstance.Projects) == 0 {

internal/utils/types.go

@@ -33,17 +33,18 @@ const (
 // - version: whether to show the version
 // - retry: the number of retries for the GitLab API requests
 type ParserArgs struct {
-	SourceGitlabURL        string
-	SourceGitlabToken      string
-	SourceGitlabIsBig      bool
-	DestinationGitlabURL   string
-	DestinationGitlabToken string
-	DestinationGitlabIsBig bool
-	MirrorMapping          *MirrorMapping
-	Verbose                bool
-	NoPrompt               bool
-	DryRun                 bool
-	Retry                  int
+	SourceGitlabURL               string
+	SourceGitlabToken             string
+	SourceGitlabIsBig             bool
+	DestinationGitlabURL          string
+	DestinationGitlabToken        string
+	DestinationGitlabIsBig        bool
+	DestinationGitlabForcePremium bool
+	MirrorMapping                 *MirrorMapping
+	Verbose                       bool
+	NoPrompt                      bool
+	DryRun                        bool
+	Retry                         int
 }
 
 // ProjectMirrorOptions defines how the project should be mirrored
@@ -72,25 +73,33 @@ type MirrorMapping struct {
 	muGroups   sync.RWMutex
 }
 
+// AddProject adds a project to the mapping
+// It takes the project name and the mirroring options as parameters
+// It locks the projects mutex to ensure thread safety
 func (m *MirrorMapping) AddProject(project string, options *MirroringOptions) {
 	m.muProjects.Lock()
 	defer m.muProjects.Unlock()
 	m.Projects[project] = options
 }
 
+// AddGroup adds a group to the mapping
+// It takes the group name and the mirroring options as parameters
+// It locks the groups mutex to ensure thread safety
 func (m *MirrorMapping) AddGroup(group string, options *MirroringOptions) {
 	m.muGroups.Lock()
 	defer m.muGroups.Unlock()
 	m.Groups[group] = options
 }
 
+// GetProject retrieves the mirroring options for a project
 func (m *MirrorMapping) GetProject(project string) (*MirroringOptions, bool) {
 	m.muProjects.RLock()
 	defer m.muProjects.RUnlock()
 	options, ok := m.Projects[project]
 	return options, ok
 }
 
+// GetGroup retrieves the mirroring options for a group
 func (m *MirrorMapping) GetGroup(group string) (*MirroringOptions, bool) {
 	m.muGroups.RLock()
 	defer m.muGroups.RUnlock()
@@ -167,6 +176,9 @@ func (m *MirrorMapping) checkProjects(errChan chan error) {
 	}
 }
 
+// checkCopyPaths checks if the source and destination paths are valid
+// It checks if the paths are not empty, do not start or end with a slash,
+// and if the destination path is in a namespace for projects
 func checkCopyPaths(sourcePath string, destinationPath string, pathType string, errChan chan error) {
 	// Ensure the source project path and destination path are not empty
 	if sourcePath == "" || destinationPath == "" {
@@ -191,6 +203,8 @@ func checkCopyPaths(sourcePath string, destinationPath string, pathType string,
 	}
 }
 
+// checkGroups checks if the groups are valid
+// It checks if the group names and destination paths are valid
 func (m *MirrorMapping) checkGroups(errChan chan error) {
 	duplicateDestinationFinder := make(map[string]struct{}, len(m.Groups))
 	for group, options := range m.Groups {
@@ -212,6 +226,8 @@ func (m *MirrorMapping) checkGroups(errChan chan error) {
 	}
 }
 
+// checkVisibility checks if the visibility string is valid
+// It checks if the visibility string is one of the valid GitLab visibility values
 func checkVisibility(visibility string) bool {
 	var valid bool
 	switch visibility {
@@ -227,6 +243,8 @@ func checkVisibility(visibility string) bool {
 	return valid
 }
 
+// ConvertVisibility converts a visibility string to a gitlab.VisibilityValue
+// It returns the corresponding gitlab.VisibilityValue or gitlab.PublicVisibility if the string is invalid
 func ConvertVisibility(visibility string) gitlab.VisibilityValue {
 	switch visibility {
 	case string(gitlab.PublicVisibility):
@@ -240,6 +258,8 @@ func ConvertVisibility(visibility string) gitlab.VisibilityValue {
 	}
 }
 
+// StringArraysMatchValues checks if two string arrays match in values
+// It returns true if both arrays have the same values, regardless of order
 func StringArraysMatchValues(array1 []string, array2 []string) bool {
 	if len(array1) != len(array2) {
 		return false

internal/utils/types_test.go

@@ -396,7 +396,7 @@ func TestCheckVisibility(t *testing.T) {
 	}
 }
 
-func TestMirrorMapping_GetProject(t *testing.T) {
+func TestMirrorMappingGetProject(t *testing.T) {
 	// Prepare a mirror mapping with some project entries
 	opts1 := &MirroringOptions{
 		DestinationPath:     "dest1",
@@ -463,7 +463,7 @@ func TestMirrorMapping_GetProject(t *testing.T) {
 	}
 }
 
-func TestMirrorMapping_GetGroup(t *testing.T) {
+func TestMirrorMappingGetGroup(t *testing.T) {
 	// Prepare a mirror mapping with some group entries
 	optsA := &MirroringOptions{
 		DestinationPath:     "groupDestA",