Fix AzureBicepResource template file handling

- Don't combine paths if TemplateFile is specified
- Add test to verify bicep resources with template files can be published

Fix #13967

Author: eerhardt

src/Aspire.Hosting.Azure/AzureBicepResource.cs

@@ -34,13 +34,6 @@ public class AzureBicepResource : Resource, IAzureResource, IResourceWithParamet
     /// <param name="templateResourceName">The name of an embedded resource that represents the bicep file.</param>
     public AzureBicepResource(string name, string? templateFile = null, string? templateString = null, string? templateResourceName = null) : base(name)
     {
-        // Convert relative template file paths to absolute paths to ensure they remain valid
-        // regardless of changes to the current working directory
-        if (templateFile is not null && !Path.IsPathRooted(templateFile))
-        {
-            templateFile = Path.GetFullPath(templateFile);
-        }
-        
         TemplateFile = templateFile;
         TemplateString = templateString;
         TemplateResourceName = templateResourceName;
@@ -159,14 +152,11 @@ public virtual BicepTemplateFile GetBicepTemplateFile(string? directory = null,
             throw new InvalidOperationException("Multiple template sources are specified.");
         }
 
-        var path = TemplateFile;
-        var isTempFile = false;
-
-        if (path is null)
+        if (TemplateFile is null)
         {
-            isTempFile = directory is null;
+            var isTempFile = directory is null;
 
-            path = TempDirectory is null
+            var path = TempDirectory is null
                 ? Path.Combine(directory ?? Directory.CreateTempSubdirectory("aspire").FullName, $"{Name.ToLowerInvariant()}.module.bicep")
                 : Path.Combine(TempDirectory, $"{Name.ToLowerInvariant()}.module.bicep");
 
@@ -188,19 +178,14 @@ public virtual BicepTemplateFile GetBicepTemplateFile(string? directory = null,
                 using var fs = File.OpenWrite(path);
                 resourceStream.CopyTo(fs);
             }
-        }
-        else if (directory is not null)
-        {
-            // When a template file is provided and a directory is specified,
-            // copy the file to the directory instead of just combining paths
-            var fileName = Path.GetFileName(path);
-            var targetPath = Path.Combine(directory, fileName);
-            File.Copy(path, targetPath, overwrite: true);
-            return new(targetPath, isTempFile && deleteTemporaryFileOnDispose);
+
+            return new(path, isTempFile && deleteTemporaryFileOnDispose);
         }
 
-        var finalPath = directory is not null ? Path.Combine(directory, path) : path;
-        return new(finalPath, isTempFile && deleteTemporaryFileOnDispose);
+        // When TemplateFile is specified, return the original path directly.
+        // The directory parameter is only for writing temporary files when the template
+        // is from a string or embedded resource, not for combining with an existing file path.
+        return new(TemplateFile, deleteFileOnDispose: false);
     }
 
     /// <summary>

tests/Aspire.Hosting.Azure.Tests/Aspire.Hosting.Azure.Tests.csproj

@@ -59,10 +59,4 @@
     <PackageReference Include="Verify.XunitV3" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Update="TestBicepTemplates\**\*.bicep">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
 </Project>

tests/Aspire.Hosting.Azure.Tests/AzureBicepResourceTests.cs

@@ -248,62 +248,74 @@ public async Task BicepResourceHasPipelineStepAnnotationWithCorrectConfiguration
     }
 
     [Fact]
-    public async Task AzureBicepResourceWithTemplateFile_CanBePublished()
+    public void GetBicepTemplateFile_WithTemplateFile_ReturnsOriginalPathWhenDirectoryProvided()
     {
-        // Arrange
+        // This test verifies the fix for https://github.com/dotnet/aspire/issues/13967
+        // When a templateFile is specified, GetBicepTemplateFile should return the original path
+        // and not combine it with the directory parameter.
+
         using var tempDir = new TestTempDirectory();
-        
-        // Create a bicep file (simulating a file in the AppHost project)
+
+        // Create a test bicep file
         var bicepFileName = "test-template.bicep";
         var bicepFilePath = Path.Combine(tempDir.Path, bicepFileName);
-        
-        var bicepContent = """
-param location string = resourceGroup().location
-param testParameter string
-
-resource testResource 'Microsoft.Storage/storageAccounts@2021-09-01' = {
-  name: 'teststorage${uniqueString(resourceGroup().id)}'
-  location: location
-  sku: {
-    name: 'Standard_LRS'
-  }
-  kind: 'StorageV2'
-  tags: {
-    testParam: testParameter
-  }
-}
+        File.WriteAllText(bicepFilePath, "param location string = resourceGroup().location");
 
-output storageEndpoint string = testResource.properties.primaryEndpoints.blob
-""";
-        await File.WriteAllTextAsync(bicepFilePath, bicepContent);
-        
+        // Create the AzureBicepResource with the templateFile
+        var resource = new AzureBicepResource("test-resource", templateFile: bicepFilePath);
+
+        // Create a different directory to pass to GetBicepTemplateFile
         var outputDir = Path.Combine(tempDir.Path, "output");
-        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Publish, outputDir);
+        Directory.CreateDirectory(outputDir);
 
-        // Add Azure Container App Environment (required for publishing)
-        builder.AddAzureContainerAppEnvironment("acaEnv");
+        // Get the bicep template file with a directory parameter
+        using var templateFile = resource.GetBicepTemplateFile(outputDir);
 
-        // Add a bicep resource with a template file (using absolute path for test, but in real scenario this would be relative)
-        var bicepResource = builder.AddBicepTemplate("myresource", bicepFilePath)
-            .WithParameter("testParameter", "test-value");
+        // The path should be the original template file path, not combined with outputDir
+        Assert.Equal(bicepFilePath, templateFile.Path);
+        Assert.True(File.Exists(templateFile.Path), $"The template file should exist at {templateFile.Path}");
+    }
 
-        // Act
-        using var app = builder.Build();
-        app.Run();
+    [Fact]
+    public void GetBicepTemplateFile_WithTemplateFile_ReturnsOriginalPathWithoutDirectory()
+    {
+        using var tempDir = new TestTempDirectory();
 
-        // Assert - Verify the bicep files were created
-        var mainBicepPath = Path.Combine(outputDir, "main.bicep");
-        Assert.True(File.Exists(mainBicepPath), "main.bicep should be generated");
+        // Create a test bicep file
+        var bicepFileName = "test-template.bicep";
+        var bicepFilePath = Path.Combine(tempDir.Path, bicepFileName);
+        File.WriteAllText(bicepFilePath, "param location string = resourceGroup().location");
+
+        // Create the AzureBicepResource with the templateFile
+        var resource = new AzureBicepResource("test-resource", templateFile: bicepFilePath);
+
+        // Get the bicep template file without a directory parameter
+        using var templateFile = resource.GetBicepTemplateFile();
+
+        // The path should be the original template file path
+        Assert.Equal(bicepFilePath, templateFile.Path);
+    }
+
+    [Fact]
+    public void GetBicepTemplateFile_WithTemplateString_WritesToDirectory()
+    {
+        using var tempDir = new TestTempDirectory();
 
-        var resourceBicepPath = Path.Combine(outputDir, "myresource", "myresource.bicep");
-        Assert.True(File.Exists(resourceBicepPath), "myresource/myresource.bicep should be generated");
+        var bicepContent = "param location string = resourceGroup().location";
+
+        // Create the AzureBicepResource with a template string (not a file)
+        var resource = new AzureBicepResource("test-resource", templateString: bicepContent);
+
+        // Create a directory to pass to GetBicepTemplateFile
+        var outputDir = Path.Combine(tempDir.Path, "output");
+        Directory.CreateDirectory(outputDir);
 
-        // Verify the content of the copied file matches the original
-        var copiedContent = await File.ReadAllTextAsync(resourceBicepPath);
-        Assert.Equal(bicepContent, copiedContent);
+        // Get the bicep template file with a directory parameter
+        using var templateFile = resource.GetBicepTemplateFile(outputDir);
 
-        // Verify the main.bicep references the resource
-        var mainBicepContent = await File.ReadAllTextAsync(mainBicepPath);
-        Assert.Contains("module myresource 'myresource/myresource.bicep'", mainBicepContent);
+        // The path should be in the output directory
+        Assert.StartsWith(outputDir, templateFile.Path);
+        Assert.True(File.Exists(templateFile.Path), $"The template file should exist at {templateFile.Path}");
+        Assert.Equal(bicepContent, File.ReadAllText(templateFile.Path));
     }
 }

tests/Aspire.Hosting.Azure.Tests/AzureEnvironmentResourceTests.cs

@@ -7,6 +7,7 @@
 using Aspire.Hosting.Utils;
 using Azure.Provisioning;
 using Azure.Provisioning.Storage;
+using Microsoft.DotNet.RemoteExecutor;
 
 namespace Aspire.Hosting.Azure.Tests;
 
@@ -238,6 +239,75 @@ public async Task PublishAsync_WithDockerfileFactory_WritesDockerfileToOutputFol
         await Verify(actualContent);
     }
 
+    [Fact]
+    public void AzurePublishingContext_WithBicepTemplateFile_WorksWithRelativePath()
+    {
+        using var testTempDir = new TestTempDirectory();
+
+        var remoteInvokeOptions = new RemoteInvokeOptions();
+        remoteInvokeOptions.StartInfo.WorkingDirectory = testTempDir.Path;
+        RemoteExecutor.Invoke(RunTest, testTempDir.Path, remoteInvokeOptions).Dispose();
+
+        static async Task RunTest(string tempDir)
+        {
+            // This test verifies the fix for https://github.com/dotnet/aspire/issues/13967
+            // When using AzureBicepResource with a relative templateFile and AzurePublishingContext,
+            // the bicep file should be correctly copied to the output directory.
+
+            // Create a source bicep file (simulating a user's custom bicep template)
+            var bicepFileName = "custom-resource.bicep";
+            var bicepFilePath = Path.Combine(tempDir, bicepFileName);
+            var bicepContent = """
+            param location string = resourceGroup().location
+            param customName string
+
+            resource storageAccount 'Microsoft.Storage/storageAccounts@2021-02-01' = {
+              name: customName
+              location: location
+              kind: 'StorageV2'
+              sku: {
+                name: 'Standard_LRS'
+              }
+            }
+
+            output endpoint string = storageAccount.properties.primaryEndpoints.blob
+            """;
+            await File.WriteAllTextAsync(bicepFilePath, bicepContent);
+
+            // Create output directory for publishing
+            var outputDir = Path.Combine(tempDir, "output");
+            Directory.CreateDirectory(outputDir);
+
+            var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Publish, outputPath: outputDir);
+
+            // Add a container app environment (required for publishing)
+            builder.AddAzureContainerAppEnvironment("env");
+
+            // Add the custom AzureBicepResource with a relative template file path
+            var customResource = new AzureBicepResource("custom-resource", bicepFileName);
+            builder.AddResource(customResource)
+                .WithParameter("customName", "mystorageaccount");
+
+            var app = builder.Build();
+            app.Run();
+
+            // Verify the bicep file was copied to the output directory
+            var mainBicepPath = Path.Combine(outputDir, "main.bicep");
+            Assert.True(File.Exists(mainBicepPath), "main.bicep should be generated");
+
+            var resourceBicepPath = Path.Combine(outputDir, "custom-resource", "custom-resource.bicep");
+            Assert.True(File.Exists(resourceBicepPath), "custom-resource/custom-resource.bicep should be generated");
+
+            // Verify the content of the copied file matches the original
+            var copiedContent = await File.ReadAllTextAsync(resourceBicepPath);
+            Assert.Equal(bicepContent, copiedContent);
+
+            // Verify the main.bicep references the resource
+            var mainBicepContent = await File.ReadAllTextAsync(mainBicepPath);
+            Assert.Contains("module custom_resource 'custom-resource/custom-resource.bicep'", mainBicepContent);
+        }
+    }
+
     private sealed class ExternalResourceWithParameters(string name) : Resource(name), IResourceWithParameters
     {
         public IDictionary<string, object?> Parameters { get; } = new Dictionary<string, object?>();