Add test cases

Author: cx-sumit-morchhale

internal/commands/scan.go

@@ -129,8 +129,6 @@ const (
 	sbomScanTypeErrMsg       = "The --sbom-only flag can only be used when the scan type is sca"
 	BranchPrimaryPrefix      = "--branch-primary="
 	OverridePolicyManagement = "override-policy-management"
-	maxSizeGB                = 5                              // 5 GB
-	maxSizeBytes             = maxSizeGB * 1024 * 1024 * 1024 // 5 GB in bytes
 )
 
 var (
@@ -155,6 +153,7 @@ var (
 	aditionalParameters []string
 	kicsErrorCodes      = []string{"60", "50", "40", "30", "20"}
 	containerResolver   wrappers.ContainerResolverWrapper
+	MaxSizeBytes        int64 = 5 * 1024 * 1024 * 1024 // 5 GB in bytes
 )
 
 func NewScanCommand(
@@ -2095,7 +2094,7 @@ func uploadZip(uploadsWrapper wrappers.UploadsWrapper, zipFilePath string, unzip
 	// check for INCREASE_FILE_UPLOAD_LIMIT feature flag
 	flagResponse, _ := wrappers.GetSpecificFeatureFlag(featureFlagsWrapper, wrappers.IncreaseFileUploadLimit)
 
-	if flagResponse.Status && fileInfo.Size() > maxSizeBytes {
+	if flagResponse.Status && fileInfo.Size() > MaxSizeBytes {
 		// File size >5GB, proceed with multipart upload
 		logger.PrintIfVerbose("File size >5GB and INCREASE_FILE_UPLOAD_LIMIT flag is enabled,hence uploading file in multiple parts...")
 		preSignedURL, zipFilePathErr = uploadsWrapper.UploadFileInMultipart(zipFilePath, featureFlagsWrapper)

internal/commands/scan_test.go

@@ -4280,3 +4280,106 @@ func TestEnforceLocalResolutionForTarFiles_Integration(t *testing.T) {
 		})
 	}
 }
+
+func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_Exceeds_5GB(t *testing.T) {
+	fileInfo, err := os.Stat("data/sources.zip")
+	if err != nil {
+		t.Fatalf("Failed to close zip file: %v", err)
+	}
+	// Simulate a file size > 5GB by setting MaxSizeBytes to less than actual size
+	MaxSizeBytes = fileInfo.Size() - 1
+	defer func() { MaxSizeBytes = 5 * 1024 * 1024 * 1024 }() // Reset after test
+
+	uploadWrapper := mock.UploadsMockWrapper{}
+	mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: true}
+	featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{}
+	url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper)
+	assert.NilError(t, err)
+	assert.Equal(t, zipPath, "")
+	assert.Equal(t, url, "multiPart/path/to/nowhere")
+}
+
+func TestUploadZip_AsMultipartUpload_when_FF_Disable_ZIP_Exceeds_5GB(t *testing.T) {
+	fileInfo, err := os.Stat("data/sources.zip")
+	if err != nil {
+		t.Fatalf("Failed to close zip file: %v", err)
+	}
+	// Simulate a file size > 5GB by setting MaxSizeBytes to less than actual size
+	MaxSizeBytes = fileInfo.Size() - 1
+	defer func() { MaxSizeBytes = 5 * 1024 * 1024 * 1024 }() // Reset after test
+
+	uploadWrapper := mock.UploadsMockWrapper{}
+	mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: false}
+	featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{}
+	url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper)
+	assert.NilError(t, err)
+	assert.Equal(t, zipPath, "")
+	assert.Equal(t, url, "singlePart/path/to/nowhere")
+}
+
+func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_LessThan_5GB(t *testing.T) {
+	uploadWrapper := mock.UploadsMockWrapper{}
+	mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: true}
+	featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{}
+	url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper)
+	assert.NilError(t, err)
+	assert.Equal(t, zipPath, "")
+	assert.Equal(t, url, "singlePart/path/to/nowhere")
+}
+
+func TestUploadZip_AsMultipartUpload_when_FF_Disable_ZIP_LessThan_5GB(t *testing.T) {
+	uploadWrapper := mock.UploadsMockWrapper{}
+	mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: false}
+	featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{}
+	url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper)
+	assert.NilError(t, err)
+	assert.Equal(t, zipPath, "")
+	assert.Equal(t, url, "singlePart/path/to/nowhere")
+}
+
+func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_Exceeds_5GB_Error(t *testing.T) {
+	// Create a temporary zip file
+	dir := t.TempDir()
+	zipPathTemp := filepath.Join(dir, "failureCaseLarge.zip")
+
+	// Create the zip file
+	zipFile, err := os.Create(zipPathTemp)
+	if err != nil {
+		t.Fatalf("Failed to create zip file: %v", err)
+	}
+	defer func(zipFile *os.File) {
+		err := zipFile.Close()
+		if err != nil {
+			t.Fatalf("Failed to close zip file: %v", err)
+		}
+	}(zipFile)
+
+	// Seek to 5KB + 1 byte
+	_, err = zipFile.Seek(5*1024+1, 0) // 5121 bytes
+	if err != nil {
+		panic("Failed to seek in zip file: " + err.Error())
+	}
+
+	// Write a single byte to allocate space
+	_, err = zipFile.Write([]byte{0})
+	if err != nil {
+		panic("Failed to write to zip file: " + err.Error())
+	}
+
+	fileInfo, err := os.Stat(zipPathTemp)
+	if err != nil {
+		t.Fatalf("Failed to close zip file: %v", err)
+	}
+
+	// Simulate a file size > 5GB by setting MaxSizeBytes to less than actual size
+	MaxSizeBytes = fileInfo.Size() - 1
+	defer func() { MaxSizeBytes = 5 * 1024 * 1024 * 1024 }() //
+
+	uploadWrapper := mock.UploadsMockWrapper{}
+	mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: true}
+	featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{}
+	_, zipPath, err := uploadZip(&uploadWrapper, zipPathTemp, false, true, featureFlagsWrapper)
+	assert.Assert(t, err != nil)
+	assert.Assert(t, strings.Contains(err.Error(), "error from UploadFileInMultipart"), err.Error())
+	assert.Equal(t, zipPath, "")
+}

internal/wrappers/mock/uploads-mock.go

@@ -14,10 +14,10 @@ type UploadsMockWrapper struct {
 
 func (u *UploadsMockWrapper) UploadFileInMultipart(filePath string, wrapper wrappers.FeatureFlagsWrapper) (*string, error) {
 	fmt.Println("UploadFileInMultipart called Create in UploadsMockWrapper")
-	if filePath == "failureCase2.zip" {
+	if strings.Contains(filePath, "failureCaseLarge.zip") {
 		return nil, errors.New("error from UploadFileInMultipart")
 	}
-	url := "/path/to/largeZipFile"
+	url := "multiPart/path/to/nowhere"
 	return &url, nil
 }
 
@@ -26,6 +26,6 @@ func (u *UploadsMockWrapper) UploadFile(filePath string, featureFlagsWrapper wra
 	if strings.Contains(filePath, "failureCase.zip") {
 		return nil, errors.New("error from UploadFile")
 	}
-	url := "/path/to/nowhere"
+	url := "singlePart/path/to/nowhere"
 	return &url, nil
 }

internal/wrappers/uploads-http.go

@@ -433,6 +433,7 @@ func getPartSizeBytes() (int64, error) {
 		logger.PrintIfVerbose(fmt.Sprintf("Configured part size %d GB is outside the allowed range (1 – 5 GB). Defaulting to 2 GB.", truncatedSize))
 		truncatedSize = 2
 	}
+	logger.PrintIfVerbose("Splitting zip file into parts of size: " + fmt.Sprintf("%.0f", float64(truncatedSize)) + " GB")
 	const bytesPerGB = 1024 * 1024 * 1024
 	return int64(float64(truncatedSize) * float64(bytesPerGB)), nil
 }

test/integration/scan_test.go

@@ -2726,3 +2726,22 @@ func TestCreateScanWithNewProjectName_Assign_Groups(t *testing.T) {
 	assert.NilError(t, err, "Groups should be assigned to newly created projects")
 
 }
+func TestCreateScan_AsMultipartUpload_Success(t *testing.T) {
+	// Simulate a file size > 5GB by setting MaxSizeBytes to less than actual size
+	commands.MaxSizeBytes = 10240                                     // 10KB less than actual file size
+	defer func() { commands.MaxSizeBytes = 5 * 1024 * 1024 * 1024 }() // Reset after test
+	args := []string{
+		"scan", "create",
+		flag(params.ProjectName), getProjectNameForScanTests(),
+		flag(params.SourcesFlag), "data/insecure.zip",
+		flag(params.BranchFlag), "dummy_branch",
+		flag(params.DebugFlag),
+	}
+	var buf bytes.Buffer
+	log.SetOutput(&buf)
+
+	err, _ := executeCommand(t, args...)
+	assert.NilError(t, err)
+	log.SetOutput(os.Stderr)
+	assert.Assert(t, strings.Contains(buf.String(), "File size >5GB and INCREASE_FILE_UPLOAD_LIMIT flag is enabled,hence uploading file in multiple parts"), "uploading file in multiple parts")
+}