added the intial changes

Signed-off-by: vviveksharma <visharma@progress.com>

Author: vviveksharma

clients/omnitruck/dynamo_services_test.go

@@ -560,6 +560,41 @@ func TestProductMetadata(t *testing.T) {
 			wantErr:      false,
 			metadata_err: nil,
 		},
+		{
+			name: "success for chef-ice windows",
+			metadata: &models.MetaData{
+				Architecture:    "x86_64",
+				FileName:        "chef-ice-x86_64-windows.zip",
+				Platform:        "windows",
+				PlatformVersion: "",
+				SHA1:            "",
+				PackageManager:  "zip",
+				SHA256:          "1234",
+			},
+			args: args{
+				p: &RequestParams{
+					Channel:         "stable",
+					Product:         "chef-ice",
+					Version:         "",
+					Platform:        "windows",
+					PlatformVersion: "",
+					PackageManager:  "zip",
+					Architecture:    "x86_64",
+					Eol:             "",
+					LicenseId:       "",
+				},
+			},
+			version:     "1.6.862",
+			version_err: nil,
+			want: PackageMetadata{
+				Sha1:    "",
+				Sha256:  "1234",
+				Url:     "",
+				Version: "1.6.862",
+			},
+			wantErr:      false,
+			metadata_err: nil,
+		},
 		{
 			name:     "failure for chef-ice",
 			metadata: &models.MetaData{},

config/config.go

@@ -11,7 +11,6 @@ type ServiceConfig struct {
 	PackageManagersTable       string           `json:"packageManagersTable"`
 	PackageDetailsCurrentTable string           `json:"packageDetailsCurrentTable"`
 	PackageDetailsStableTable  string           `json:"packageDetailsStableTable"`
-	SupportInfra19             bool             `json:"supportInfra19"`
 }
 
 type ReplicatedConfig struct {

internal/api/handler/handler_test.go

@@ -45,7 +45,6 @@ func testInjector(
 		do.ProvideNamedValue[config.ServiceConfig](reqInjector, "config", config.ServiceConfig{
 			LicenseServiceUrl: "http://licenseservice",
 			OmnitruckUrl:      "https://omnitruck.chef.io",
-			SupportInfra19:    true,
 		})
 
 		do.ProvideNamedValue[omnitruck.IRequestValidator](reqInjector, "validator", &omnitruck.MockRequestValidator{
@@ -582,7 +581,7 @@ func TestProductMetadataHandler(t *testing.T) {
 			versions_err:     nil,
 		},
 		{
-			name:             "chef-ice success",
+			name:             "chef-ice success (linux)",
 			serverMode:       constants.Trial,
 			requestPath:      "/stable/chef-ice/metadata?p=linux&m=amd64&pm=deb&eol=false&v=latest",
 			expectedStatus:   fiber.StatusOK,
@@ -601,6 +600,26 @@ func TestProductMetadataHandler(t *testing.T) {
 			versions:     []string{"latest"},
 			versions_err: nil,
 		},
+		{
+			name:             "chef-ice success (windows)",
+			serverMode:       constants.Trial,
+			requestPath:      "/stable/chef-ice/metadata?p=windows&m=amd64&pm=deb&eol=false&v=latest",
+			expectedStatus:   fiber.StatusOK,
+			expectedResponse: `{"sha1":"", "sha256":"abcd", "url":"http://example.com/stable/chef-ice/download?eol=false&m=amd64&p=windows&pm=deb&v=latest", "version":"latest"}`,
+			metadata: models.MetaData{
+				Architecture:   "amd64",
+				Platform:       "windows",
+				PackageManager: "deb",
+				SHA1:           "",
+				SHA256:         "abcd",
+				FileName:       "",
+			},
+			err:          nil,
+			version:      "latest",
+			version_err:  nil,
+			versions:     []string{"latest"},
+			versions_err: nil,
+		},
 		{
 			name:             "chef-ice failure for opensource server",
 			serverMode:       constants.Opensource,
@@ -628,7 +647,7 @@ func TestProductMetadataHandler(t *testing.T) {
 			versions_err:     nil,
 		},
 		{
-			name:             "migrate-ice success",
+			name:             "migrate-ice success (linux)",
 			serverMode:       constants.Trial,
 			requestPath:      "/stable/migrate-ice/metadata?p=linux&m=amd64&pm=deb&eol=false&v=latest",
 			expectedStatus:   fiber.StatusOK,
@@ -647,6 +666,26 @@ func TestProductMetadataHandler(t *testing.T) {
 			versions:     []string{"latest"},
 			versions_err: nil,
 		},
+		{
+			name:             "migrate-ice success (windows)",
+			serverMode:       constants.Trial,
+			requestPath:      "/stable/migrate-ice/metadata?p=windows&m=amd64&pm=zip&eol=false&v=latest",
+			expectedStatus:   fiber.StatusOK,
+			expectedResponse: `{"sha1":"", "sha256":"abcd", "url":"http://example.com/stable/migrate-ice/download?eol=false&m=amd64&p=windows&pm=zip&v=latest", "version":"latest"}`,
+			metadata: models.MetaData{
+				Architecture:   "amd64",
+				Platform:       "windows",
+				PackageManager: "deb",
+				SHA1:           "",
+				SHA256:         "abcd",
+				FileName:       "",
+			},
+			err:          nil,
+			version:      "latest",
+			version_err:  nil,
+			versions:     []string{"latest"},
+			versions_err: nil,
+		},
 		{
 			name:             "migrate-ice failure for opensource server",
 			serverMode:       constants.Opensource,
@@ -1213,6 +1252,19 @@ func TestFileNameHandler(t *testing.T) {
 			versions:         []string{"latest"},
 			versions_err:     nil,
 		},
+		{
+			name:             "migrate-ice fileName success windows",
+			serverMode:       constants.Commercial,
+			requestPath:      "/current/migrate-ice/fileName?p=windows&pv=11&m=x86_64&pm=zip&v=latest",
+			expectedStatus:   http.StatusOK,
+			expectedResponse: `{"fileName":"migrate-ice_.1.0.25-test_Windows_x86_64.zip"}`,
+			metadata:         models.MetaData{FileName: "migrate-ice_.1.0.25-test_Windows_x86_64.zip"},
+			metadata_err:     nil,
+			version:          "latest",
+			version_err:      nil,
+			versions:         []string{"latest"},
+			versions_err:     nil,
+		},
 	}
 
 	for _, test := range tests {

internal/services/services.go

@@ -99,17 +99,6 @@ func (svc *DownloadService) Products(params *omnitruck.RequestParams) (data omni
 	request = svc.Omnitruck().Products(params, &data)
 
 	data = svc.DynamoServices(svc.databaseService).Products(data, params.Eol)
-	// This a temporary fix to hide CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT when infra19Enabled is false
-	if !svc.config.SupportInfra19 {
-		// Remove CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT from the data array
-		var filtered omnitruck.ItemList
-		for _, item := range data {
-			if item != constants.CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT && item != constants.MIGRATE_ICE {
-				filtered = append(filtered, item)
-			}
-		}
-		data = filtered
-	}
 	getServerStrategy := strategy.SelectModeStrategy(svc.mode)
 	eol := params.Eol == "true"
 	data = getServerStrategy.FilterProducts(data, eol)
@@ -250,12 +239,6 @@ func (svc *DownloadService) RelatedProducts(params *omnitruck.RequestParams) (da
 		}
 	}
 
-	if !svc.config.SupportInfra19 && relatedProducts != nil && relatedProducts.Products != nil {
-		// This a temporary fix to hide CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT when supportInfra19 is false
-		delete(relatedProducts.Products, constants.CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT)
-		delete(relatedProducts.Products, constants.MIGRATE_ICE)
-	}
-
 	response := map[string]interface{}{
 		"relatedProducts": relatedProducts.Products,
 	}

internal/services/services_test.go

@@ -39,7 +39,6 @@ func buildInjector(templateRenderer template.TemplateRenderer, omnitruckURL stri
 	do.ProvideNamedValue[config.ServiceConfig](injector, "config", config.ServiceConfig{
 		LicenseServiceUrl: "http://license-service",
 		OmnitruckUrl:      omnitruckURL,
-		SupportInfra19:    true,
 	})
 	return injector
 }
@@ -363,7 +362,6 @@ func TestDownloadService_Platforms(t *testing.T) {
 	do.ProvideNamedValue[constants.ApiType](injector, "mode", constants.Commercial)
 	do.ProvideNamedValue[config.ServiceConfig](injector, "config", config.ServiceConfig{
 		OmnitruckUrl: ts.URL,
-		SupportInfra19:    true,
 	})
 
 	locals := map[string]interface{}{"license_id": "123"}
@@ -825,88 +823,6 @@ func TestDownloadService_RelatedProducts(t *testing.T) {
 	}
 }
 
-func TestDownloadService_RelatedProducts_SupportInfra19(t *testing.T) {
-	t.Parallel()
-
-	logEntry := logrus.NewEntry(logrus.New())
-	locals := map[string]interface{}{"base_url": "http://example.com"}
-
-	tests := []struct {
-		name               string
-		supportInfra19     bool
-		expectedProducts   []string
-		unexpectedProducts []string
-	}{
-		{
-			name:               "SupportInfra19 true - includes infra products",
-			supportInfra19:     true,
-			expectedProducts:   []string{"chef", "chef-ice", "migrate-ice"},
-			unexpectedProducts: []string{},
-		},
-		{
-			name:               "SupportInfra19 false - excludes infra products",
-			supportInfra19:     false,
-			expectedProducts:   []string{"chef"},
-			unexpectedProducts: []string{"chef-ice", "migrate-ice"},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			injector := do.New()
-			do.ProvideNamedValue[dboperations.IDbOperations](injector, "dbService", &dboperations.MockIDbOperations{
-				GetRelatedProductsfunc: func(partitionValue string) (*models.RelatedProducts, error) {
-					return &models.RelatedProducts{
-						Bom: "test-bom",
-						Products: map[string]string{
-							"chef":        "Chef Infra Client",
-							"chef-ice":    "Chef Infra Client Enterprise",
-							"migrate-ice": "Migrate ICE",
-							"automate":    "Chef Automate",
-						},
-					}, nil
-				},
-			})
-			do.ProvideNamedValue[template.TemplateRenderer](injector, "templateRenderer", &template.MockTemplateRenderer{})
-			do.ProvideNamedValue[replicated.IReplicated](injector, "replicated", &replicated.MockReplicated{})
-			do.ProvideNamedValue[clients.ILicense](injector, "licenseClient", &clients.MockLicense{})
-			do.ProvideNamedValue[constants.ApiType](injector, "mode", constants.Commercial)
-			do.ProvideNamedValue[config.ServiceConfig](injector, "config", config.ServiceConfig{
-				SupportInfra19: tt.supportInfra19,
-			})
-
-			svc, err := NewDownloadService(injector, logEntry, locals)
-			require.NoError(t, err)
-
-			params := &omnitruck.RequestParams{
-				BOM: "test-bom",
-			}
-
-			data, req := svc.RelatedProducts(params)
-
-			assert.True(t, req.Ok, "expected ok true")
-			assert.Equal(t, fiber.StatusOK, req.Code)
-			assert.NotNil(t, data)
-
-			products, ok := data["relatedProducts"].(map[string]string)
-			assert.True(t, ok, "expected relatedProducts to be map[string]string")
-
-			// Check expected products are present
-			for _, product := range tt.expectedProducts {
-				assert.Contains(t, products, product, "expected product %s to be present", product)
-			}
-
-			// Check unexpected products are not present
-			for _, product := range tt.unexpectedProducts {
-				assert.NotContains(t, products, product, "expected product %s to be excluded", product)
-			}
-		})
-	}
-}
-
 func TestDownloadService_GetFileName_InvalidProduct(t *testing.T) {
 	t.Parallel()
 

internal/strategy/product_strategy.go

@@ -54,9 +54,6 @@ func SelectProductStrategy(product string, channel string, deps *ProductStrategy
 			Locals:            deps.Locals,
 		}
 	case constants.CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT, constants.MIGRATE_ICE:
-		if !deps.Config.SupportInfra19 {
-			return &DefaultProductStrategy{OmnitruckService: deps.OmnitruckService}
-		}
 		if channel == constants.CURRENT_CHANNEL {
 			deps.DynamoService.SetDbInfo(deps.Config.PackageDetailsCurrentTable, reflect.TypeOf(models.PackageDetails{}))
 		} else {

internal/strategy/product_strategy_test.go

@@ -33,7 +33,6 @@ func TestSelectProductStrategy(t *testing.T) {
 			PackageDetailsCurrentTable: "mock_current_table",
 			PackageDetailsStableTable:  "mock_stable_table",
 			AWSConfig:                  config.AWSConfig{},
-			SupportInfra19:             true,
 		},
 	}
 
@@ -115,85 +114,3 @@ func TestSelectProductStrategy(t *testing.T) {
 	}
 }
 
-func TestSelectProductStrategy_SupportInfra19(t *testing.T) {
-	mockDynamo := &omnitruck.MockDynamoServices{}
-	mockPlatform := &omnitruck.PlatformServices{}
-	mockOmnitruck := &omnitruck.Omnitruck{}
-	mockLog := log.NewEntry(log.New())
-
-	tests := []struct {
-		name           string
-		product        string
-		channel        string
-		supportInfra19 bool
-		expectedType   reflect.Type
-		expectDbInfo   bool
-	}{
-		{
-			name:           "infra product with SupportInfra19=true should return InfraProductStrategy",
-			product:        constants.CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT,
-			channel:        constants.CURRENT_CHANNEL,
-			supportInfra19: true,
-			expectedType:   reflect.TypeOf(&strategy.InfraProductStrategy{}),
-			expectDbInfo:   true,
-		},
-		{
-			name:           "infra product with SupportInfra19=false should return DefaultProductStrategy",
-			product:        constants.CHEF_INFRA_CLIENT_ENTERPRISE_PRODUCT,
-			channel:        constants.CURRENT_CHANNEL,
-			supportInfra19: false,
-			expectedType:   reflect.TypeOf(&strategy.DefaultProductStrategy{}),
-			expectDbInfo:   false,
-		},
-		{
-			name:           "migrate ice with SupportInfra19=true should return InfraProductStrategy",
-			product:        constants.MIGRATE_ICE,
-			channel:        constants.STABLE_CHANNEL,
-			supportInfra19: true,
-			expectedType:   reflect.TypeOf(&strategy.InfraProductStrategy{}),
-			expectDbInfo:   true,
-		},
-		{
-			name:           "migrate ice with SupportInfra19=false should return DefaultProductStrategy",
-			product:        constants.MIGRATE_ICE,
-			channel:        constants.STABLE_CHANNEL,
-			supportInfra19: false,
-			expectedType:   reflect.TypeOf(&strategy.DefaultProductStrategy{}),
-			expectDbInfo:   false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Reset mock for each test
-			mockDynamo.SetDbInfoCalledWith = nil
-
-			deps := &strategy.ProductStrategyDeps{
-				DynamoService:     mockDynamo,
-				PlatformService:   mockPlatform,
-				OmnitruckService:  mockOmnitruck,
-				Log:               mockLog,
-				Replicated:        nil,
-				LicenseClient:     nil,
-				LicenseServiceUrl: "http://mock-license",
-				Mode:              constants.Opensource,
-				Config: config.ServiceConfig{
-					MetadataDetailsTable:       "mock_metadata_table",
-					PackageDetailsCurrentTable: "mock_current_table",
-					PackageDetailsStableTable:  "mock_stable_table",
-					AWSConfig:                  config.AWSConfig{},
-					SupportInfra19:             tt.supportInfra19,
-				},
-			}
-
-			strat := strategy.SelectProductStrategy(tt.product, tt.channel, deps)
-			assert.Equal(t, tt.expectedType, reflect.TypeOf(strat))
-
-			if tt.expectDbInfo {
-				assert.NotEmpty(t, mockDynamo.SetDbInfoCalledWith, "expected SetDbInfo to be called when SupportInfra19=true")
-			} else {
-				assert.Empty(t, mockDynamo.SetDbInfoCalledWith, "expected SetDbInfo NOT to be called when SupportInfra19=false")
-			}
-		})
-	}
-}