Handle Exception during dab validate when SqlMetadataProvider has not correctly initialized (#2202)

## Why make this change?
Closes #2184
Closes #2180


## What is this change?

When we don't properly initialize the `SqlMetadataProvider`, certain
functions will not behave as intended. This change adds some defensive
programming around this fact so that we have more readable exceptions in
these cases, as well as restructuring the validation to avoid the
potential of such a circumstance.

We refactor the `ValidateEntitiesMetadata` function into 2 functions,
one called `ValidateRelationshipConfigCorrectness` that validates the
relationships in the config without needing to cross reference database
metadata, and leaving the remaining validations that do require such
metadata within the original function. This validation is then handled
by a mix of the initialization of the metadata provider (this init
process does some validation), and the call to `ValidateRelationships`
which happens from within `ValidateEntitiesMetadata` only when the
initialization of the metadata provider resulted in no connection
errors.

Therefore, the normal code path when doing `dab validate` will be

1. Call `ValidateRelationshipConfigCorrectness`
2. Call `ValidateEntitiesMetadata`
    2a. If there were no connection errors Call `ValidateRelationships`



![image](https://github.com/Azure/data-api-builder/assets/93220300/1e2feec5-ac73-4e57-b3eb-01f032f362cf)


## How was this tested?

Manually, against our test suite, and we add a regression test that
looks for the correct error messaging when the config that caused the
error from the finding of the bug is used.

## Sample Request(s)

This can be reprod by using the command `dab validate -c <path to
config>

Author: aaronburtle

src/Cli.Tests/TestHelper.cs

@@ -1065,6 +1065,104 @@ public static Process ExecuteDabCommand(string command, string flags)
         }
       }";
 
+        public const string COMPLETE_CONFIG_WITH_RELATIONSHIPS_NON_WORKING_CONN_STRING = @"
+        {
+  ""$schema"": ""https://github.com/Azure/data-api-builder/releases/download/vmajor.minor.patch/dab.draft.schema.json"",
+  ""data-source"": {
+    ""database-type"": ""mssql"",
+    ""options"": {
+      ""set-session-context"": false
+    },
+    ""connection-string"": ""Server=XXXXX;Persist Security Info=False;User ID=<USERHERE>;Password=<PWD HERE> ;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=5;""
+  },
+  ""runtime"": {
+    ""rest"": {
+      ""enabled"": true,
+      ""path"": ""/api""
+    },
+    ""graphql"": {
+      ""allow-introspection"": true,
+      ""enabled"": true,
+      ""path"": ""/graphql""
+    },
+    ""host"": {
+      ""mode"": ""development"",
+      ""cors"": {
+        ""origins"": [],
+        ""allow-credentials"": false
+      },
+      ""authentication"": {
+        ""provider"": ""StaticWebApps""
+      }
+    }
+  },
+  ""entities"": {
+    ""Publisher"": {
+      ""source"": {
+        ""object"": ""publishers"",
+        ""type"": ""table"",
+        ""key-fields"": [ ""id"" ]
+      },
+      ""graphql"": {
+        ""enabled"": true,
+        ""type"": {
+          ""singular"": ""Publisher"",
+          ""plural"": ""Publishers""
+        }
+      },
+      ""rest"": {
+        ""enabled"": true
+      },
+      ""permissions"": [
+      ],
+      ""relationships"": {
+        ""books"": {
+          ""cardinality"": ""many"",
+          ""target.entity"": ""Book"",
+          ""source.fields"": [ ""id"" ],
+          ""target.fields"": [ ""publisher_id"" ],
+          ""linking.source.fields"": [],
+          ""linking.target.fields"": []
+        }
+      }
+    },
+    ""Book"": {
+      ""source"": {
+        ""object"": ""books"",
+        ""type"": ""table"",
+        ""key-fields"": [ ""id"" ]
+      },
+      ""graphql"": {
+        ""enabled"": true,
+        ""type"": {
+          ""singular"": ""book"",
+          ""plural"": ""books""
+        }
+      },
+      ""rest"": {
+        ""enabled"": true
+      },
+      ""permissions"": [
+      ],
+      ""mappings"": {
+        ""id"": ""id"",
+        ""title"": ""title""
+      },
+      ""relationships"": {
+        ""publishers"": {
+          ""cardinality"": ""one"",
+          ""target.entity"": ""Publisher"",
+          ""source.fields"": [ ""publisher_id"" ],
+          ""target.fields"": [ ""id"" ],
+          ""linking.source.fields"": [],
+          ""linking.target.fields"": []
+        }
+      }
+    }
+  }
+}
+";
+
         /// <summary>
         /// Creates basic initialization options for MS SQL config.
         /// </summary>

src/Cli.Tests/ValidateConfigTests.cs

@@ -46,6 +46,31 @@ public void TestConfigWithCustomPropertyAsInvalid()
         Assert.IsFalse(isConfigValid);
     }
 
+    /// <summary>
+    /// This method verifies that the relationship validation does not cause unhandled
+    /// exceptions, and that the errors generated include the expected messaging.
+    /// This case is a regression test due to the metadata needed not always being
+    /// populated in the SqlMetadataProvider if for example a bad connection string
+    /// is given.
+    /// </summary>
+    [TestMethod]
+    public void TestErrorHandlingForRelationshipValidationWithNonWorkingConnectionString()
+    {
+        // Arrange
+        ((MockFileSystem)_fileSystem!).AddFile(TEST_RUNTIME_CONFIG_FILE, COMPLETE_CONFIG_WITH_RELATIONSHIPS_NON_WORKING_CONN_STRING);
+        ValidateOptions validateOptions = new(TEST_RUNTIME_CONFIG_FILE);
+        StringWriter writer = new();
+        // Capture console output to get error messaging.
+        Console.SetOut(writer);
+
+        // Act
+        ConfigGenerator.IsConfigValid(validateOptions, _runtimeConfigLoader!, _fileSystem!);
+        string errorMessage = writer.ToString();
+
+        // Assert
+        Assert.IsTrue(errorMessage.Contains(DataApiBuilderException.CONNECTION_STRING_ERROR_MESSAGE));
+    }
+
     /// <summary>
     /// Validates that the IsConfigValid method returns false when a config is passed with
     /// both rest and graphQL disabled globally.

src/Core/Configurations/RuntimeConfigValidator.cs

@@ -92,23 +92,31 @@ bool VerifyForeignKeyExistsInDB(
         /// try to get the exposed name associated
         /// with the provided field, if it exists, save in out
         /// parameter, and return true, otherwise return false.
+        /// If an entity name is provided that does not exist
+        /// as metadata in this metadata provider, a KeyNotFoundException
+        /// is thrown.
         /// </summary>
         /// <param name="entityName">The entity whose mapping we lookup.</param>
         /// <param name="backingFieldName">The field used for the lookup in the mapping.</param>
         /// <param name="name">Out parameter in which we will save exposed name.</param>
         /// <returns>True if exists, false otherwise.</returns>
+        /// <throws>KeyNotFoundException if entity name not found.</throws>
         bool TryGetExposedColumnName(string entityName, string backingFieldName, [NotNullWhen(true)] out string? name);
 
         /// <summary>
         /// For the entity that is provided as an argument,
         /// try to get the underlying backing column name associated
         /// with the provided field, if it exists, save in out
         /// parameter, and return true, otherwise return false.
+        /// If an entity name is provided that does not exist
+        /// as metadata in this metadata provider, a KeyNotFoundException
+        /// is thrown.
         /// </summary>
         /// <param name="entityName">The entity whose mapping we lookup.</param>
         /// <param name="field">The field used for the lookup in the mapping.</param>
         /// <param name="name"/>Out parameter in which we will save backing column name.<param>
         /// <returns>True if exists, false otherwise.</returns>
+        /// <throws>KeyNotFoundException if entity name not found.</throws>
         bool TryGetBackingColumn(string entityName, string field, [NotNullWhen(true)] out string? name);
 
         /// <summary>

src/Core/Services/MetadataProviders/ISqlMetadataProvider.cs

@@ -209,13 +209,25 @@ public StoredProcedureDefinition GetStoredProcedureDefinition(string entityName)
         /// <inheritdoc />
         public bool TryGetExposedColumnName(string entityName, string backingFieldName, [NotNullWhen(true)] out string? name)
         {
-            return EntityBackingColumnsToExposedNames[entityName].TryGetValue(backingFieldName, out name);
+            Dictionary<string, string>? backingColumnsToExposedNamesMap;
+            if (!EntityBackingColumnsToExposedNames.TryGetValue(entityName, out backingColumnsToExposedNamesMap))
+            {
+                throw new KeyNotFoundException($"Initialization of metadata incomplete for entity: {entityName}");
+            }
+
+            return backingColumnsToExposedNamesMap.TryGetValue(backingFieldName, out name);
         }
 
         /// <inheritdoc />
         public bool TryGetBackingColumn(string entityName, string field, [NotNullWhen(true)] out string? name)
         {
-            return EntityExposedNamesToBackingColumnNames[entityName].TryGetValue(field, out name);
+            Dictionary<string, string>? exposedNamesToBackingColumnsMap;
+            if (!EntityExposedNamesToBackingColumnNames.TryGetValue(entityName, out exposedNamesToBackingColumnsMap))
+            {
+                throw new KeyNotFoundException($"Initialization of metadata incomplete for entity: {entityName}");
+            }
+
+            return exposedNamesToBackingColumnsMap.TryGetValue(field, out name);
         }
 
         /// <inheritdoc />

src/Core/Services/MetadataProviders/SqlMetadataProvider.cs

@@ -1271,6 +1271,7 @@ public async Task TestSqlMetadataForValidConfigEntities()
                     configValidatorLogger.Object,
                     isValidateOnly: true);
 
+            configValidator.ValidateRelationshipConfigCorrectness(configProvider.GetConfig());
             await configValidator.ValidateEntitiesMetadata(configProvider.GetConfig(), mockLoggerFactory);
             Assert.IsTrue(configValidator.ConfigValidationExceptions.IsNullOrEmpty());
         }
@@ -1337,6 +1338,7 @@ public async Task TestSqlMetadataForInvalidConfigEntities()
 
             ILoggerFactory mockLoggerFactory = TestHelper.ProvisionLoggerFactory();
 
+            configValidator.ValidateRelationshipConfigCorrectness(configProvider.GetConfig());
             await configValidator.ValidateEntitiesMetadata(configProvider.GetConfig(), mockLoggerFactory);
 
             Assert.IsTrue(configValidator.ConfigValidationExceptions.Any());
@@ -1418,6 +1420,7 @@ public async Task TestSqlMetadataValidationForEntitiesWithInvalidSource()
 
             try
             {
+                configValidator.ValidateRelationshipConfigCorrectness(configProvider.GetConfig());
                 await configValidator.ValidateEntitiesMetadata(configProvider.GetConfig(), mockLoggerFactory);
             }
             catch

src/Service.Tests/Configuration/ConfigurationTests.cs

@@ -262,13 +262,10 @@ public void TestAddingRelationshipWithInvalidTargetEntity()
             );
 
             RuntimeConfigValidator configValidator = InitializeRuntimeConfigValidator();
-            Mock<ISqlMetadataProvider> _sqlMetadataProvider = new();
-            Mock<IMetadataProviderFactory> _metadataProviderFactory = new();
-            _metadataProviderFactory.Setup(x => x.GetMetadataProvider(It.IsAny<string>())).Returns(_sqlMetadataProvider.Object);
 
             // Assert that expected exception is thrown. Entity used in relationship is Invalid
             DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(() =>
-                configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object));
+                configValidator.ValidateRelationshipConfigCorrectness(runtimeConfig));
             Assert.AreEqual($"Entity: {sampleRelationship.TargetEntity} used for relationship is not defined in the config.", ex.Message);
             Assert.AreEqual(HttpStatusCode.ServiceUnavailable, ex.StatusCode);
         }
@@ -325,13 +322,10 @@ public void TestAddingRelationshipWithDisabledGraphQL()
             );
 
             RuntimeConfigValidator configValidator = InitializeRuntimeConfigValidator();
-            Mock<ISqlMetadataProvider> _sqlMetadataProvider = new();
-            Mock<IMetadataProviderFactory> _metadataProviderFactory = new();
-            _metadataProviderFactory.Setup(x => x.GetMetadataProvider(It.IsAny<string>())).Returns(_sqlMetadataProvider.Object);
 
             // Exception should be thrown as we cannot use an entity (with graphQL disabled) in a relationship.
             DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(() =>
-                configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object));
+                configValidator.ValidateRelationshipConfigCorrectness(runtimeConfig));
             Assert.AreEqual($"Entity: {sampleRelationship.TargetEntity} is disabled for GraphQL.", ex.Message);
             Assert.AreEqual(HttpStatusCode.ServiceUnavailable, ex.StatusCode);
         }
@@ -417,7 +411,7 @@ string relationshipEntity
 
             // Exception thrown as foreignKeyPair not found in the DB.
             DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(() =>
-                configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object));
+                configValidator.ValidateRelationships(runtimeConfig, _metadataProviderFactory.Object));
             Assert.AreEqual($"Could not find relationship between Linking Object: TEST_SOURCE_LINK"
                 + $" and entity: {relationshipEntity}.", ex.Message);
             Assert.AreEqual(HttpStatusCode.ServiceUnavailable, ex.StatusCode);
@@ -435,7 +429,7 @@ string relationshipEntity
 
             // Since, we have defined the relationship in Database,
             // the engine was able to find foreign key relation and validation will pass.
-            configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object);
+            configValidator.ValidateRelationships(runtimeConfig, _metadataProviderFactory.Object);
         }
 
         /// <summary>
@@ -498,7 +492,7 @@ public void TestRelationshipWithNoLinkingObjectAndEitherSourceOrTargetFieldIsNul
             // Exception is thrown as foreignKey pair is not specified in the config, nor defined
             // in the database.
             DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(() =>
-                configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object));
+                configValidator.ValidateRelationships(runtimeConfig, _metadataProviderFactory.Object));
             Assert.AreEqual($"Could not find relationship between entities:"
                 + $" SampleEntity1 and SampleEntity2.", ex.Message);
             Assert.AreEqual(HttpStatusCode.ServiceUnavailable, ex.StatusCode);
@@ -518,7 +512,7 @@ public void TestRelationshipWithNoLinkingObjectAndEitherSourceOrTargetFieldIsNul
 
             // No Exception is thrown as foreignKey Pair was found in the DB between
             // source and target entity.
-            configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object);
+            configValidator.ValidateRelationships(runtimeConfig, _metadataProviderFactory.Object);
         }
 
         /// <summary>
@@ -566,7 +560,6 @@ public void TestRelationshipWithoutSourceAndTargetFieldsMatching(
             FileSystemRuntimeConfigLoader loader = new(fileSystem);
             RuntimeConfigProvider provider = new(loader) { IsLateConfigured = true };
             RuntimeConfigValidator configValidator = new(provider, fileSystem, new Mock<ILogger<RuntimeConfigValidator>>().Object);
-            Mock<ISqlMetadataProvider> _sqlMetadataProvider = new();
 
             Dictionary<string, DatabaseObject> mockDictionaryForEntityDatabaseObject = new()
             {
@@ -581,16 +574,10 @@ public void TestRelationshipWithoutSourceAndTargetFieldsMatching(
                 }
             };
 
-            _sqlMetadataProvider.Setup<Dictionary<string, DatabaseObject>>(x =>
-                x.EntityToDatabaseObject).Returns(mockDictionaryForEntityDatabaseObject);
-
-            Mock<IMetadataProviderFactory> _metadataProviderFactory = new();
-            _metadataProviderFactory.Setup(x => x.GetMetadataProvider(It.IsAny<string>())).Returns(_sqlMetadataProvider.Object);
-
             // Exception is thrown since sourceFields and targetFields do not match in either their existence,
             // or their length.
             DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(() =>
-                configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object));
+                configValidator.ValidateRelationshipConfigCorrectness(runtimeConfig));
             Assert.AreEqual(expectedExceptionMessage, ex.Message);
             Assert.AreEqual(HttpStatusCode.ServiceUnavailable, ex.StatusCode);
             Assert.AreEqual(DataApiBuilderException.SubStatusCodes.ConfigValidationError, ex.SubStatusCode);
@@ -672,7 +659,7 @@ public void TestRelationshipWithoutSourceAndTargetFieldsAsValidBackingColumns(
 
             // Exception is thrown since either source or target field does not exist as a valid backing column in their respective entity.
             DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(() =>
-                configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object));
+                configValidator.ValidateRelationships(runtimeConfig, _metadataProviderFactory.Object));
             Assert.AreEqual(expectedExceptionMessage, ex.Message);
             Assert.AreEqual(HttpStatusCode.ServiceUnavailable, ex.StatusCode);
             Assert.AreEqual(DataApiBuilderException.SubStatusCodes.ConfigValidationError, ex.SubStatusCode);
@@ -776,7 +763,6 @@ public void TestRelationshipWithoutLinkingSourceAndTargetFieldsMatching(
             FileSystemRuntimeConfigLoader loader = new(fileSystem);
             RuntimeConfigProvider provider = new(loader) { IsLateConfigured = true };
             RuntimeConfigValidator configValidator = new(provider, fileSystem, new Mock<ILogger<RuntimeConfigValidator>>().Object);
-            Mock<ISqlMetadataProvider> _sqlMetadataProvider = new();
 
             Dictionary<string, DatabaseObject> mockDictionaryForEntityDatabaseObject = new()
             {
@@ -791,19 +777,10 @@ public void TestRelationshipWithoutLinkingSourceAndTargetFieldsMatching(
                 }
             };
 
-            _sqlMetadataProvider.Setup<Dictionary<string, DatabaseObject>>(x =>
-                x.EntityToDatabaseObject).Returns(mockDictionaryForEntityDatabaseObject);
-
-            string discard;
-            _sqlMetadataProvider.Setup(x => x.TryGetExposedColumnName(It.IsAny<string>(), It.IsAny<string>(), out discard)).Returns(true);
-
-            Mock<IMetadataProviderFactory> _metadataProviderFactory = new();
-            _metadataProviderFactory.Setup(x => x.GetMetadataProvider(It.IsAny<string>())).Returns(_sqlMetadataProvider.Object);
-
             // Exception is thrown since linkingSourceFields and linkingTargetFields do not match in either their existence,
             // or their length.
             DataApiBuilderException ex = Assert.ThrowsException<DataApiBuilderException>(() =>
-                configValidator.ValidateRelationshipsInConfig(runtimeConfig, _metadataProviderFactory.Object));
+                configValidator.ValidateRelationshipConfigCorrectness(runtimeConfig));
             Assert.AreEqual(expectedExceptionMessage, ex.Message);
             Assert.AreEqual(HttpStatusCode.ServiceUnavailable, ex.StatusCode);
             Assert.AreEqual(DataApiBuilderException.SubStatusCodes.ConfigValidationError, ex.SubStatusCode);

src/Service.Tests/Unittests/ConfigValidationUnitTests.cs

@@ -635,7 +635,8 @@ private async Task<bool> PerformOnConfigChangeAsync(IApplicationBuilder app)
                 if (runtimeConfig.IsDevelopmentMode())
                 {
                     // Running only in developer mode to ensure fast and smooth startup in production.
-                    runtimeConfigValidator.ValidateRelationshipsInConfig(runtimeConfig, sqlMetadataProviderFactory!);
+                    runtimeConfigValidator.ValidateRelationshipConfigCorrectness(runtimeConfig);
+                    runtimeConfigValidator.ValidateRelationships(runtimeConfig, sqlMetadataProviderFactory!);
                 }
 
                 // OpenAPI document creation is only attempted for REST supporting database types.