ConfigureOptionsTests.cs

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

using Serilog;

namespace Cli.Tests
{
    /// <summary>
    /// Validates that `dab configure [options]` configures settings with the user-provided options.
    /// </summary>
    [TestClass]
    public class ConfigureOptionsTests : VerifyBase
    {
        private MockFileSystem? _fileSystem;
        private FileSystemRuntimeConfigLoader? _runtimeConfigLoader;
        private const string TEST_RUNTIME_CONFIG_FILE = "test-update-runtime-setting.json";
        private const string TEST_DATASOURCE_HEALTH_NAME = "My Data Source";

        [TestInitialize]
        public void TestInitialize()
        {
            _fileSystem = FileSystemUtils.ProvisionMockFileSystem();

            _runtimeConfigLoader = new FileSystemRuntimeConfigLoader(_fileSystem);

            ILoggerFactory loggerFactory = TestLoggerSupport.ProvisionLoggerFactory();

            SetLoggerForCliConfigGenerator(loggerFactory.CreateLogger<ConfigGenerator>());
            SetCliUtilsLogger(loggerFactory.CreateLogger<Utils>());
        }

        /// <summary>
        /// Validates that if depth-limit is not provided in `dab configure` options, then The config file must not change.
        /// Example: if depth-limit is not provided in the config, it should not be added.
        /// if { "depth-limit" : null } is provided in the config, it should not be removed.
        /// Also, if { "depth-limit" : -1 } is provided in the config, it should not be removed.
        /// </summary>
        [DataTestMethod]
        [DataRow(null, false, DisplayName = "Config: 'depth-limit' property not defined, should not be added.")]
        [DataRow(null, true, DisplayName = "Config: 'depth-limit' is null. It should not be removed.")]
        [DataRow(-1, true, DisplayName = "Config: 'depth-limit' is -1, should remain as is without change.")]
        public void TestNoUpdateOnGraphQLDepthLimitInRuntimeSettings(object? depthLimit, bool isDepthLimitProvidedInConfig)
        {
            string depthLimitSection = "";
            if (isDepthLimitProvidedInConfig)
            {
                if (depthLimit == null)
                {
                    depthLimitSection = $@"""depth-limit"": null";
                }
                else
                {
                    depthLimitSection = $@"""depth-limit"": {depthLimit}";
                }
            }

            string initialConfig = TestHelper.GenerateConfigWithGivenDepthLimit(depthLimitSection);

            // Arrange
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, initialConfig);
            Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));

            // Act: Run Configure with no options
            ConfigureOptions options = new(
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);

            // Assert that INITIAL_CONFIG is same as the updated config
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            if (isDepthLimitProvidedInConfig)
            {
                Assert.IsTrue(updatedConfig.Contains(depthLimitSection));
            }
            else
            {
                Assert.IsTrue(!updatedConfig.Contains("depth-limit"));
            }

            // Assert that INITIAL_CONFIG is same as the updated config
            Assert.IsTrue(JToken.DeepEquals(JObject.Parse(initialConfig), JObject.Parse(updatedConfig)));
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.graphql.depth-limit 8" on a config with no depth-limit previously specified, results
        /// in runtime.graphql.depthlimit property being set with the value 8.
        [TestMethod]
        public void TestAddDepthLimitForGraphQL()
        {
            // Arrange
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(INITIAL_CONFIG));
            int maxDepthLimit = 8;

            Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));

            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(INITIAL_CONFIG, out RuntimeConfig? config));
            Assert.IsNull(config.Runtime!.GraphQL!.DepthLimit);

            // Act: Attmepts to Add Depth Limit
            ConfigureOptions options = new(
                depthLimit: maxDepthLimit,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Depth Limit is added
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out config));
            Assert.IsNotNull(config.Runtime?.GraphQL?.DepthLimit);
            Assert.AreEqual(maxDepthLimit, config.Runtime.GraphQL.DepthLimit);
        }

        /// <summary>
        /// Tests that running the "configure --azure-key-vault" commands on a config without AKV properties results
        /// in a valid config being generated.
        [TestMethod]
        public void TestAddAKVOptions()
        {
            // Arrange
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(INITIAL_CONFIG));

            Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));

            // Act: Attempts to add AKV options
            ConfigureOptions options = new(
                azureKeyVaultEndpoint: "foo",
                azureKeyVaultRetryPolicyMaxCount: 1,
                azureKeyVaultRetryPolicyDelaySeconds: 1,
                azureKeyVaultRetryPolicyMaxDelaySeconds: 1,
                azureKeyVaultRetryPolicyMode: AKVRetryPolicyMode.Exponential,
                azureKeyVaultRetryPolicyNetworkTimeoutSeconds: 1,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the AKV options are added.
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.AzureKeyVault);
            Assert.IsNotNull(config.AzureKeyVault?.RetryPolicy);
            Assert.AreEqual("foo", config.AzureKeyVault?.Endpoint);
            Assert.AreEqual(AKVRetryPolicyMode.Exponential, config.AzureKeyVault?.RetryPolicy.Mode);
            Assert.AreEqual(1, config.AzureKeyVault?.RetryPolicy.MaxCount);
            Assert.AreEqual(1, config.AzureKeyVault?.RetryPolicy.DelaySeconds);
            Assert.AreEqual(1, config.AzureKeyVault?.RetryPolicy.MaxDelaySeconds);
            Assert.AreEqual(1, config.AzureKeyVault?.RetryPolicy.NetworkTimeoutSeconds);
        }

        /// <summary>
        /// Tests that running the "configure --azure-log-analytics" commands on a config without Azure Log Analytics properties results
        /// in a valid config being generated.
        [TestMethod]
        public void TestAddAzureLogAnalyticsOptions()
        {
            // Arrange
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(INITIAL_CONFIG));

            Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));

            // Act: Attempts to add Azure Log Analytics options
            ConfigureOptions options = new(
                azureLogAnalyticsEnabled: CliBool.True,
                azureLogAnalyticsDabIdentifier: "dab-identifier-test",
                azureLogAnalyticsFlushIntervalSeconds: 1,
                azureLogAnalyticsCustomTableName: "custom-table-name-test",
                azureLogAnalyticsDcrImmutableId: "dcr-immutable-id-test",
                azureLogAnalyticsDceEndpoint: "dce-endpoint-test",
                config: TEST_RUNTIME_CONFIG_FILE
            );

            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Azure Log Analytics options are added.
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.Runtime);
            Assert.IsNotNull(config.Runtime.Telemetry);
            Assert.IsNotNull(config.Runtime.Telemetry.AzureLogAnalytics);
            Assert.AreEqual(true, config.Runtime.Telemetry.AzureLogAnalytics.Enabled);
            Assert.AreEqual("dab-identifier-test", config.Runtime.Telemetry.AzureLogAnalytics.DabIdentifier);
            Assert.AreEqual(1, config.Runtime.Telemetry.AzureLogAnalytics.FlushIntervalSeconds);
            Assert.IsNotNull(config.Runtime.Telemetry.AzureLogAnalytics.Auth);
            Assert.AreEqual("custom-table-name-test", config.Runtime.Telemetry.AzureLogAnalytics.Auth.CustomTableName);
            Assert.AreEqual("dcr-immutable-id-test", config.Runtime.Telemetry.AzureLogAnalytics.Auth.DcrImmutableId);
            Assert.AreEqual("dce-endpoint-test", config.Runtime.Telemetry.AzureLogAnalytics.Auth.DceEndpoint);
        }

        /// <summary>
        /// Tests that running the "configure --file" commands on a config without file sink properties results
        /// in a valid config being generated.
        /// </summary>
        [TestMethod]
        public void TestAddFileSinkOptions()
        {
            // Arrange
            string fileSinkPath = "/custom/log/path.txt";
            RollingInterval fileSinkRollingInterval = RollingInterval.Hour;
            int fileSinkRetainedFileCountLimit = 5;
            int fileSinkFileSizeLimitBytes = 2097152;

            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(INITIAL_CONFIG));

            Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));

            // Act: Attempts to add file options
            ConfigureOptions options = new(
                fileSinkEnabled: CliBool.True,
                fileSinkPath: fileSinkPath,
                fileSinkRollingInterval: fileSinkRollingInterval,
                fileSinkRetainedFileCountLimit: fileSinkRetainedFileCountLimit,
                fileSinkFileSizeLimitBytes: fileSinkFileSizeLimitBytes,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the file options are added.
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.Runtime);
            Assert.IsNotNull(config.Runtime.Telemetry);
            Assert.IsNotNull(config.Runtime.Telemetry.File);
            Assert.AreEqual(true, config.Runtime.Telemetry.File.Enabled);
            Assert.AreEqual(fileSinkPath, config.Runtime.Telemetry.File.Path);
            Assert.AreEqual(fileSinkRollingInterval.ToString(), config.Runtime.Telemetry.File.RollingInterval);
            Assert.AreEqual(fileSinkRetainedFileCountLimit, config.Runtime.Telemetry.File.RetainedFileCountLimit);
            Assert.AreEqual(fileSinkFileSizeLimitBytes, config.Runtime.Telemetry.File.FileSizeLimitBytes);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.graphql.enabled" on a config with various values results
        /// in runtime. Takes in updated value for graphql.enabled and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(false, DisplayName = "Update GraphQL.Enabled to false.")]
        [DataRow(true, DisplayName = "Validate GraphQL.Enabled to remain true.")]
        public void TestUpdateEnabledForGraphQLSettings(bool updatedEnabledValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update enabled flag
            ConfigureOptions options = new(
                runtimeGraphQLEnabled: updatedEnabledValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Enabled Flag is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.GraphQL?.Enabled);
            Assert.AreEqual(updatedEnabledValue, runtimeConfig.Runtime.GraphQL.Enabled);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.graphql.path" on a config with various values results
        /// in runtime config update. Takes in updated value for graphql.path and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow("/updatedPath", DisplayName = "Update path to /updatedPath for GraphQL.")]
        [DataRow("/updated_Path", DisplayName = "Ensure underscore is allowed in GraphQL path name.")]
        [DataRow("/updated-Path", DisplayName = "Ensure hyphen is allowed in GraphQL path name.")]
        public void TestUpdatePathForGraphQLSettings(string updatedPathValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update path value
            ConfigureOptions options = new(
                runtimeGraphQLPath: updatedPathValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Path update is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.GraphQL?.Path);
            Assert.AreEqual(updatedPathValue, runtimeConfig.Runtime.GraphQL.Path);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.graphql.allow-introspection" on a 
        /// config with various values results in runtime config update.
        /// Takes in updated value for graphql.allow-introspection and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(false, DisplayName = "Update GraphQL.AllowIntrospection to be false.")]
        [DataRow(true, DisplayName = "Validate GraphQL.AllowIntrospection to remain true.")]
        public void TestUpdateAllowIntrospectionForGraphQLSettings(bool updatedAllowIntrospectionValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update allow-introspection flag
            ConfigureOptions options = new(
                runtimeGraphQLAllowIntrospection: updatedAllowIntrospectionValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Allow-Introspection value is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.GraphQL?.AllowIntrospection);
            Assert.AreEqual(updatedAllowIntrospectionValue, runtimeConfig.Runtime.GraphQL.AllowIntrospection);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.graphql.multiple-mutations.create.enabled"
        /// on a config with various values results in runtime config update. 
        /// Takes in updated value for multiple mutations.create.enabled and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(false, DisplayName = "Update GraphQL.MultipleMutation.Create.Enabled to be false.")]
        [DataRow(true, DisplayName = "Validate GraphQL.MultipleMutation.Create.Enabled to remain true.")]
        public void TestUpdateMultipleMutationCreateEnabledForGraphQLSettings(bool updatedMultipleMutationsCreateEnabledValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update multiple-mutations.create.enabled flag
            ConfigureOptions options = new(
                runtimeGraphQLMultipleMutationsCreateEnabled: updatedMultipleMutationsCreateEnabledValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Multiple-Mutation.Create.Enabled is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.GraphQL?.MultipleMutationOptions?.MultipleCreateOptions?.Enabled);
            Assert.AreEqual(updatedMultipleMutationsCreateEnabledValue, runtimeConfig.Runtime.GraphQL.MultipleMutationOptions.MultipleCreateOptions.Enabled);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.graphql.path" on a config with various values results
        /// in runtime config update. Takes in updatedPath and updated value for allow-introspection and 
        /// validates whether the runtime config reflects those updated values
        [TestMethod]
        public void TestUpdateMultipleParametersForGraphQLSettings()
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            bool updatedAllowIntrospectionValue = false;
            string updatedPathValue = "/updatedPath";

            // Act: Attempts to update the path value and allow-introspection flag
            ConfigureOptions options = new(
                runtimeGraphQLPath: updatedPathValue,
                runtimeGraphQLAllowIntrospection: updatedAllowIntrospectionValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the path is updated and allow introspection is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.GraphQL?.Path);
            Assert.IsNotNull(runtimeConfig.Runtime?.GraphQL?.AllowIntrospection);
            Assert.AreEqual(updatedPathValue, runtimeConfig.Runtime.GraphQL.Path);
            Assert.AreEqual(updatedAllowIntrospectionValue, runtimeConfig.Runtime.GraphQL.AllowIntrospection);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.rest.enabled {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for rest.enabled and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(false, DisplayName = "Update Rest.Enabled to false.")]
        [DataRow(true, DisplayName = "Validate if Rest.Enabled remains true.")]
        public void TestUpdateEnabledForRestSettings(bool updatedEnabledValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update enabled flag
            ConfigureOptions options = new(
                runtimeRestEnabled: updatedEnabledValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Enabled Flag is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Rest?.Enabled);
            Assert.AreEqual(updatedEnabledValue, runtimeConfig.Runtime.Rest.Enabled);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.rest.path {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for rest.path and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow("/updatedPath", DisplayName = "Update REST path to /updatedPath.")]
        [DataRow("/updated_Path", DisplayName = "Ensure underscore is allowed in REST path.")]
        [DataRow("/updated-Path", DisplayName = "Ensure hyphen is allowed in REST path.")]
        public void TestUpdatePathForRestSettings(string updatedPathValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update path value
            ConfigureOptions options = new(
                runtimeRestPath: updatedPathValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Path update is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Rest?.Path);
            Assert.AreEqual(updatedPathValue, runtimeConfig.Runtime.Rest.Path);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.rest.request-body-strict" on a config with various values results
        /// in runtime config update. Takes in updated value for rest.request-body-strict and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(false, DisplayName = "Update Rest.Request-Body-Strict to false.")]
        [DataRow(true, DisplayName = "Validate if Rest.Request-body-Strict remains true.")]
        public void TestUpdateRequestBodyStrictForRestSettings(bool updatedRequestBodyStrictValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update request-body-strict value
            ConfigureOptions options = new(
                runtimeRestRequestBodyStrict: updatedRequestBodyStrictValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the RequestBodyStrict Value is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Rest?.RequestBodyStrict);
            Assert.AreEqual(updatedRequestBodyStrictValue, runtimeConfig.Runtime.Rest.RequestBodyStrict);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.rest.enabled {value} --runtime.rest.path {value}"
        /// on a config with various values results in runtime config update. 
        /// Takes in updated value for enabled and path and further 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(false, "/updatedPath", DisplayName = "Update enabled flag and path in Rest runtime settings.")]
        public void TestUpdateMultipleParametersRestSettings(bool updatedEnabledValue, string updatedPathValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update the path value and enabled flag
            ConfigureOptions options = new(
                runtimeRestPath: updatedPathValue,
                runtimeRestEnabled: updatedEnabledValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the path is updated and enabled is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Rest?.Path);
            Assert.IsNotNull(runtimeConfig.Runtime?.Rest?.Enabled);
            Assert.AreEqual(updatedPathValue, runtimeConfig.Runtime.Rest.Path);
            Assert.AreEqual(updatedEnabledValue, runtimeConfig.Runtime.Rest.Enabled);
        }

        /// <summary>
        /// Validates that running "dab configure --runtime.cache.enabled" on a config with various values results
        /// in runtime config update. Takes in updated value for cache.enabled and 
        /// validates whether the runtime config reflects those updated values.
        [DataTestMethod]
        [DataRow(false, DisplayName = "Update Cache.Enabled to false.")]
        [DataRow(true, DisplayName = "Validate if Cache.Enabled remains true.")]
        public void TestUpdateEnabledForCacheSettings(bool updatedEnabledValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update cache enabled flag
            ConfigureOptions options = new(
                runtimeCacheEnabled: updatedEnabledValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the cache Enabled Flag is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Cache?.Enabled);
            Assert.AreEqual(updatedEnabledValue, runtimeConfig.Runtime.Cache.Enabled);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.cache.ttl-seconds" on a config with various values results
        /// in runtime config update. Takes in updated value for cache.ttl-seconds and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(4, DisplayName = "Update global cache TTL to 4.")]
        public void TestUpdateTTLForCacheSettings(int updatedTtlValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update TTL Value
            ConfigureOptions options = new(
                runtimeCacheTtl: updatedTtlValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the TTL Value is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Cache?.TtlSeconds);
            Assert.AreEqual(updatedTtlValue, runtimeConfig.Runtime.Cache.TtlSeconds);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.compression.level {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for compression.level and
        /// validates whether the runtime config reflects those updated values.
        [DataTestMethod]
        [DataRow(CompressionLevel.Fastest, DisplayName = "Update Compression.Level to fastest.")]
        [DataRow(CompressionLevel.Optimal, DisplayName = "Update Compression.Level to optimal.")]
        [DataRow(CompressionLevel.None, DisplayName = "Update Compression.Level to none.")]
        public void TestUpdateLevelForCompressionSettings(CompressionLevel updatedLevelValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update compression level value
            ConfigureOptions options = new(
                runtimeCompressionLevel: updatedLevelValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Level Value is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Compression?.Level);
            Assert.AreEqual(updatedLevelValue, runtimeConfig.Runtime.Compression.Level);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.host.mode {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for host.mode and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow("production", DisplayName = "Update mode to production for Host.")]
        [DataRow("Production", DisplayName = "Update mode to Production for Host.")]
        [DataRow("development", DisplayName = "Ensure mode is retained to development for Host.")]
        [DataRow("Development", DisplayName = "Ensure mode is retained to Development for Host.")]
        public void TestCaseInsensitiveUpdateModeForHostSettings(string modeValue)
        {
            // Arrange -> all the setup which includes creating options.
            Enum.TryParse<HostMode>(modeValue, ignoreCase: true, out HostMode updatedModeValue);
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update host.mode value
            ConfigureOptions options = new(
                runtimeHostMode: updatedModeValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Mode in Host is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Host?.Mode);
            Assert.AreEqual(updatedModeValue, runtimeConfig.Runtime.Host.Mode);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.host.cors.origins {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for host.cors.origins and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow("https://localhost, https://localhost1", DisplayName = "Overwrite list of origins in Cors in Host with comma.")]
        [DataRow("https://localhost https://localhost1", DisplayName = "Overwrite list of origins in Cors in Host with space.")]
        public void TestUpdateCorsOriginsForHostSettings(string inputValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);
            // Convert the comma-separated string into a List<string>
            List<string> originsValue = inputValue.Split(new char[] { ',', ' ' }).ToList();

            // Act: Attempts to update host.cors.origins value
            ConfigureOptions configureOptions = new(
                runtimeHostCorsOrigins: originsValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(configureOptions, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Cors.Origins in Host is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Host?.Cors?.Origins);
            CollectionAssert.AreEqual(originsValue.ToArray(), runtimeConfig.Runtime.Host.Cors.Origins);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.host.cors.allow-credentials {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for host.cors.allow-credentials and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow(false, DisplayName = "Update cors.allow-credentials to false for Host.")]
        [DataRow(true, DisplayName = "Update cors.allow-credentials to true for Host.")]
        public void TestUpdateCorsAllowCredentialsHostSettings(bool allowCredentialsValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update host.cors.allow-credentials value
            ConfigureOptions options = new(
                runtimeHostCorsAllowCredentials: allowCredentialsValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the cors.allow-credentials in Host is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Host?.Cors?.AllowCredentials);
            Assert.AreEqual(allowCredentialsValue, runtimeConfig.Runtime.Host.Cors.AllowCredentials);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.host.authentication.provider {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for host.authentication.provider and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow("staticWebApps", DisplayName = "Update authentication.provider to StaticWebApps for Host.")]
        [DataRow("Appservice", DisplayName = "Update authentication.provider to AppService for Host.")]
        [DataRow("azuread", DisplayName = "Update authentication.provider to AzureAD for Host.")]
        [DataRow("entraid", DisplayName = "Update authentication.provider to EntraID for Host.")]
        public void TestUpdateAuthenticationProviderHostSettings(string authenticationProviderValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update host.authentication.provider value
            ConfigureOptions options = new(
                runtimeHostAuthenticationProvider: authenticationProviderValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the authentication.provider in Host is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Host?.Authentication?.Provider);
            Assert.AreEqual(authenticationProviderValue, runtimeConfig.Runtime.Host.Authentication.Provider);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.host.authentication.jwt.audience {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for host.authentication.jwt.audience and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow("updatedAudience", DisplayName = "Update authentication.jwt.audience to 'updatedAudience' for Host.")]
        public void TestUpdateAuthenticationJwtAudienceHostSettings(string updatedJwtAudienceValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update host.authentication.jwt.audience value
            ConfigureOptions options = new(
                runtimeHostAuthenticationJwtAudience: updatedJwtAudienceValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the authentication.jwt.audience in Host is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Host?.Authentication?.Jwt?.Audience);
            Assert.AreEqual(updatedJwtAudienceValue.ToString(), runtimeConfig.Runtime.Host.Authentication.Jwt.Audience);
        }

        /// <summary>
        /// Tests that running "dab configure --runtime.host.authentication.jwt.issuer {value}" on a config with various values results
        /// in runtime config update. Takes in updated value for host.authentication.jwt.issuer and 
        /// validates whether the runtime config reflects those updated values
        [DataTestMethod]
        [DataRow("updatedIssuer", DisplayName = "Update authentication.jwt.issuer to 'updatedIssuer' for Host.")]
        public void TestUpdateAuthenticationJwtIssuerHostSettings(string updatedJwtIssuerValue)
        {
            // Arrange -> all the setup which includes creating options.
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            // Act: Attempts to update host.authentication.jwt.issuer value
            ConfigureOptions options = new(
                runtimeHostAuthenticationJwtIssuer: updatedJwtIssuerValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the authentication.jwt.issuer in Host is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? runtimeConfig));
            Assert.IsNotNull(runtimeConfig.Runtime?.Host?.Authentication?.Jwt?.Issuer);
            Assert.AreEqual(updatedJwtIssuerValue.ToString(), runtimeConfig.Runtime.Host.Authentication.Jwt.Issuer);
        }

        /// <summary>
        /// Test to update the current depth limit for GraphQL and removal the depth limit using -1.
        /// When runtime.graphql.depth-limit has an initial value of 8.
        /// validates that "dab configure --runtime.graphql.depth-limit {value}" sets the expected depth limit.
        /// </summary>
        [DataTestMethod]
        [DataRow(20, DisplayName = "Update current depth limit for GraphQL.")]
        [DataRow(-1, DisplayName = "Remove depth limit from GraphQL by setting depth limit to -1.")]
        public void TestUpdateDepthLimitForGraphQL(int? newDepthLimit)
        {
            int currentDepthLimit = 8;

            // Arrange
            RuntimeConfigLoader.TryParseConfig(INITIAL_CONFIG, out RuntimeConfig? config);
            Assert.IsNotNull(config);
            config = config with
            {
                Runtime = config.Runtime! with
                {
                    GraphQL = config.Runtime.GraphQL! with
                    {
                        DepthLimit = currentDepthLimit
                    }
                }
            };

            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(config.ToJson()));
            ConfigureOptions options = new(
                depthLimit: newDepthLimit,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act: Update Depth Limit
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: Validate the Depth Limit is updated
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out config));

            Assert.AreEqual(newDepthLimit, config.Runtime?.GraphQL?.DepthLimit);
        }

        /// <summary>
        /// Tests the update of the database type in the runtime config.
        /// dab configure `--data-source.database-type {dbType}`
        /// This method verifies that the database type can be updated to various valid values, including different cases,
        /// and ensures that the config file is correctly modified and parsed after the update.
        /// </summary>
        [DataTestMethod]
        [DataRow("mssql", DisplayName = "Update the database type to MSSQL")]
        [DataRow("MSSql", DisplayName = "Update the database type to MSSQL with different case")]
        [DataRow("postgresql", DisplayName = "Update the database type to PostgreSQL")]
        [DataRow("cosmosdb_nosql", DisplayName = "Update the database type to CosmosDB_NoSQL")]
        [DataRow("cosmosdb_postgresql", DisplayName = "Update the database type to CosmosDB_PGSQL")]
        [DataRow("mysql", DisplayName = "Update the database type to MySQL")]
        public void TestDatabaseTypeUpdate(string dbType)
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceDatabaseType: dbType,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.Runtime);
            Assert.AreEqual(config.DataSource.DatabaseType, Enum.Parse<DatabaseType>(dbType, ignoreCase: true));
        }

        /// <summary>
        /// Tests the update of the database type from CosmosDB_NoSQL to MSSQL in the runtime config.
        /// This method verifies that the database type can be changed from CosmosDB_NoSQL to MSSQL and that the 
        /// specific MSSQL option 'set-session-context' is correctly added to the configuration and the specific
        /// cosmosDB options are removed.
        /// Command: dab configure --data-source.database-type mssql --data-source.options.set-session-context true 
        /// </summary>
        [TestMethod]
        public void TestDatabaseTypeUpdateCosmosDB_NoSQLToMSSQL()
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_COSMOSDB_NOSQL_CONFIG);

            ConfigureOptions options = new(
                dataSourceDatabaseType: "mssql",
                dataSourceOptionsSetSessionContext: true,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.Runtime);
            Assert.AreEqual(config.DataSource.DatabaseType, DatabaseType.MSSQL);
            Assert.AreEqual(config.DataSource.Options!.GetValueOrDefault("set-session-context", false), true);
            Assert.IsFalse(config.DataSource.Options!.ContainsKey("database"));
            Assert.IsFalse(config.DataSource.Options!.ContainsKey("container"));
            Assert.IsFalse(config.DataSource.Options!.ContainsKey("schema"));
        }

        /// <summary>
        /// Tests the update of the database type from MSSQL to CosmosDB_NoSQL in the runtime config.
        /// This method verifies that the database type can be changed from MSSQL to CosmosDB_NoSQL and that the 
        /// specific CosmosDB_NoSQL options such as database, container, and schema are correctly added to the config.
        /// Command: dab configure --data-source.database-type cosmosdb_nosql
        /// --data-source.options.database testdb --data-source.options.container testcontainer --data-source.options.schema testschema.gql
        /// </summary>
        [TestMethod]
        public void TestDatabaseTypeUpdateMSSQLToCosmosDB_NoSQL()
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceDatabaseType: "cosmosdb_nosql",
                dataSourceOptionsDatabase: "testdb",
                dataSourceOptionsContainer: "testcontainer",
                dataSourceOptionsSchema: "testschema.gql",
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.Runtime);
            Assert.AreEqual(config.DataSource.DatabaseType, DatabaseType.CosmosDB_NoSQL);
            Assert.AreEqual(config.DataSource.Options!.GetValueOrDefault("database"), "testdb");
            Assert.AreEqual(config.DataSource.Options!.GetValueOrDefault("container"), "testcontainer");
            Assert.AreEqual(config.DataSource.Options!.GetValueOrDefault("schema"), "testschema.gql");
        }

        /// <summary>
        /// Tests configuring database type with an invalid database type value.
        /// This method verifies that when an invalid database type is provided,
        /// the runtime config is not updated. It ensures that the method correctly identifies and handles
        /// invalid database types by returning false.
        /// </summary>
        [TestMethod]
        public void TestConfiguringInvalidDatabaseType()
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceDatabaseType: "invalid",
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsFalse(isSuccess);
        }

        /// <summary>
        /// Tests the failure scenario when attempting to add CosmosDB-specific options to an MSSQL database configuration.
        /// This method verifies that the configuration process correctly fails when options such as database, container,
        /// and schema, which are specific to CosmosDB_NoSQL, are provided for an MSSQL database type.
        /// </summary>
        [TestMethod]
        public void TestFailureWhenAddingCosmosDbOptionsToMSSQLDatabase()
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceOptionsDatabase: "testdb",
                dataSourceOptionsContainer: "testcontainer",
                dataSourceOptionsSchema: "testschema.gql",
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsFalse(isSuccess);
        }

        /// <summary>
        /// Tests the failure scenario when attempting to add the 'set-session-context' option to a MySQL database configuration.
        /// This method verifies that the configuration process correctly fails when the 'set-session-context' option,
        /// which is specific to MSSQL/DWSQL, is provided for a MySQL database type.
        /// </summary>
        [TestMethod]
        public void TestFailureWhenAddingSetSessionContextToMySQLDatabase()
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceDatabaseType: "mysql",
                dataSourceOptionsSetSessionContext: true,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsFalse(isSuccess);
        }

        /// <summary>
        /// Tests adding data-source.health.name to a config that doesn't have a health section.
        /// This method verifies that the health.name can be added to a data source configuration
        /// that doesn't previously have a health section.
        /// Command: dab configure --data-source.health.name "My Data Source"
        /// </summary>
        [TestMethod]
        public void TestAddDataSourceHealthName()
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceHealthName: TEST_DATASOURCE_HEALTH_NAME,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.DataSource);
            Assert.IsNotNull(config.DataSource.Health);
            Assert.AreEqual(TEST_DATASOURCE_HEALTH_NAME, config.DataSource.Health.Name);
            Assert.IsTrue(config.DataSource.Health.Enabled); // Default value
        }

        /// <summary>
        /// Tests updating data-source.health.name on a config that already has a health section.
        /// This method verifies that the health.name can be updated while preserving other health settings.
        /// Command: dab configure --data-source.health.name "Updated Name"
        /// </summary>
        [DataTestMethod]
        [DataRow("New Name", DisplayName = "Update health name with a simple string")]
        [DataRow("This is the value", DisplayName = "Update health name with the example from the issue")]
        public void TestUpdateDataSourceHealthName(string healthName)
        {
            // Arrange - Config with existing health section
            string configWithHealth = @"
            {
                ""$schema"": ""test"",
                ""data-source"": {
                    ""database-type"": ""mssql"",
                    ""connection-string"": ""testconnectionstring"",
                    ""health"": {
                        ""enabled"": false,
                        ""threshold-ms"": 2000
                    }
                },
                ""runtime"": {
                    ""rest"": {
                        ""enabled"": true,
                        ""path"": ""/api""
                    },
                    ""graphql"": {
                        ""enabled"": true,
                        ""path"": ""/graphql"",
                        ""allow-introspection"": true
                    },
                    ""host"": {
                        ""mode"": ""development"",
                        ""cors"": {
                            ""origins"": [],
                            ""allow-credentials"": false
                        },
                        ""authentication"": {
                            ""provider"": ""StaticWebApps""
                        }
                    }
                },
                ""entities"": {}
            }";
            SetupFileSystemWithInitialConfig(configWithHealth);

            ConfigureOptions options = new(
                dataSourceHealthName: healthName,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.DataSource);
            Assert.IsNotNull(config.DataSource.Health);
            Assert.AreEqual(healthName, config.DataSource.Health.Name);
            // Verify existing health settings are preserved
            Assert.IsFalse(config.DataSource.Health.Enabled);
            Assert.AreEqual(2000, config.DataSource.Health.ThresholdMs);
        }

        /// <summary>
        /// Validates that `dab configure --show-effective-permissions` correctly displays
        /// effective permissions without modifying the config file.
        /// Covers:
        /// 1. Entities are listed alphabetically.
        /// 2. Explicitly configured roles show their actions.
        /// 3. When only anonymous is configured, authenticated inherits from anonymous.
        /// 4. An inheritance note is emitted for unconfigured named roles.
        /// 5. The config file is not modified.
        /// </summary>
        [DataTestMethod]
        [DataRow(
            true, false,
            "authenticated", "Read (inherited from: anonymous)",
            "Any unconfigured named role inherits from: anonymous",
            DisplayName = "Only anonymous defined: authenticated inherits from anonymous.")]
        [DataRow(
            true, true,
            null, null,
            "Any unconfigured named role inherits from: authenticated",
            DisplayName = "Both anonymous and authenticated defined: named roles inherit from authenticated.")]
        public void TestShowEffectivePermissions(
            bool hasAnonymous,
            bool hasAuthenticated,
            string? expectedInheritedRole,
            string? expectedInheritedActionsSubstring,
            string expectedInheritanceNote)
        {
            // Arrange: build a config with two entities (Zebra before Alpha to verify sorting)
            // and the specified role combinations.
            string permissionsJson = "";
            List<string> perms = new();
            if (hasAnonymous)
            {
                perms.Add(@"{ ""role"": ""anonymous"", ""actions"": [""read""] }");
            }

            if (hasAuthenticated)
            {
                perms.Add(@"{ ""role"": ""authenticated"", ""actions"": [""create"", ""read"" ] }");
            }

            permissionsJson = string.Join(",", perms);

            string configJson = @"
            {
                ""$schema"": ""test"",
                ""data-source"": {
                    ""database-type"": ""mssql"",
                    ""connection-string"": ""testconnectionstring""
                },
                ""runtime"": {
                    ""rest"": { ""enabled"": true, ""path"": ""/api"" },
                    ""graphql"": { ""enabled"": true, ""path"": ""/graphql"", ""allow-introspection"": true },
                    ""host"": {
                        ""mode"": ""development"",
                        ""cors"": { ""origins"": [], ""allow-credentials"": false },
                        ""authentication"": { ""provider"": ""StaticWebApps"" }
                    }
                },
                ""entities"": {
                    ""Zebra"": {
                        ""source"": ""ZebraTable"",
                        ""permissions"": [" + permissionsJson + @"]
                    },
                    ""Alpha"": {
                        ""source"": ""AlphaTable"",
                        ""permissions"": [" + permissionsJson + @"]
                    }
                }
            }";

            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(configJson));
            string configBefore = _fileSystem.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);

            // Capture logger output via a StringWriter on Console
            StringWriter writer = new();
            Console.SetOut(writer);

            // Act
            ConfigureOptions options = new(
                showEffectivePermissions: true,
                config: TEST_RUNTIME_CONFIG_FILE
            );
            bool isSuccess = ConfigGenerator.TryShowEffectivePermissions(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert: operation succeeded
            Assert.IsTrue(isSuccess, "TryShowEffectivePermissions should return true.");

            // Assert: config file is unchanged (read-only operation)
            string configAfter = _fileSystem.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.AreEqual(configBefore, configAfter, "Config file should not be modified by --show-effective-permissions.");

            // Note: TryShowEffectivePermissions uses ILogger (not Console), so we verify
            // behavior indirectly by re-checking the logic via the RuntimeConfig.
            // Parse config and verify the expected inheritance rules hold.
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(configJson, out RuntimeConfig? config));

            // Verify alphabetical entity ordering
            string[] entityNames = config!.Entities.Select(e => e.Key).ToArray();
            string[] sortedNames = entityNames.OrderBy(n => n, StringComparer.OrdinalIgnoreCase).ToArray();
            CollectionAssert.AreEqual(sortedNames, new[] { "Alpha", "Zebra" },
                "Entities should be listed alphabetically.");

            // Verify entity permission structure matches expectations
            Entity firstEntity = config.Entities[sortedNames[0]];
            bool configHasAnonymous = firstEntity.Permissions.Any(p => p.Role.Equals("anonymous", StringComparison.OrdinalIgnoreCase));
            bool configHasAuthenticated = firstEntity.Permissions.Any(p => p.Role.Equals("authenticated", StringComparison.OrdinalIgnoreCase));
            Assert.AreEqual(hasAnonymous, configHasAnonymous);
            Assert.AreEqual(hasAuthenticated, configHasAuthenticated);

            // When only anonymous is defined, verify inherited role line would be generated
            if (hasAnonymous && !hasAuthenticated)
            {
                Assert.IsNotNull(expectedInheritedRole, "Expected inherited role should be 'authenticated'.");
                Assert.AreEqual("authenticated", expectedInheritedRole);

                // Verify the anonymous actions would be inherited
                EntityPermission anonPerm = firstEntity.Permissions.First(p => p.Role.Equals("anonymous", StringComparison.OrdinalIgnoreCase));
                string inheritedActions = string.Join(", ", anonPerm.Actions.Select(a => a.Action.ToString()));
                Assert.AreEqual("Read", inheritedActions, "Inherited actions should match anonymous role's actions.");
            }

            // When authenticated is explicitly defined, no inheritance line for authenticated
            if (hasAuthenticated)
            {
                Assert.IsNull(expectedInheritedRole, "No inherited role line when authenticated is explicitly configured.");
            }
        }

        /// <summary>
        /// Validates that --show-effective-permissions returns true and outputs entities sorted a-z by name.
        /// </summary>
        [TestMethod]
        public void TestShowEffectivePermissions_EntitiesSortedAlphabetically()
        {
            // Arrange: Config with "Zebra" entity before "Apple" entity (insertion order reversed).
            string config = $@"{{
                {SAMPLE_SCHEMA_DATA_SOURCE},
                {RUNTIME_SECTION},
                ""entities"": {{
                    ""Zebra"": {{
                        ""source"": ""dbo.Zebra"",
                        ""permissions"": [
                            {{ ""role"": ""anonymous"", ""actions"": [""read""] }}
                        ]
                    }},
                    ""Apple"": {{
                        ""source"": ""dbo.Apple"",
                        ""permissions"": [
                            {{ ""role"": ""anonymous"", ""actions"": [""read""] }}
                        ]
                    }}
                }}
            }}";

            List<string> logMessages = new();
            ListLogger<ConfigGenerator> logger = new(logMessages);
            SetLoggerForCliConfigGenerator(logger);
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(config));

            ConfigureOptions options = new(
                config: TEST_RUNTIME_CONFIG_FILE,
                showEffectivePermissions: true
            );

            // Act
            bool isSuccess = TryShowEffectivePermissions(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            int appleIndex = logMessages.FindIndex(m => m.Contains("Apple"));
            int zebraIndex = logMessages.FindIndex(m => m.Contains("Zebra"));
            Assert.IsTrue(appleIndex >= 0, "Expected 'Apple' entity in output.");
            Assert.IsTrue(zebraIndex >= 0, "Expected 'Zebra' entity in output.");
            Assert.IsTrue(appleIndex < zebraIndex, "Expected 'Apple' to appear before 'Zebra' in output.");
        }

        /// <summary>
        /// Validates that --show-effective-permissions outputs roles sorted a-z within each entity.
        /// </summary>
        [TestMethod]
        public void TestShowEffectivePermissions_RolesSortedAlphabeticallyWithinEntity()
        {
            // Arrange: Config with roles "zebra-role" before "admin" (insertion order reversed).
            string config = $@"{{
                {SAMPLE_SCHEMA_DATA_SOURCE},
                {RUNTIME_SECTION},
                ""entities"": {{
                    ""Book"": {{
                        ""source"": ""dbo.Book"",
                        ""permissions"": [
                            {{ ""role"": ""zebra-role"", ""actions"": [""read""] }},
                            {{ ""role"": ""admin"", ""actions"": [""create"", ""read"", ""update"", ""delete""] }}
                        ]
                    }}
                }}
            }}";

            List<string> logMessages = new();
            ListLogger<ConfigGenerator> logger = new(logMessages);
            SetLoggerForCliConfigGenerator(logger);
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(config));

            ConfigureOptions options = new(
                config: TEST_RUNTIME_CONFIG_FILE,
                showEffectivePermissions: true
            );

            // Act
            bool isSuccess = TryShowEffectivePermissions(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);

            // Within the entity, "admin" should appear before "zebra-role".
            int adminIndex = logMessages.FindIndex(m => m.Contains("admin"));
            int zebraRoleIndex = logMessages.FindIndex(m => m.Contains("zebra-role"));
            Assert.IsTrue(adminIndex >= 0, "Expected 'admin' role in output.");
            Assert.IsTrue(zebraRoleIndex >= 0, "Expected 'zebra-role' role in output.");
            Assert.IsTrue(adminIndex < zebraRoleIndex, "Expected 'admin' to appear before 'zebra-role' in output.");
        }

        /// <summary>
        /// Validates that --show-effective-permissions shows the authenticated-inherits-anonymous line
        /// when anonymous is configured but authenticated is not.
        /// </summary>
        [TestMethod]
        public void TestShowEffectivePermissions_AuthenticatedInheritsAnonymousNote()
        {
            // Arrange: anonymous defined, authenticated not defined.
            string config = $@"{{
                {SAMPLE_SCHEMA_DATA_SOURCE},
                {RUNTIME_SECTION},
                ""entities"": {{
                    ""Book"": {{
                        ""source"": ""dbo.Book"",
                        ""permissions"": [
                            {{ ""role"": ""anonymous"", ""actions"": [""read""] }}
                        ]
                    }}
                }}
            }}";

            List<string> logMessages = new();
            ListLogger<ConfigGenerator> logger = new(logMessages);
            SetLoggerForCliConfigGenerator(logger);
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(config));

            ConfigureOptions options = new(
                config: TEST_RUNTIME_CONFIG_FILE,
                showEffectivePermissions: true
            );

            // Act
            bool isSuccess = TryShowEffectivePermissions(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);

            // Should show "authenticated" inheriting from "anonymous".
            bool hasAuthenticatedInheritedLine = logMessages.Any(m =>
                m.Contains("authenticated") && m.Contains("inherited from") && m.Contains("anonymous"));
            Assert.IsTrue(hasAuthenticatedInheritedLine, "Expected a line showing authenticated inherits from anonymous.");

            // Should show inheritance note for unconfigured named roles.
            // When only anonymous is defined, the note points to "anonymous" (since authenticated
            // is itself shown as inheriting from anonymous via the line above).
            bool hasInheritanceNote = logMessages.Any(m =>
                m.Contains("unconfigured named role") && m.Contains("anonymous"));
            Assert.IsTrue(hasInheritanceNote, "Expected an inheritance note pointing to 'anonymous'.");
        }

        /// <summary>
        /// Validates that --show-effective-permissions does not show an authenticated-inherits-anonymous
        /// line when authenticated is explicitly configured for the entity.
        /// </summary>
        [TestMethod]
        public void TestShowEffectivePermissions_NoInheritanceNoteWhenAuthenticatedExplicitlyConfigured()
        {
            // Arrange: Both anonymous and authenticated explicitly defined.
            string config = $@"{{
                {SAMPLE_SCHEMA_DATA_SOURCE},
                {RUNTIME_SECTION},
                ""entities"": {{
                    ""Book"": {{
                        ""source"": ""dbo.Book"",
                        ""permissions"": [
                            {{ ""role"": ""anonymous"", ""actions"": [""read""] }},
                            {{ ""role"": ""authenticated"", ""actions"": [""read"", ""create""] }}
                        ]
                    }}
                }}
            }}";

            List<string> logMessages = new();
            ListLogger<ConfigGenerator> logger = new(logMessages);
            SetLoggerForCliConfigGenerator(logger);
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(config));

            ConfigureOptions options = new(
                config: TEST_RUNTIME_CONFIG_FILE,
                showEffectivePermissions: true
            );

            // Act
            bool isSuccess = TryShowEffectivePermissions(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);

            // Should NOT show an "authenticated inherits from anonymous" line.
            bool hasUnexpectedInheritanceLine = logMessages.Any(m =>
                m.Contains("authenticated") && m.Contains("inherited from") && m.Contains("anonymous"));
            Assert.IsFalse(hasUnexpectedInheritanceLine,
                "Should not show authenticated-inherits-anonymous when authenticated is explicitly configured.");
        }

        /// <summary>
        /// Validates that --show-effective-permissions returns false when the config file does not exist.
        /// </summary>
        [TestMethod]
        public void TestShowEffectivePermissions_ReturnsFalseWhenConfigMissing()
        {
            // Arrange: no config file added to the file system.
            List<string> logMessages = new();
            ListLogger<ConfigGenerator> logger = new(logMessages);
            SetLoggerForCliConfigGenerator(logger);

            ConfigureOptions options = new(
                config: "nonexistent-config.json",
                showEffectivePermissions: true
            );

            // Act
            bool isSuccess = TryShowEffectivePermissions(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsFalse(isSuccess);
        }

        /// <summary>
        /// Sets up the mock file system with an initial configuration file.
        /// This method adds a config file to the mock file system and verifies its existence.
        /// It also attempts to parse the config file to ensure it is valid.
        /// </summary>
        /// <param name="jsonConfig">The config file data as a json string.</param>
        private void SetupFileSystemWithInitialConfig(string jsonConfig)
        {
            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(jsonConfig));

            Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));

            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(jsonConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.Runtime);
        }

        /// <summary>
        /// A simple ILogger implementation that records all log messages to a list,
        /// enabling tests to assert on log output without redirecting console streams.
        /// </summary>
        private sealed class ListLogger<T> : ILogger<T>
        {
            private readonly List<string> _messages;

            public ListLogger(List<string> messages)
            {
                _messages = messages;
            }

            public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;

            public bool IsEnabled(LogLevel logLevel) => true;

            public void Log<TState>(
                LogLevel logLevel,
                EventId eventId,
                TState state,
                Exception? exception,
                Func<TState, Exception?, string> formatter)
            {
                _messages.Add(formatter(state, exception));
            }
        }

        /// <summary>
        /// Tests adding user-delegated-auth configuration options individually or together.
        /// Verifies that enabled and database-audience properties can be set independently or combined.
        /// Also verifies default values for properties not explicitly set.
        /// Commands:
        /// - dab configure --data-source.user-delegated-auth.enabled true
        /// - dab configure --data-source.user-delegated-auth.database-audience "https://database.windows.net"
        /// - dab configure --data-source.user-delegated-auth.enabled true --data-source.user-delegated-auth.database-audience "https://database.windows.net"
        /// </summary>
        [DataTestMethod]
        [DataRow(true, null, DisplayName = "Set enabled=true only")]
        [DataRow(null, "https://database.windows.net", DisplayName = "Set database-audience only")]
        [DataRow(true, "https://database.windows.net", DisplayName = "Set both enabled and database-audience")]
        public void TestAddUserDelegatedAuthConfiguration(bool? enabledValue, string? audienceValue)
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceUserDelegatedAuthEnabled: enabledValue,
                dataSourceUserDelegatedAuthDatabaseAudience: audienceValue,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.DataSource);
            Assert.IsNotNull(config.DataSource.UserDelegatedAuth);

            // Verify enabled value (if set, use provided value; otherwise defaults to false)
            if (enabledValue.HasValue)
            {
                Assert.AreEqual(enabledValue.Value, config.DataSource.UserDelegatedAuth.Enabled);
            }
            else
            {
                Assert.IsFalse(config.DataSource.UserDelegatedAuth.Enabled);
            }

            // Verify database-audience value
            if (audienceValue is not null)
            {
                Assert.AreEqual(audienceValue, config.DataSource.UserDelegatedAuth.DatabaseAudience);
            }
            else
            {
                Assert.IsNull(config.DataSource.UserDelegatedAuth.DatabaseAudience);
            }

            // Verify provider is set to default
            Assert.AreEqual("EntraId", config.DataSource.UserDelegatedAuth.Provider);
        }

        /// <summary>
        /// Tests that enabling user-delegated-auth on a non-MSSQL database fails.
        /// This method verifies that user-delegated-auth is only allowed for MSSQL database type.
        /// Command: dab configure --data-source.database-type postgresql --data-source.user-delegated-auth.enabled true
        /// </summary>
        [DataTestMethod]
        [DataRow("postgresql", DisplayName = "Fail when enabling user-delegated-auth on PostgreSQL")]
        [DataRow("mysql", DisplayName = "Fail when enabling user-delegated-auth on MySQL")]
        [DataRow("cosmosdb_nosql", DisplayName = "Fail when enabling user-delegated-auth on CosmosDB")]
        public void TestFailureWhenEnablingUserDelegatedAuthOnNonMSSQLDatabase(string dbType)
        {
            // Arrange
            SetupFileSystemWithInitialConfig(INITIAL_CONFIG);

            ConfigureOptions options = new(
                dataSourceDatabaseType: dbType,
                dataSourceUserDelegatedAuthEnabled: true,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsFalse(isSuccess);
        }

        /// <summary>
        /// Tests updating existing user-delegated-auth configuration by changing the database-audience.
        /// Verifies that the database-audience can be updated while preserving the enabled setting.
        /// Also validates JSON structure: verifies user-delegated-auth is correctly nested under data-source
        /// with proper JSON property names (enabled, provider, database-audience).
        /// </summary>
        [TestMethod]
        public void TestUpdateUserDelegatedAuthDatabaseAudience()
        {
            // Arrange - Config with existing user-delegated-auth section
            SetupFileSystemWithInitialConfig(TestHelper.CONFIG_WITH_USER_DELEGATED_AUTH);

            string newAudience = "https://database.usgovcloudapi.net";
            ConfigureOptions options = new(
                dataSourceUserDelegatedAuthDatabaseAudience: newAudience,
                config: TEST_RUNTIME_CONFIG_FILE
            );

            // Act
            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);

            // Assert
            Assert.IsTrue(isSuccess);
            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
            Assert.IsNotNull(config.DataSource);
            Assert.IsNotNull(config.DataSource.UserDelegatedAuth);
            Assert.IsTrue(config.DataSource.UserDelegatedAuth.Enabled);
            Assert.AreEqual(newAudience, config.DataSource.UserDelegatedAuth.DatabaseAudience);
            Assert.AreEqual("EntraId", config.DataSource.UserDelegatedAuth.Provider);

            // Verify JSON structure using JObject to ensure correct nesting
            JObject configJson = JObject.Parse(updatedConfig);
            JToken? userDelegatedAuthSection = configJson["data-source"]?["user-delegated-auth"];
            Assert.IsNotNull(userDelegatedAuthSection);
            Assert.AreEqual(newAudience, (string?)userDelegatedAuthSection["database-audience"]);
            Assert.AreEqual(true, (bool?)userDelegatedAuthSection["enabled"]);
            Assert.AreEqual("EntraId", (string?)userDelegatedAuthSection["provider"]);
        }
    }
}