Merge branch 'main' into Usr/sogh/bug3373

souvikghosh04 · web-flow · commit 6783acb7bd31 · 2026-04-07T20:11:30.000+05:30
diff --git a/src/Config/ObjectModel/RuntimeConfig.cs b/src/Config/ObjectModel/RuntimeConfig.cs
@@ -6,6 +6,7 @@
 using System.Net;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using Azure.DataApiBuilder.Config.Converters;
 using Azure.DataApiBuilder.Service.Exceptions;
 using Microsoft.Extensions.Logging;
 
@@ -355,8 +356,9 @@ public RuntimeConfig(
 
             foreach (string dataSourceFile in DataSourceFiles.SourceFiles)
             {
-                // Use default replacement settings for environment variable replacement
-                DeserializationVariableReplacementSettings replacementSettings = new(azureKeyVaultOptions: null, doReplaceEnvVar: true, doReplaceAkvVar: true);
+                // Use Ignore mode so missing env vars are left as literal @env() strings,
+                // consistent with how the parent config is loaded in TryLoadKnownConfig.
+                DeserializationVariableReplacementSettings replacementSettings = new(azureKeyVaultOptions: null, doReplaceEnvVar: true, doReplaceAkvVar: true, envFailureMode: EnvironmentVariableReplacementFailureMode.Ignore);
 
                 if (loader.TryLoadConfig(dataSourceFile, out RuntimeConfig? config, replacementSettings: replacementSettings))
                 {
@@ -378,6 +380,17 @@ public RuntimeConfig(
                             e.InnerException);
                     }
                 }
+                else if (fileSystem.File.Exists(dataSourceFile))
+                {
+                    // The file exists but failed to load (e.g. invalid JSON, deserialization error).
+                    // Throw to prevent silently skipping a broken child config.
+                    // Non-existent files are skipped gracefully to support late-configured scenarios
+                    // where data-source-files may reference files not present on the host.
+                    throw new DataApiBuilderException(
+                        message: $"Failed to load datasource file: {dataSourceFile}. Ensure the file is accessible and contains a valid DAB configuration.",
+                        statusCode: HttpStatusCode.ServiceUnavailable,
+                        subStatusCode: DataApiBuilderException.SubStatusCodes.ConfigValidationError);
+                }
             }
 
             this.Entities = new RuntimeEntities(allEntities != null ? allEntities.ToDictionary(x => x.Key, x => x.Value) : new Dictionary<string, Entity>());
diff --git a/src/Service.Tests/Configuration/RuntimeConfigLoaderTests.cs b/src/Service.Tests/Configuration/RuntimeConfigLoaderTests.cs
@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Azure.DataApiBuilder.Config;
+using Azure.DataApiBuilder.Config.Converters;
 using Azure.DataApiBuilder.Config.ObjectModel;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Newtonsoft.Json.Linq;
@@ -131,4 +132,154 @@ public async Task CanLoadValidMultiSourceConfigWithAutoentities(string configPat
         Assert.IsTrue(runtimeConfig.SqlDataSourceUsed, "Should have Sql data source");
         Assert.AreEqual(expectedEntities, runtimeConfig.Entities.Entities.Count, "Number of entities is not what is expected.");
     }
+
+    /// <summary>
+    /// Validates that when a child config contains @env('...') references to environment variables
+    /// that do not exist, the config still loads successfully because the child config uses
+    /// EnvironmentVariableReplacementFailureMode.Ignore (matching the parent config behavior).
+    /// Regression test for https://github.com/Azure/data-api-builder/issues/3271
+    /// </summary>
+    [TestMethod]
+    public async Task ChildConfigWithMissingEnvVarsLoadsSuccessfully()
+    {
+        string parentConfig = await File.ReadAllTextAsync("Multidab-config.MsSql.json");
+
+        // Child config references env vars that do not exist in the environment.
+        string childConfig = @"{
+            ""$schema"": ""https://github.com/Azure/data-api-builder/releases/download/vmajor.minor.patch/dab.draft.schema.json"",
+            ""data-source"": {
+                ""database-type"": ""mssql"",
+                ""connection-string"": ""Server=tcp:127.0.0.1,1433;Persist Security Info=False;Trusted_Connection=True;TrustServerCertificate=True;MultipleActiveResultSets=False;Connection Timeout=5;""
+            },
+            ""runtime"": {
+                ""rest"": { ""enabled"": true },
+                ""graphql"": { ""enabled"": true },
+                ""host"": {
+                    ""cors"": { ""origins"": [] },
+                    ""authentication"": { ""provider"": ""StaticWebApps"" }
+                },
+                ""telemetry"": {
+                    ""open-telemetry"": {
+                        ""enabled"": true,
+                        ""endpoint"": ""@env('NONEXISTENT_OTEL_ENDPOINT')"",
+                        ""headers"": ""@env('NONEXISTENT_OTEL_HEADERS')"",
+                        ""service-name"": ""@env('NONEXISTENT_OTEL_SERVICE_NAME')""
+                    }
+                }
+            },
+            ""entities"": {
+                ""ChildEntity"": {
+                    ""source"": ""dbo.ChildTable"",
+                    ""permissions"": [{ ""role"": ""anonymous"", ""actions"": [""read""] }]
+                }
+            }
+        }";
+
+        // Save original env var values and clear them to ensure they don't exist.
+        string? origEndpoint = Environment.GetEnvironmentVariable("NONEXISTENT_OTEL_ENDPOINT");
+        string? origHeaders = Environment.GetEnvironmentVariable("NONEXISTENT_OTEL_HEADERS");
+        string? origServiceName = Environment.GetEnvironmentVariable("NONEXISTENT_OTEL_SERVICE_NAME");
+        Environment.SetEnvironmentVariable("NONEXISTENT_OTEL_ENDPOINT", null);
+        Environment.SetEnvironmentVariable("NONEXISTENT_OTEL_HEADERS", null);
+        Environment.SetEnvironmentVariable("NONEXISTENT_OTEL_SERVICE_NAME", null);
+
+        // Write the child config to a unique temp file because the RuntimeConfig
+        // constructor creates a real FileSystem to load child data-source-files.
+        string childFilePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".json");
+        try
+        {
+            await File.WriteAllTextAsync(childFilePath, childConfig);
+
+            JObject parentJson = JObject.Parse(parentConfig);
+            parentJson.Add("data-source-files", new JArray(childFilePath));
+            string parentJsonStr = parentJson.ToString();
+
+            MockFileSystem fs = new(new Dictionary<string, MockFileData>()
+            {
+                { "dab-config.json", new MockFileData(parentJsonStr) }
+            });
+
+            FileSystemRuntimeConfigLoader loader = new(fs);
+
+            DeserializationVariableReplacementSettings replacementSettings = new(
+                azureKeyVaultOptions: null,
+                doReplaceEnvVar: true,
+                doReplaceAkvVar: false,
+                envFailureMode: EnvironmentVariableReplacementFailureMode.Ignore);
+
+            Assert.IsTrue(
+                loader.TryLoadConfig("dab-config.json", out RuntimeConfig runtimeConfig, replacementSettings: replacementSettings),
+                "Config should load successfully even when child config has missing env vars.");
+
+            Assert.IsTrue(runtimeConfig.Entities.ContainsKey("ChildEntity"), "Child config entity should be merged into the parent config.");
+        }
+        finally
+        {
+            Environment.SetEnvironmentVariable("NONEXISTENT_OTEL_ENDPOINT", origEndpoint);
+            Environment.SetEnvironmentVariable("NONEXISTENT_OTEL_HEADERS", origHeaders);
+            Environment.SetEnvironmentVariable("NONEXISTENT_OTEL_SERVICE_NAME", origServiceName);
+
+            if (File.Exists(childFilePath))
+            {
+                File.Delete(childFilePath);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Validates that when a child config file exists but contains invalid content,
+    /// the parent config loading fails instead of silently skipping the child.
+    /// Non-existent child files are intentionally skipped to support late-configured scenarios.
+    /// Regression test for https://github.com/Azure/data-api-builder/issues/3271
+    /// </summary>
+    [TestMethod]
+    public async Task ChildConfigLoadFailureHaltsParentConfigLoading()
+    {
+        string parentConfig = await File.ReadAllTextAsync("Multidab-config.MsSql.json");
+
+        // Use a real temp file with invalid JSON so the file exists but fails to parse.
+        string invalidChildPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".json");
+
+        try
+        {
+            await File.WriteAllTextAsync(invalidChildPath, "{ this is not valid json }");
+
+            JObject parentJson = JObject.Parse(parentConfig);
+            parentJson.Add("data-source-files", new JArray(invalidChildPath));
+            string parentJsonStr = parentJson.ToString();
+
+            MockFileSystem fs = new(new Dictionary<string, MockFileData>()
+            {
+                { "dab-config.json", new MockFileData(parentJsonStr) }
+            });
+
+            FileSystemRuntimeConfigLoader loader = new(fs);
+
+            TextWriter originalError = Console.Error;
+            StringWriter sw = new();
+
+            try
+            {
+                Console.SetError(sw);
+
+                bool loaded = loader.TryLoadConfig("dab-config.json", out RuntimeConfig _);
+                string error = sw.ToString();
+
+                Assert.IsFalse(loaded, "Config loading should fail when a child config file exists but cannot be parsed.");
+                Assert.IsTrue(error.Contains("Failed to load datasource file"), "Error message should indicate the child config file that failed to load.");
+            }
+            finally
+            {
+                Console.SetError(originalError);
+                sw.Dispose();
+            }
+        }
+        finally
+        {
+            if (File.Exists(invalidChildPath))
+            {
+                File.Delete(invalidChildPath);
+            }
+        }
+    }
 }
diff --git a/src/Service.Tests/OpenApiDocumentor/MissingRoleNotFoundTests.cs b/src/Service.Tests/OpenApiDocumentor/MissingRoleNotFoundTests.cs
@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Azure.DataApiBuilder.Config;
+using Azure.DataApiBuilder.Config.ObjectModel;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Azure.DataApiBuilder.Service.Tests.OpenApiIntegration
+{
+    /// <summary>
+    /// Tests validating that requesting an OpenAPI document for a role not present
+    /// in the configuration returns a 404 ProblemDetails response with a descriptive message.
+    /// </summary>
+    [TestCategory(TestCategory.MSSQL)]
+    [TestClass]
+    public class MissingRoleNotFoundTests
+    {
+        private const string CONFIG_FILE = "missing-role-notfound-config.MsSql.json";
+        private const string DB_ENV = TestCategory.MSSQL;
+
+        /// <summary>
+        /// Validates that a request for /api/openapi/{role} returns a 404
+        /// ProblemDetails response containing the role name in the detail message
+        /// when the role is not present in the configuration or contains invalid characters.
+        /// </summary>
+        [DataTestMethod]
+        [DataRow("nonexistentrole", DisplayName = "Missing role returns 404 ProblemDetails")]
+        [DataRow("foo/bar", DisplayName = "Role with path separator returns 404 ProblemDetails")]
+        public async Task MissingRole_Returns404ProblemDetailsWithMessage(string roleName)
+        {
+            TestHelper.SetupDatabaseEnvironment(DB_ENV);
+            FileSystem fileSystem = new();
+            FileSystemRuntimeConfigLoader loader = new(fileSystem);
+            loader.TryLoadKnownConfig(out RuntimeConfig config);
+
+            Entity entity = new(
+                Source: new("books", EntitySourceType.Table, null, null),
+                Fields: null,
+                GraphQL: new(null, null, false),
+                Rest: new(EntityRestOptions.DEFAULT_SUPPORTED_VERBS),
+                Permissions: OpenApiTestBootstrap.CreateBasicPermissions(),
+                Mappings: null,
+                Relationships: null);
+
+            RuntimeConfig testConfig = config with
+            {
+                Runtime = config.Runtime with
+                {
+                    Host = config.Runtime?.Host with { Mode = HostMode.Development }
+                },
+                Entities = new RuntimeEntities(new Dictionary<string, Entity> { { "book", entity } })
+            };
+
+            File.WriteAllText(CONFIG_FILE, testConfig.ToJson());
+            string[] args = new[] { $"--ConfigFileName={CONFIG_FILE}" };
+
+            try
+            {
+                using TestServer server = new(Program.CreateWebHostBuilder(args));
+                using HttpClient client = server.CreateClient();
+
+                HttpResponseMessage response = await client.GetAsync($"/api/openapi/{Uri.EscapeDataString(roleName)}");
+
+                Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode, "Expected 404 for a role not in the configuration.");
+
+                string responseBody = await response.Content.ReadAsStringAsync();
+                using JsonDocument doc = JsonDocument.Parse(responseBody);
+                JsonElement root = doc.RootElement;
+
+                Assert.AreEqual("Not Found", root.GetProperty("title").GetString(), "ProblemDetails title should be 'Not Found'.");
+                Assert.AreEqual(404, root.GetProperty("status").GetInt32(), "ProblemDetails status should be 404.");
+                Assert.IsTrue(root.TryGetProperty("type", out _), "ProblemDetails should contain a 'type' field.");
+                Assert.IsTrue(root.TryGetProperty("traceId", out _), "ProblemDetails should contain a 'traceId' field.");
+
+                string detail = root.GetProperty("detail").GetString();
+                Assert.IsTrue(detail.Contains(roleName), $"Detail should contain the role name '{roleName}'. Actual: {detail}");
+            }
+            finally
+            {
+                if (File.Exists(CONFIG_FILE))
+                {
+                    File.Delete(CONFIG_FILE);
+                }
+            }
+
+            TestHelper.UnsetAllDABEnvironmentVariables();
+        }
+    }
+}
diff --git a/src/Service.Tests/UnitTests/RuntimeConfigLoaderJsonDeserializerTests.cs b/src/Service.Tests/UnitTests/RuntimeConfigLoaderJsonDeserializerTests.cs
@@ -486,7 +486,10 @@ public void TestLoadRuntimeConfigFailures(
         }
 
         /// <summary>
-        /// Method to validate that FileNotFoundException is thrown if sub-data source file is not found.
+        /// Method to validate that when a sub-data source file is not found, it is gracefully
+        /// skipped and the parent config loads successfully. Non-existent child files are
+        /// tolerated to support late-configured scenarios where data-source-files may reference
+        /// files not present on the host.
         /// </summary>
         [TestMethod]
         public void TestLoadRuntimeConfigSubFilesFails()
diff --git a/src/Service/Controllers/RestController.cs b/src/Service/Controllers/RestController.cs
@@ -249,15 +249,21 @@ private async Task<IActionResult> HandleOperation(
                     // Validate role doesn't contain path separators (reject /openapi/foo/bar)
                     if (string.IsNullOrEmpty(role) || role.Contains('/'))
                     {
-                        return NotFound();
+                        return Problem(
+                            detail: $"Invalid role name '{role}'. Role names must not be empty or contain path separators.",
+                            statusCode: StatusCodes.Status404NotFound,
+                            title: "Not Found");
                     }
 
                     if (_openApiDocumentor.TryGetDocumentForRole(role, out string? roleDocument))
                     {
                         return Content(roleDocument, MediaTypeNames.Application.Json);
                     }
 
-                    return NotFound();
+                    return Problem(
+                        detail: $"Role '{role}' is not present in the configuration.",
+                        statusCode: StatusCodes.Status404NotFound,
+                        title: "Not Found");
                 }
 
                 (string entityName, string primaryKeyRoute) = _restService.GetEntityNameAndPrimaryKeyRouteFromRoute(routeAfterPathBase);

Original file line number	Diff line number	Diff line change
`@@ -249,15 +249,21 @@ private async Task<IActionResult> HandleOperation(`
`249`	`249`	`// Validate role doesn't contain path separators (reject /openapi/foo/bar)`
`250`	`250`	`if (string.IsNullOrEmpty(role) \|\| role.Contains('/'))`
`251`	`251`	`{`
`252`		`- return NotFound();`
	`252`	`+ return Problem(`
	`253`	`+ detail: $"Invalid role name '{role}'. Role names must not be empty or contain path separators.",`
	`254`	`+ statusCode: StatusCodes.Status404NotFound,`
	`255`	`+ title: "Not Found");`
`253`	`256`	`}`
`254`	`257`
`255`	`258`	`if (_openApiDocumentor.TryGetDocumentForRole(role, out string? roleDocument))`
`256`	`259`	`{`
`257`	`260`	`return Content(roleDocument, MediaTypeNames.Application.Json);`
`258`	`261`	`}`
`259`	`262`
`260`		`- return NotFound();`
	`263`	`+ return Problem(`
	`264`	`+ detail: $"Role '{role}' is not present in the configuration.",`
	`265`	`+ statusCode: StatusCodes.Status404NotFound,`
	`266`	`+ title: "Not Found");`
`261`	`267`	`}`
`262`	`268`
`263`	`269`	`(string entityName, string primaryKeyRoute) = _restService.GetEntityNameAndPrimaryKeyRouteFromRoute(routeAfterPathBase);`