From a5b1a715f3cbf6a4cd48e06b2987c40540a0e47e Mon Sep 17 00:00:00 2001 From: Wallace Breza Date: Tue, 18 Nov 2025 17:58:28 -0800 Subject: [PATCH 1/2] Added helper func to get infra config with defaults applied --- cli/azd/internal/cmd/add/add.go | 19 +- .../provisioning/bicep/bicep_provider.go | 30 +- cli/azd/pkg/infra/provisioning/manager.go | 9 +- cli/azd/pkg/infra/provisioning/provider.go | 26 ++ .../pkg/infra/provisioning/provider_test.go | 355 ++++++++++++++++++ .../terraform/terraform_provider.go | 10 +- cli/azd/pkg/project/dotnet_importer.go | 7 +- cli/azd/pkg/project/importer.go | 20 +- .../project/service_target_containerapp.go | 20 +- 9 files changed, 446 insertions(+), 50 deletions(-) create mode 100644 cli/azd/pkg/infra/provisioning/provider_test.go diff --git a/cli/azd/internal/cmd/add/add.go b/cli/azd/internal/cmd/add/add.go index 092bf878873..db0d52d6051 100644 --- a/cli/azd/internal/cmd/add/add.go +++ b/cli/azd/internal/cmd/add/add.go @@ -14,7 +14,6 @@ import ( "slices" "strings" - "dario.cat/mergo" "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" "github.com/azure/azure-dev/cli/azd/cmd/actions" "github.com/azure/azure-dev/cli/azd/internal" @@ -285,11 +284,12 @@ func (a *AddAction) Run(ctx context.Context) (*actions.ActionResult, error) { SuccessMessage: "azure.yaml updated.", }) - mergedOptions := provisioning.Options{} - mergo.Merge(&mergedOptions, prjConfig.Infra) - mergo.Merge(&mergedOptions, project.DefaultProvisioningOptions) + infraOptions, err := prjConfig.Infra.GetWithDefaults() + if err != nil { + return nil, fmt.Errorf("getting infra options: %w", err) + } - infraRoot := mergedOptions.Path + infraRoot := infraOptions.Path if !filepath.IsAbs(infraRoot) { infraRoot = filepath.Join(prjConfig.Path, infraRoot) } @@ -302,7 +302,7 @@ func (a *AddAction) Run(ctx context.Context) (*actions.ActionResult, error) { "\nRun '%s' to add a secret to the key vault.", output.WithHighLightFormat("azd env set-secret ")) - if _, err := pathHasInfraModule(infraRoot, mergedOptions.Module); err == nil { + if _, err := pathHasInfraModule(infraRoot, infraOptions.Module); err == nil { followUpMessage = fmt.Sprintf( "Run '%s' to re-generate the infrastructure, "+ "then run '%s' to provision these changes anytime later.", @@ -403,9 +403,10 @@ func ensureCompatibleProject( } } - mergedOptions := provisioning.Options{} - mergo.Merge(&mergedOptions, prjConfig.Infra) - mergo.Merge(&mergedOptions, project.DefaultProvisioningOptions) + mergedOptions, err := prjConfig.Infra.GetWithDefaults() + if err != nil { + return err + } infraRoot := mergedOptions.Path if !filepath.IsAbs(infraRoot) { diff --git a/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go b/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go index 2406a37040a..1dcd3bbe71d 100644 --- a/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go +++ b/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go @@ -20,7 +20,6 @@ import ( "strings" "time" - "dario.cat/mergo" "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/cognitiveservices/armcognitiveservices" @@ -96,33 +95,34 @@ func (p *BicepProvider) Name() string { // Initialize initializes provider state from the options. // It also calls EnsureEnv, which ensures the client-side state is ready for provisioning. func (p *BicepProvider) Initialize(ctx context.Context, projectPath string, opt provisioning.Options) error { - mergedOptions := provisioning.Options{} - mergo.Merge(&mergedOptions, opt) - mergo.Merge(&mergedOptions, defaultOptions) + infraOptions, err := opt.GetWithDefaults() + if err != nil { + return err + } - if !filepath.IsAbs(mergedOptions.Path) { - mergedOptions.Path = filepath.Join(projectPath, mergedOptions.Path) + if !filepath.IsAbs(infraOptions.Path) { + infraOptions.Path = filepath.Join(projectPath, infraOptions.Path) } - bicepparam := mergedOptions.Module + ".bicepparam" - bicepFile := mergedOptions.Module + ".bicep" + bicepparam := infraOptions.Module + ".bicepparam" + bicepFile := infraOptions.Module + ".bicep" // Check if there's a .bicepparam first. It will be preferred over a .bicep - if _, err := os.Stat(filepath.Join(mergedOptions.Path, bicepparam)); err == nil { - p.path = filepath.Join(mergedOptions.Path, bicepparam) + if _, err := os.Stat(filepath.Join(infraOptions.Path, bicepparam)); err == nil { + p.path = filepath.Join(infraOptions.Path, bicepparam) p.mode = bicepparamMode } else { - p.path = filepath.Join(mergedOptions.Path, bicepFile) + p.path = filepath.Join(infraOptions.Path, bicepFile) p.mode = bicepMode } p.projectPath = projectPath - p.layer = mergedOptions.Name - p.options = mergedOptions - p.ignoreDeploymentState = mergedOptions.IgnoreDeploymentState + p.layer = infraOptions.Name + p.options = infraOptions + p.ignoreDeploymentState = infraOptions.IgnoreDeploymentState p.console.ShowSpinner(ctx, "Initialize bicep provider", input.Step) - err := p.EnsureEnv(ctx) + err = p.EnsureEnv(ctx) p.console.StopSpinner(ctx, "", input.Step) return err } diff --git a/cli/azd/pkg/infra/provisioning/manager.go b/cli/azd/pkg/infra/provisioning/manager.go index 27c59a17dd8..4878b03d95c 100644 --- a/cli/azd/pkg/infra/provisioning/manager.go +++ b/cli/azd/pkg/infra/provisioning/manager.go @@ -11,7 +11,6 @@ import ( "os" "path/filepath" - "dario.cat/mergo" "github.com/azure/azure-dev/cli/azd/pkg/alpha" "github.com/azure/azure-dev/cli/azd/pkg/azapi" "github.com/azure/azure-dev/cli/azd/pkg/azsdk/storage" @@ -51,12 +50,10 @@ var ( ) func (m *Manager) Initialize(ctx context.Context, projectPath string, options Options) error { - mergedOptions := Options{} - mergo.Merge(&mergedOptions, options) - mergo.Merge(&mergedOptions, defaultOptions) + infraOptions, err := options.GetWithDefaults() m.projectPath = projectPath - m.options = &mergedOptions + m.options = &infraOptions provider, err := m.newProvider(ctx) if err != nil { @@ -64,7 +61,7 @@ func (m *Manager) Initialize(ctx context.Context, projectPath string, options Op } m.provider = provider - return m.provider.Initialize(ctx, projectPath, mergedOptions) + return m.provider.Initialize(ctx, projectPath, infraOptions) } // Parameters gets the list of parameters and its value which will be used to provision the infrastructure. diff --git a/cli/azd/pkg/infra/provisioning/provider.go b/cli/azd/pkg/infra/provisioning/provider.go index 24a82941913..ac68aeacd01 100644 --- a/cli/azd/pkg/infra/provisioning/provider.go +++ b/cli/azd/pkg/infra/provisioning/provider.go @@ -7,6 +7,8 @@ import ( "context" "fmt" "strings" + + "dario.cat/mergo" ) type ProviderKind string @@ -34,6 +36,30 @@ type Options struct { Layers []Options `yaml:"layers,omitempty"` } +// GetWithDefaults merges the provided infra options with the default provisioning options +func (o Options) GetWithDefaults(other ...Options) (Options, error) { + mergedOptions := Options{} + + // Merge in the provided infra options first + if err := mergo.Merge(&mergedOptions, o); err != nil { + return Options{}, fmt.Errorf("merging infra options: %w", err) + } + + // Merge in any other provided options + for _, opt := range other { + if err := mergo.Merge(&mergedOptions, opt); err != nil { + return Options{}, fmt.Errorf("merging other options: %w", err) + } + } + + // Finally, merge in the default provisioning options + if err := mergo.Merge(&mergedOptions, defaultOptions); err != nil { + return Options{}, fmt.Errorf("merging default infra options: %w", err) + } + + return mergedOptions, nil +} + // GetLayers return the provisioning layers defined. // When [Options.Layers] is not defined, it returns the single layer defined. // diff --git a/cli/azd/pkg/infra/provisioning/provider_test.go b/cli/azd/pkg/infra/provisioning/provider_test.go new file mode 100644 index 00000000000..c42f974396c --- /dev/null +++ b/cli/azd/pkg/infra/provisioning/provider_test.go @@ -0,0 +1,355 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package provisioning + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestOptions_GetWithDefaults(t *testing.T) { + // Save original defaultOptions and restore after tests + originalDefaults := defaultOptions + t.Cleanup(func() { + defaultOptions = originalDefaults + }) + + // Set test default options + defaultOptions = Options{ + Provider: Bicep, + Module: "main", + Path: "infra", + } + + tests := []struct { + name string + baseOptions Options + otherOptions []Options + expectedResult Options + expectError bool + }{ + { + name: "merges base options with defaults", + baseOptions: Options{ + Provider: Terraform, + Path: "custom-infra", + }, + otherOptions: nil, + expectedResult: Options{ + Provider: Terraform, + Module: "main", + Path: "custom-infra", + }, + expectError: false, + }, + { + name: "empty base options uses defaults", + baseOptions: Options{}, + otherOptions: nil, + expectedResult: Options{ + Provider: Bicep, + Module: "main", + Path: "infra", + }, + expectError: false, + }, + { + name: "merges multiple other options in order (first non-empty value wins)", + baseOptions: Options{ + Provider: Terraform, + }, + otherOptions: []Options{ + { + Path: "infra-override-1", + Module: "module-1", + }, + { + Module: "module-2", + Name: "layer-1", + }, + }, + expectedResult: Options{ + Provider: Terraform, + Path: "infra-override-1", + Module: "module-1", // First other option wins for Module + Name: "layer-1", + }, + expectError: false, + }, + { + name: "base options take precedence over other options", + baseOptions: Options{ + Provider: Pulumi, + Path: "base-path", + }, + otherOptions: []Options{ + { + Provider: Bicep, + Path: "other-path", + Module: "other-module", + }, + }, + expectedResult: Options{ + Provider: Pulumi, + Path: "base-path", + Module: "other-module", + }, + expectError: false, + }, + { + name: "defaults fill in missing fields", + baseOptions: Options{ + Name: "custom-name", + }, + otherOptions: []Options{ + { + Module: "custom-module", + }, + }, + expectedResult: Options{ + Provider: Bicep, + Module: "custom-module", + Path: "infra", + Name: "custom-name", + }, + expectError: false, + }, + { + name: "merges deployment stacks", + baseOptions: Options{ + Provider: Bicep, + DeploymentStacks: map[string]any{ + "stack1": "value1", + }, + }, + otherOptions: []Options{ + { + DeploymentStacks: map[string]any{ + "stack2": "value2", + }, + }, + }, + expectedResult: Options{ + Provider: Bicep, + Module: "main", + Path: "infra", + DeploymentStacks: map[string]any{ + "stack1": "value1", + "stack2": "value2", + }, + }, + expectError: false, + }, + { + name: "preserves IgnoreDeploymentState flag", + baseOptions: Options{ + Provider: Terraform, + IgnoreDeploymentState: true, + }, + otherOptions: nil, + expectedResult: Options{ + Provider: Terraform, + Module: "main", + Path: "infra", + IgnoreDeploymentState: true, + }, + expectError: false, + }, + { + name: "handles layers in base options", + baseOptions: Options{ + Layers: []Options{ + { + Provider: Bicep, + Name: "layer-1", + Path: "layer1-path", + }, + { + Provider: Terraform, + Name: "layer-2", + Path: "layer2-path", + }, + }, + }, + otherOptions: nil, + expectedResult: Options{ + Provider: Bicep, + Module: "main", + Path: "infra", + Layers: []Options{ + { + Provider: Bicep, + Name: "layer-1", + Path: "layer1-path", + }, + { + Provider: Terraform, + Name: "layer-2", + Path: "layer2-path", + }, + }, + }, + expectError: false, + }, + { + name: "all fields specified overrides defaults completely", + baseOptions: Options{ + Provider: Arm, + Path: "custom-path", + Module: "custom-module", + Name: "custom-name", + DeploymentStacks: map[string]any{ + "key": "value", + }, + IgnoreDeploymentState: true, + }, + otherOptions: nil, + expectedResult: Options{ + Provider: Arm, + Path: "custom-path", + Module: "custom-module", + Name: "custom-name", + DeploymentStacks: map[string]any{ + "key": "value", + }, + IgnoreDeploymentState: true, + }, + expectError: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := tt.baseOptions.GetWithDefaults(tt.otherOptions...) + + if tt.expectError { + require.Error(t, err) + } else { + require.NoError(t, err) + assert.Equal(t, tt.expectedResult.Provider, result.Provider, "Provider mismatch") + assert.Equal(t, tt.expectedResult.Path, result.Path, "Path mismatch") + assert.Equal(t, tt.expectedResult.Module, result.Module, "Module mismatch") + assert.Equal(t, tt.expectedResult.Name, result.Name, "Name mismatch") + assert.Equal( + t, + tt.expectedResult.IgnoreDeploymentState, + result.IgnoreDeploymentState, + "IgnoreDeploymentState mismatch", + ) + + if tt.expectedResult.DeploymentStacks != nil { + assert.Equal( + t, + tt.expectedResult.DeploymentStacks, + result.DeploymentStacks, + "DeploymentStacks mismatch", + ) + } + + if tt.expectedResult.Layers != nil { + require.Len(t, result.Layers, len(tt.expectedResult.Layers), "Layers length mismatch") + for i, expectedLayer := range tt.expectedResult.Layers { + assert.Equal(t, expectedLayer.Provider, result.Layers[i].Provider) + assert.Equal(t, expectedLayer.Name, result.Layers[i].Name) + assert.Equal(t, expectedLayer.Path, result.Layers[i].Path) + } + } + } + }) + } +} + +func TestOptions_GetWithDefaults_MergePrecedence(t *testing.T) { + // Save original defaultOptions and restore after tests + originalDefaults := defaultOptions + t.Cleanup(func() { + defaultOptions = originalDefaults + }) + + // Set test default options + defaultOptions = Options{ + Provider: Bicep, + Module: "default-module", + Path: "default-path", + } + + t.Run("verifies merge precedence order: base > other > defaults", func(t *testing.T) { + baseOptions := Options{ + Provider: Terraform, + } + + otherOptions := []Options{ + { + Module: "other-module", + }, + } + + result, err := baseOptions.GetWithDefaults(otherOptions...) + require.NoError(t, err) + + // Base option (Terraform) should win over default (Bicep) + assert.Equal(t, Terraform, result.Provider) + // Other option (other-module) should win over default (default-module) + assert.Equal(t, "other-module", result.Module) + // Default (default-path) should be used when not specified elsewhere + assert.Equal(t, "default-path", result.Path) + }) +} + +func TestOptions_GetWithDefaults_EmptyVariations(t *testing.T) { + // Save original defaultOptions and restore after tests + originalDefaults := defaultOptions + t.Cleanup(func() { + defaultOptions = originalDefaults + }) + + defaultOptions = Options{ + Provider: Bicep, + Module: "main", + Path: "infra", + } + + t.Run("handles nil other options", func(t *testing.T) { + baseOptions := Options{ + Provider: Terraform, + } + + result, err := baseOptions.GetWithDefaults(nil...) + require.NoError(t, err) + assert.Equal(t, Terraform, result.Provider) + assert.Equal(t, "main", result.Module) + assert.Equal(t, "infra", result.Path) + }) + + t.Run("handles empty other options slice", func(t *testing.T) { + baseOptions := Options{ + Provider: Pulumi, + } + + result, err := baseOptions.GetWithDefaults([]Options{}...) + require.NoError(t, err) + assert.Equal(t, Pulumi, result.Provider) + assert.Equal(t, "main", result.Module) + assert.Equal(t, "infra", result.Path) + }) + + t.Run("handles empty options in other slice", func(t *testing.T) { + baseOptions := Options{ + Provider: Arm, + } + + otherOptions := []Options{ + {}, + {}, + } + + result, err := baseOptions.GetWithDefaults(otherOptions...) + require.NoError(t, err) + assert.Equal(t, Arm, result.Provider) + assert.Equal(t, "main", result.Module) + assert.Equal(t, "infra", result.Path) + }) +} diff --git a/cli/azd/pkg/infra/provisioning/terraform/terraform_provider.go b/cli/azd/pkg/infra/provisioning/terraform/terraform_provider.go index 1776154eff8..c3b164f2256 100644 --- a/cli/azd/pkg/infra/provisioning/terraform/terraform_provider.go +++ b/cli/azd/pkg/infra/provisioning/terraform/terraform_provider.go @@ -14,7 +14,6 @@ import ( "slices" "strings" - "dario.cat/mergo" "github.com/azure/azure-dev/cli/azd/internal" "github.com/azure/azure-dev/cli/azd/pkg/environment" "github.com/azure/azure-dev/cli/azd/pkg/infra/provisioning" @@ -83,12 +82,13 @@ func NewTerraformProvider( } func (t *TerraformProvider) Initialize(ctx context.Context, projectPath string, options provisioning.Options) error { - mergedOptions := provisioning.Options{} - mergo.Merge(&mergedOptions, options) - mergo.Merge(&mergedOptions, defaultOptions) + infraOptions, err := options.GetWithDefaults(defaultOptions) + if err != nil { + return fmt.Errorf("merging terraform provider options: %w", err) + } t.projectPath = projectPath - t.options = mergedOptions + t.options = infraOptions requiredTools := t.RequiredExternalTools() if err := tools.EnsureInstalled(ctx, requiredTools...); err != nil { diff --git a/cli/azd/pkg/project/dotnet_importer.go b/cli/azd/pkg/project/dotnet_importer.go index fd8315b9fa9..2fc46d183a2 100644 --- a/cli/azd/pkg/project/dotnet_importer.go +++ b/cli/azd/pkg/project/dotnet_importer.go @@ -334,11 +334,16 @@ func (ai *DotNetImporter) Services( var dOptions DockerProjectOptions if bContainer.Build != nil { + infraOptions, err := svcConfig.Project.Infra.GetWithDefaults() + if err != nil { + return nil, fmt.Errorf("getting infra options for service %s: %w", name, err) + } + defaultLanguage = ServiceLanguageDocker // dockerfiles are copied to the infra folder like bicep files to ensure // provision and deploy works after infra gen. bContainer.Build.Dockerfile = filepath.Join( - svcConfig.Project.Path, svcConfig.Project.Infra.Path, name, filepath.Base(bContainer.Build.Dockerfile)) + svcConfig.Project.Path, infraOptions.Path, name, filepath.Base(bContainer.Build.Dockerfile)) // If the dockerfile is not in disk, it could have been manually deleted (after infra gen) or // infra gen was never run. In any case, use the in-memory generated dockerfile to build the container. diff --git a/cli/azd/pkg/project/importer.go b/cli/azd/pkg/project/importer.go index 10fcca2451a..77ffa42b870 100644 --- a/cli/azd/pkg/project/importer.go +++ b/cli/azd/pkg/project/importer.go @@ -13,7 +13,6 @@ import ( "slices" "strings" - "dario.cat/mergo" "github.com/azure/azure-dev/cli/azd/pkg/infra/provisioning" ) @@ -237,27 +236,28 @@ var ( // The configuration can be explicitly defined on azure.yaml using path and module, or in case these values // are not explicitly defined, the project importer uses default values to find the infrastructure. func (im *ImportManager) ProjectInfrastructure(ctx context.Context, projectConfig *ProjectConfig) (*Infra, error) { - mergedOptions := provisioning.Options{} - mergo.Merge(&mergedOptions, projectConfig.Infra) - mergo.Merge(&mergedOptions, DefaultProvisioningOptions) + infraOptions, err := projectConfig.Infra.GetWithDefaults() + if err != nil { + return nil, fmt.Errorf("getting infra options: %w", err) + } - infraRoot := mergedOptions.Path + infraRoot := infraOptions.Path if !filepath.IsAbs(infraRoot) { infraRoot = filepath.Join(projectConfig.Path, infraRoot) } // short-circuit: If layers are defined, we know it's an explicit infrastructure - if len(mergedOptions.Layers) > 0 { + if len(infraOptions.Layers) > 0 { return &Infra{ - Options: mergedOptions, + Options: infraOptions, }, nil } // short-circuit: If infra files exist, we know it's an explicit infrastructure - if moduleExists, err := pathHasModule(infraRoot, mergedOptions.Module); err == nil && moduleExists { + if moduleExists, err := pathHasModule(infraRoot, infraOptions.Module); err == nil && moduleExists { log.Printf("using infrastructure from %s directory", infraRoot) return &Infra{ - Options: mergedOptions, + Options: infraOptions, }, nil } @@ -287,7 +287,7 @@ func (im *ImportManager) ProjectInfrastructure(ctx context.Context, projectConfi // Return default project infra return &Infra{ - Options: mergedOptions, + Options: infraOptions, }, nil } diff --git a/cli/azd/pkg/project/service_target_containerapp.go b/cli/azd/pkg/project/service_target_containerapp.go index 9ba14ff8910..3529bc3e3bf 100644 --- a/cli/azd/pkg/project/service_target_containerapp.go +++ b/cli/azd/pkg/project/service_target_containerapp.go @@ -189,12 +189,24 @@ func (at *containerAppTarget) Deploy( // If present, build and deploy it. controlledRevision := false - moduleName := serviceConfig.Module - if moduleName == "" { - moduleName = serviceConfig.Name + nameOverrideOptions := provisioning.Options{ + Module: serviceConfig.Name, } - modulePath := filepath.Join(serviceConfig.Project.Infra.Path, moduleName) + // Get the infra options with defaults applied + // The order of precedence is: + // 1. Service-specific settings + // 2. Service-specific override (with module name) + // 3. Project-level infra options + serviceInfraOptions, err := serviceConfig.Infra.GetWithDefaults( + nameOverrideOptions, + serviceConfig.Project.Infra, + ) + if err != nil { + return nil, fmt.Errorf("getting service infra options: %w", err) + } + + modulePath := filepath.Join(serviceInfraOptions.Path, serviceInfraOptions.Module) bicepPath := modulePath + ".bicep" bicepParametersPath := modulePath + ".parameters.json" bicepParamPath := modulePath + ".bicepparam" From a00a3f56e11142e563d0ff822e7fd9c6fb196484 Mon Sep 17 00:00:00 2001 From: Wallace Breza Date: Wed, 19 Nov 2025 10:08:54 -0800 Subject: [PATCH 2/2] Fixes linting issues --- cli/azd/internal/cmd/add/add.go | 2 +- cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go | 7 ------- cli/azd/pkg/infra/provisioning/manager.go | 3 +++ cli/azd/pkg/project/dotnet_importer.go | 2 +- cli/azd/pkg/project/importer.go | 2 +- 5 files changed, 6 insertions(+), 10 deletions(-) diff --git a/cli/azd/internal/cmd/add/add.go b/cli/azd/internal/cmd/add/add.go index db0d52d6051..7ae861fc086 100644 --- a/cli/azd/internal/cmd/add/add.go +++ b/cli/azd/internal/cmd/add/add.go @@ -286,7 +286,7 @@ func (a *AddAction) Run(ctx context.Context) (*actions.ActionResult, error) { infraOptions, err := prjConfig.Infra.GetWithDefaults() if err != nil { - return nil, fmt.Errorf("getting infra options: %w", err) + return nil, err } infraRoot := infraOptions.Path diff --git a/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go b/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go index 1dcd3bbe71d..7b905b5d3e4 100644 --- a/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go +++ b/cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go @@ -46,13 +46,6 @@ import ( type bicepFileMode int -var ( - defaultOptions = provisioning.Options{ - Module: "main", - Path: "infra", - } -) - const ( bicepMode bicepFileMode = iota bicepparamMode diff --git a/cli/azd/pkg/infra/provisioning/manager.go b/cli/azd/pkg/infra/provisioning/manager.go index 4878b03d95c..306f9dd600e 100644 --- a/cli/azd/pkg/infra/provisioning/manager.go +++ b/cli/azd/pkg/infra/provisioning/manager.go @@ -51,6 +51,9 @@ var ( func (m *Manager) Initialize(ctx context.Context, projectPath string, options Options) error { infraOptions, err := options.GetWithDefaults() + if err != nil { + return err + } m.projectPath = projectPath m.options = &infraOptions diff --git a/cli/azd/pkg/project/dotnet_importer.go b/cli/azd/pkg/project/dotnet_importer.go index 2fc46d183a2..5eb11f995a2 100644 --- a/cli/azd/pkg/project/dotnet_importer.go +++ b/cli/azd/pkg/project/dotnet_importer.go @@ -336,7 +336,7 @@ func (ai *DotNetImporter) Services( if bContainer.Build != nil { infraOptions, err := svcConfig.Project.Infra.GetWithDefaults() if err != nil { - return nil, fmt.Errorf("getting infra options for service %s: %w", name, err) + return nil, err } defaultLanguage = ServiceLanguageDocker diff --git a/cli/azd/pkg/project/importer.go b/cli/azd/pkg/project/importer.go index 77ffa42b870..ae290c79de6 100644 --- a/cli/azd/pkg/project/importer.go +++ b/cli/azd/pkg/project/importer.go @@ -238,7 +238,7 @@ var ( func (im *ImportManager) ProjectInfrastructure(ctx context.Context, projectConfig *ProjectConfig) (*Infra, error) { infraOptions, err := projectConfig.Infra.GetWithDefaults() if err != nil { - return nil, fmt.Errorf("getting infra options: %w", err) + return nil, err } infraRoot := infraOptions.Path