Merge in 'release/3.1' changes

SqlClient Azure DevOps · SqlClient Azure DevOps · commit d7ccad2f563d · 2024-07-24T21:02:40.000Z
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ActiveDirectoryAuthenticationProvider.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ActiveDirectoryAuthenticationProvider.cs
@@ -114,7 +114,11 @@ public override async Task<SqlAuthenticationToken> AcquireTokenAsync(SqlAuthenti
             CancellationTokenSource cts = new CancellationTokenSource();
 
             // Use Connection timeout value to cancel token acquire request after certain period of time.
-            cts.CancelAfter(parameters.ConnectionTimeout * 1000); // Convert to milliseconds
+            int timeout = parameters.ConnectionTimeout * 1000;
+            if (timeout > 0) // if ConnectionTimeout is 0 or the millis overflows an int, no need to set CancelAfter
+            {
+                cts.CancelAfter(timeout); // Convert to milliseconds
+            }
 
             string scope = parameters.Resource.EndsWith(s_defaultScopeSuffix) ? parameters.Resource : parameters.Resource + s_defaultScopeSuffix;
             string[] scopes = new string[] { scope };
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs
@@ -60,6 +60,7 @@ public static class DataTestUtility
         public static readonly string EnclaveAzureDatabaseConnString = null;
         public static bool ManagedIdentitySupported = true;
         public static string AADAccessToken = null;
+        public static bool SupportsSystemAssignedManagedIdentity = false;
         public static string AADSystemIdentityAccessToken = null;
         public static string AADUserIdentityAccessToken = null;
         public const string UdtTestDbName = "UdtTestDb";
@@ -70,6 +71,15 @@ public static class DataTestUtility
         private static Dictionary<string, bool> AvailableDatabases;
         private static TraceEventListener TraceListener;
 
+        public static bool TcpConnectionStringDoesNotUseAadAuth
+        {
+            get
+            {
+                SqlConnectionStringBuilder builder = new (TCPConnectionString);
+                return builder.Authentication == SqlAuthenticationMethod.SqlPassword || builder.Authentication == SqlAuthenticationMethod.NotSpecified;
+            }
+        }
+
         static DataTestUtility()
         {
             Config c = Config.Load();
@@ -472,7 +482,7 @@ public static string GetAccessToken()
 
         public static string GetSystemIdentityAccessToken()
         {
-            if (true == ManagedIdentitySupported && null == AADSystemIdentityAccessToken && IsAADPasswordConnStrSetup())
+            if (ManagedIdentitySupported && SupportsSystemAssignedManagedIdentity && null == AADSystemIdentityAccessToken && IsAADPasswordConnStrSetup())
             {
                 AADSystemIdentityAccessToken = AADUtility.GetManagedIdentityToken().GetAwaiter().GetResult();
                 if (AADSystemIdentityAccessToken == null)
@@ -485,7 +495,7 @@ public static string GetSystemIdentityAccessToken()
 
         public static string GetUserIdentityAccessToken()
         {
-            if (true == ManagedIdentitySupported && null == AADUserIdentityAccessToken && IsAADPasswordConnStrSetup())
+            if (ManagedIdentitySupported && null == AADUserIdentityAccessToken && IsAADPasswordConnStrSetup())
             {
                 // Pass User Assigned Managed Identity Client Id here.
                 AADUserIdentityAccessToken = AADUtility.GetManagedIdentityToken(UserManagedIdentityClientId).GetAwaiter().GetResult();
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/AdapterTest/AdapterTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/AdapterTest/AdapterTest.cs
@@ -991,7 +991,14 @@ public void UpdateOffsetTest()
             }
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        public static bool CanRunSchemaTests()
+        {
+            return DataTestUtility.AreConnStringsSetup() &&
+                // Tests switch to master database, which is not guaranteed when using AAD auth
+                DataTestUtility.TcpConnectionStringDoesNotUseAadAuth;
+        }
+
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public void SelectAllTest()
         {
             // Test exceptions
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ConnectivityTests/AADConnectionTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ConnectivityTests/AADConnectionTest.cs
@@ -30,6 +30,7 @@ private static void ConnectAndDisconnect(string connectionString, SqlCredential
         private static bool IsAccessTokenSetup() => DataTestUtility.IsAccessTokenSetup();
         private static bool IsAADConnStringsSetup() => DataTestUtility.IsAADPasswordConnStrSetup();
         private static bool IsManagedIdentitySetup() => DataTestUtility.ManagedIdentitySupported;
+        private static bool SupportsSystemAssignedManagedIdentity() => DataTestUtility.SupportsSystemAssignedManagedIdentity;
 
         [ConditionalFact(nameof(IsAccessTokenSetup), nameof(IsAADConnStringsSetup))]
         public static void AccessTokenTest()
@@ -481,7 +482,7 @@ public static void ActiveDirectoryDefaultMustPass()
         {
             string[] credKeys = { "Authentication", "User ID", "Password", "UID", "PWD" };
             string connStr = DataTestUtility.RemoveKeysInConnStr(DataTestUtility.AADPasswordConnectionString, credKeys) +
-                "Authentication=ActiveDirectoryDefault;";
+                $"Authentication=ActiveDirectoryDefault;User ID={DataTestUtility.UserManagedIdentityClientId};";
 
             // Connection should be established using Managed Identity by default.
             ConnectAndDisconnect(connStr);
@@ -537,7 +538,7 @@ public static void ConnectionSpeed()
 
         #region Managed Identity Authentication tests
 
-        [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup))]
+        [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]
         public static void SystemAssigned_ManagedIdentityTest()
         {
             string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD" };
@@ -555,7 +556,7 @@ public static void UserAssigned_ManagedIdentityTest()
             ConnectAndDisconnect(connStr);
         }
 
-        [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup))]
+        [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]
         public static void AccessToken_SystemManagedIdentityTest()
         {
             string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD" };
@@ -583,7 +584,7 @@ public static void AccessToken_UserManagedIdentityTest()
             }
         }
 
-        [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure))]
+        [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]
         public static void Azure_SystemManagedIdentityTest()
         {
             string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD", "Trusted_Connection", "Integrated Security" };
@@ -613,7 +614,7 @@ public static void Azure_UserManagedIdentityTest()
             }
         }
 
-        [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure))]
+        [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure), nameof(IsAccessTokenSetup), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]
         public static void Azure_AccessToken_SystemManagedIdentityTest()
         {
             string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD", "Trusted_Connection", "Integrated Security" };
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ConnectivityTests/ConnectivityTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ConnectivityTests/ConnectivityTest.cs
@@ -347,7 +347,8 @@ public static void ConnectionStringPersistentInfoTest()
             }
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        // ConnectionOpenDisableRetry relies on error 4060 for automatic retry, which is not returned when using AAD auth
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer), nameof(DataTestUtility.TcpConnectionStringDoesNotUseAadAuth))]
         public static void ConnectionOpenDisableRetry()
         {
             using (SqlConnection sqlConnection = new SqlConnection((new SqlConnectionStringBuilder(DataTestUtility.TCPConnectionString) { InitialCatalog = "DoesNotExist0982532435423", Pooling = false }).ConnectionString))
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/DataBaseSchemaTest/ConnectionSchemaTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/DataBaseSchemaTest/ConnectionSchemaTest.cs
@@ -10,86 +10,92 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
     public static class ConnectionSchemaTest
     {
+        public static bool CanRunSchemaTests()
+        {
+            return DataTestUtility.AreConnStringsSetup() &&
+                // Tests switch to master database, which is not guaranteed when using AAD auth
+                DataTestUtility.TcpConnectionStringDoesNotUseAadAuth;
+        }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetTablesFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.Tables, new string[] { "TABLE_CATALOG", "TABLE_SCHEMA", "TABLE_NAME", "TABLE_TYPE" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetProceduresFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.Procedures, new string[] { "ROUTINE_SCHEMA", "ROUTINE_NAME", "ROUTINE_TYPE" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetProcedureParametersFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.ProcedureParameters, new string[] { "PARAMETER_MODE", "PARAMETER_NAME" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetDatabasesFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.Databases, new string[] { "database_name", "dbid", "create_date" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetForeignKeysFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.ForeignKeys, new string[] { "CONSTRAINT_TYPE", "IS_DEFERRABLE", "INITIALLY_DEFERRED" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetIndexesFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.Indexes, new string[] { "index_name", "constraint_name" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetIndexColumnsFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.IndexColumns, new string[] { "index_name", "KeyType", "column_name" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetColumnsFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.Columns, new string[] { "IS_NULLABLE", "COLUMN_DEFAULT" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetAllColumnsFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.AllColumns, new string[] { "IS_NULLABLE", "COLUMN_DEFAULT", "IS_FILESTREAM", "IS_SPARSE", "IS_COLUMN_SET" });
         }
-        
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetColumnSetColumnsFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.ColumnSetColumns, new string[] { "IS_NULLABLE", "COLUMN_DEFAULT", "IS_FILESTREAM", "IS_SPARSE", "IS_COLUMN_SET" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetUsersFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.Users, new string[] { "uid", "user_name" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetViewsFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.Views, new string[] { "TABLE_NAME", "CHECK_OPTION", "IS_UPDATABLE" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetViewColumnsFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.ViewColumns, new string[] { "VIEW_CATALOG", "VIEW_SCHEMA", "VIEW_NAME" });
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(nameof(CanRunSchemaTests))]
         public static void GetUserDefinedTypesFromSchema()
         {
             VerifySchemaTable(SqlClientMetaDataCollectionNames.UserDefinedTypes, new string[] { "assembly_name", "version_revision", "culture_info" });
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ExceptionTest/ExceptionTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ExceptionTest/ExceptionTest.cs
@@ -201,7 +201,7 @@ public static void ExceptionTests()
         }
 
         // Synapse: 110003;Invalid user or password
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]
         public static void VariousExceptionTests()
         {
             SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(DataTestUtility.TCPConnectionString);
@@ -219,7 +219,7 @@ public static void VariousExceptionTests()
             }
 
             // Test 1 - B
-            badBuilder = new SqlConnectionStringBuilder(builder.ConnectionString) { Password = string.Empty, IntegratedSecurity = false };
+            badBuilder = new SqlConnectionStringBuilder(builder.ConnectionString) { Password = string.Empty, IntegratedSecurity = false, Authentication = SqlAuthenticationMethod.NotSpecified };
             using (var sqlConnection = new SqlConnection(badBuilder.ConnectionString))
             {
                 string errorMessage = string.Format(CultureInfo.InvariantCulture, logonFailedErrorMessage, badBuilder.UserID);
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConfigurationManagerReliabilityTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConfigurationManagerReliabilityTest.cs
@@ -23,7 +23,8 @@ public class SqlConfigurationManagerReliabilityTest
         { InitialCatalog = SqlConnectionReliabilityTest.InvalidInitialCatalog, ConnectTimeout = 1 }.ConnectionString;
 
         #region Internal Functions
-        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        // Test relies on error 4060 for automatic retry, which is not returned when using AAD auth
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.TcpConnectionStringDoesNotUseAadAuth))]
         [InlineData(RetryLogicConfigHelper.RetryMethodName_Fix, RetryLogicConfigHelper.RetryMethodName_Inc)]
         [InlineData(RetryLogicConfigHelper.RetryMethodName_Inc, RetryLogicConfigHelper.RetryMethodName_Exp)]
         [InlineData(RetryLogicConfigHelper.RetryMethodName_Exp, RetryLogicConfigHelper.RetryMethodName_Fix)]
@@ -160,7 +161,8 @@ public void InvalidRetryMethodName(string methodName)
             s_commandCRLTest.NoneRetriableExecuteFail(TcpCnnString, cmdProvider);
         }
 
-        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        // Test relies on error 4060 for automatic retry, which is not returned when using AAD auth
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.TcpConnectionStringDoesNotUseAadAuth))]
         [InlineData("InvalidRetrylogicTypeName")]
         [InlineData("")]
         [InlineData(null)]
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConnectionReliabilityTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConnectionReliabilityTest.cs
@@ -16,7 +16,8 @@ public class SqlConnectionReliabilityTest
         private readonly string _cancelErrMsgPattern = RetryLogicTestHelper.s_CancelErrMsgPattern;
 
         #region Sync
-        [Theory]
+        // Test relies on error 4060 for automatic retry, which is not reliable when using Azure or AAD auth
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]
         [MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]
         public void ConnectionRetryOpenInvalidCatalogFailed(string cnnString, SqlRetryLogicBaseProvider provider)
         {
@@ -33,7 +34,8 @@ public void ConnectionRetryOpenInvalidCatalogFailed(string cnnString, SqlRetryLo
             }
         }
 
-        [Theory]
+        // Test relies on error 4060 for automatic retry, which is not reliable when using Azure or AAD auth
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]
         [MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]
         public void ConnectionCancelRetryOpenInvalidCatalog(string cnnString, SqlRetryLogicBaseProvider provider)
         {
@@ -98,7 +100,8 @@ public void CreateDatabaseWhileTryingToConnect(string cnnString, SqlRetryLogicBa
             Assert.True(currentRetries > 0);
         }
 
-        [Theory]
+        // Test relies on AggregateException but SqlException is thrown for Azure auth (Address in #31453)
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsNotAzureServer))]
         [MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]
         public void ConcurrentExecution(string cnnString, SqlRetryLogicBaseProvider provider)
         {
@@ -154,7 +157,8 @@ public void DefaultOpenWithoutRetry(string connectionString, SqlRetryLogicBasePr
         #endregion
 
         #region Async
-        [Theory]
+        // Test relies on error 4060 for automatic retry, which is not reliable when using Azure or AAD auth
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]
         [MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 5 }, MemberType = typeof(RetryLogicTestHelper))]
         public async void ConnectionRetryOpenAsyncInvalidCatalogFailed(string cnnString, SqlRetryLogicBaseProvider provider)
         {
@@ -171,7 +175,8 @@ public async void ConnectionRetryOpenAsyncInvalidCatalogFailed(string cnnString,
             }
         }
 
-        [Theory]
+        // Test relies on error 4060 for automatic retry, which is not returned when using AAD auth
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.TcpConnectionStringDoesNotUseAadAuth))]
         [MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]
         public async void ConnectionCancelRetryOpenAsyncInvalidCatalog(string cnnString, SqlRetryLogicBaseProvider provider)
         {

Original file line number	Diff line number	Diff line change
`@@ -991,7 +991,14 @@ public void UpdateOffsetTest()`
`991`	`991`	`}`
`992`	`992`	`}`
`993`	`993`
`994`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`994`	`+ public static bool CanRunSchemaTests()`
	`995`	`+ {`
	`996`	`+ return DataTestUtility.AreConnStringsSetup() &&`
	`997`	`+ // Tests switch to master database, which is not guaranteed when using AAD auth`
	`998`	`+ DataTestUtility.TcpConnectionStringDoesNotUseAadAuth;`
	`999`	`+ }`
	`1000`	`+`
	`1001`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`995`	`1002`	`public void SelectAllTest()`
`996`	`1003`	`{`
`997`	`1004`	`// Test exceptions`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ private static void ConnectAndDisconnect(string connectionString, SqlCredential`
`30`	`30`	`private static bool IsAccessTokenSetup() => DataTestUtility.IsAccessTokenSetup();`
`31`	`31`	`private static bool IsAADConnStringsSetup() => DataTestUtility.IsAADPasswordConnStrSetup();`
`32`	`32`	`private static bool IsManagedIdentitySetup() => DataTestUtility.ManagedIdentitySupported;`
	`33`	`+ private static bool SupportsSystemAssignedManagedIdentity() => DataTestUtility.SupportsSystemAssignedManagedIdentity;`
`33`	`34`
`34`	`35`	`[ConditionalFact(nameof(IsAccessTokenSetup), nameof(IsAADConnStringsSetup))]`
`35`	`36`	`public static void AccessTokenTest()`
`@@ -481,7 +482,7 @@ public static void ActiveDirectoryDefaultMustPass()`
`481`	`482`	`{`
`482`	`483`	`string[] credKeys = { "Authentication", "User ID", "Password", "UID", "PWD" };`
`483`	`484`	`string connStr = DataTestUtility.RemoveKeysInConnStr(DataTestUtility.AADPasswordConnectionString, credKeys) +`
`484`		`- "Authentication=ActiveDirectoryDefault;";`
	`485`	`+ $"Authentication=ActiveDirectoryDefault;User ID={DataTestUtility.UserManagedIdentityClientId};";`
`485`	`486`
`486`	`487`	`// Connection should be established using Managed Identity by default.`
`487`	`488`	`ConnectAndDisconnect(connStr);`
`@@ -537,7 +538,7 @@ public static void ConnectionSpeed()`
`537`	`538`
`538`	`539`	`#region Managed Identity Authentication tests`
`539`	`540`
`540`		`- [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup))]`
	`541`	`+ [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]`
`541`	`542`	`public static void SystemAssigned_ManagedIdentityTest()`
`542`	`543`	`{`
`543`	`544`	`string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD" };`
`@@ -555,7 +556,7 @@ public static void UserAssigned_ManagedIdentityTest()`
`555`	`556`	`ConnectAndDisconnect(connStr);`
`556`	`557`	`}`
`557`	`558`
`558`		`- [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup))]`
	`559`	`+ [ConditionalFact(nameof(IsAADConnStringsSetup), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]`
`559`	`560`	`public static void AccessToken_SystemManagedIdentityTest()`
`560`	`561`	`{`
`561`	`562`	`string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD" };`
`@@ -583,7 +584,7 @@ public static void AccessToken_UserManagedIdentityTest()`
`583`	`584`	`}`
`584`	`585`	`}`
`585`	`586`
`586`		`- [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure))]`
	`587`	`+ [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]`
`587`	`588`	`public static void Azure_SystemManagedIdentityTest()`
`588`	`589`	`{`
`589`	`590`	`string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD", "Trusted_Connection", "Integrated Security" };`
`@@ -613,7 +614,7 @@ public static void Azure_UserManagedIdentityTest()`
`613`	`614`	`}`
`614`	`615`	`}`
`615`	`616`
`616`		`- [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure))]`
	`617`	`+ [ConditionalFact(nameof(AreConnStringsSetup), nameof(IsAzure), nameof(IsAccessTokenSetup), nameof(IsManagedIdentitySetup), nameof(SupportsSystemAssignedManagedIdentity))]`
`617`	`618`	`public static void Azure_AccessToken_SystemManagedIdentityTest()`
`618`	`619`	`{`
`619`	`620`	`string[] removeKeys = { "Authentication", "User ID", "Password", "UID", "PWD", "Trusted_Connection", "Integrated Security" };`
Original file line number	Diff line number	Diff line change
`@@ -347,7 +347,8 @@ public static void ConnectionStringPersistentInfoTest()`
`347`	`347`	`}`
`348`	`348`	`}`
`349`	`349`
`350`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`350`	`+ // ConnectionOpenDisableRetry relies on error 4060 for automatic retry, which is not returned when using AAD auth`
	`351`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer), nameof(DataTestUtility.TcpConnectionStringDoesNotUseAadAuth))]`
`351`	`352`	`public static void ConnectionOpenDisableRetry()`
`352`	`353`	`{`
`353`	`354`	`using (SqlConnection sqlConnection = new SqlConnection((new SqlConnectionStringBuilder(DataTestUtility.TCPConnectionString) { InitialCatalog = "DoesNotExist0982532435423", Pooling = false }).ConnectionString))`
Original file line number	Diff line number	Diff line change
`@@ -10,86 +10,92 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests`
`10`	`10`	`{`
`11`	`11`	`public static class ConnectionSchemaTest`
`12`	`12`	`{`
	`13`	`+ public static bool CanRunSchemaTests()`
	`14`	`+ {`
	`15`	`+ return DataTestUtility.AreConnStringsSetup() &&`
	`16`	`+ // Tests switch to master database, which is not guaranteed when using AAD auth`
	`17`	`+ DataTestUtility.TcpConnectionStringDoesNotUseAadAuth;`
	`18`	`+ }`
`13`	`19`
`14`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`20`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`15`	`21`	`public static void GetTablesFromSchema()`
`16`	`22`	`{`
`17`	`23`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.Tables, new string[] { "TABLE_CATALOG", "TABLE_SCHEMA", "TABLE_NAME", "TABLE_TYPE" });`
`18`	`24`	`}`
`19`	`25`
`20`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`26`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`21`	`27`	`public static void GetProceduresFromSchema()`
`22`	`28`	`{`
`23`	`29`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.Procedures, new string[] { "ROUTINE_SCHEMA", "ROUTINE_NAME", "ROUTINE_TYPE" });`
`24`	`30`	`}`
`25`	`31`
`26`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`32`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`27`	`33`	`public static void GetProcedureParametersFromSchema()`
`28`	`34`	`{`
`29`	`35`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.ProcedureParameters, new string[] { "PARAMETER_MODE", "PARAMETER_NAME" });`
`30`	`36`	`}`
`31`	`37`
`32`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`38`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`33`	`39`	`public static void GetDatabasesFromSchema()`
`34`	`40`	`{`
`35`	`41`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.Databases, new string[] { "database_name", "dbid", "create_date" });`
`36`	`42`	`}`
`37`	`43`
`38`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`44`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`39`	`45`	`public static void GetForeignKeysFromSchema()`
`40`	`46`	`{`
`41`	`47`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.ForeignKeys, new string[] { "CONSTRAINT_TYPE", "IS_DEFERRABLE", "INITIALLY_DEFERRED" });`
`42`	`48`	`}`
`43`	`49`
`44`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`50`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`45`	`51`	`public static void GetIndexesFromSchema()`
`46`	`52`	`{`
`47`	`53`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.Indexes, new string[] { "index_name", "constraint_name" });`
`48`	`54`	`}`
`49`	`55`
`50`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`56`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`51`	`57`	`public static void GetIndexColumnsFromSchema()`
`52`	`58`	`{`
`53`	`59`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.IndexColumns, new string[] { "index_name", "KeyType", "column_name" });`
`54`	`60`	`}`
`55`	`61`
`56`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`62`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`57`	`63`	`public static void GetColumnsFromSchema()`
`58`	`64`	`{`
`59`	`65`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.Columns, new string[] { "IS_NULLABLE", "COLUMN_DEFAULT" });`
`60`	`66`	`}`
`61`	`67`
`62`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`68`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`63`	`69`	`public static void GetAllColumnsFromSchema()`
`64`	`70`	`{`
`65`	`71`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.AllColumns, new string[] { "IS_NULLABLE", "COLUMN_DEFAULT", "IS_FILESTREAM", "IS_SPARSE", "IS_COLUMN_SET" });`
`66`	`72`	`}`
`67`		`-`
`68`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`73`	`+`
	`74`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`69`	`75`	`public static void GetColumnSetColumnsFromSchema()`
`70`	`76`	`{`
`71`	`77`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.ColumnSetColumns, new string[] { "IS_NULLABLE", "COLUMN_DEFAULT", "IS_FILESTREAM", "IS_SPARSE", "IS_COLUMN_SET" });`
`72`	`78`	`}`
`73`	`79`
`74`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`80`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`75`	`81`	`public static void GetUsersFromSchema()`
`76`	`82`	`{`
`77`	`83`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.Users, new string[] { "uid", "user_name" });`
`78`	`84`	`}`
`79`	`85`
`80`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`86`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`81`	`87`	`public static void GetViewsFromSchema()`
`82`	`88`	`{`
`83`	`89`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.Views, new string[] { "TABLE_NAME", "CHECK_OPTION", "IS_UPDATABLE" });`
`84`	`90`	`}`
`85`	`91`
`86`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`92`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`87`	`93`	`public static void GetViewColumnsFromSchema()`
`88`	`94`	`{`
`89`	`95`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.ViewColumns, new string[] { "VIEW_CATALOG", "VIEW_SCHEMA", "VIEW_NAME" });`
`90`	`96`	`}`
`91`	`97`
`92`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`98`	`+ [ConditionalFact(nameof(CanRunSchemaTests))]`
`93`	`99`	`public static void GetUserDefinedTypesFromSchema()`
`94`	`100`	`{`
`95`	`101`	`VerifySchemaTable(SqlClientMetaDataCollectionNames.UserDefinedTypes, new string[] { "assembly_name", "version_revision", "culture_info" });`
Original file line number	Diff line number	Diff line change
`@@ -201,7 +201,7 @@ public static void ExceptionTests()`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`// Synapse: 110003;Invalid user or password`
`204`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]`
	`204`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]`
`205`	`205`	`public static void VariousExceptionTests()`
`206`	`206`	`{`
`207`	`207`	`SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(DataTestUtility.TCPConnectionString);`
`@@ -219,7 +219,7 @@ public static void VariousExceptionTests()`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`// Test 1 - B`
`222`		`- badBuilder = new SqlConnectionStringBuilder(builder.ConnectionString) { Password = string.Empty, IntegratedSecurity = false };`
	`222`	`+ badBuilder = new SqlConnectionStringBuilder(builder.ConnectionString) { Password = string.Empty, IntegratedSecurity = false, Authentication = SqlAuthenticationMethod.NotSpecified };`
`223`	`223`	`using (var sqlConnection = new SqlConnection(badBuilder.ConnectionString))`
`224`	`224`	`{`
`225`	`225`	`string errorMessage = string.Format(CultureInfo.InvariantCulture, logonFailedErrorMessage, badBuilder.UserID);`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,8 @@ public class SqlConnectionReliabilityTest`
`16`	`16`	`private readonly string _cancelErrMsgPattern = RetryLogicTestHelper.s_CancelErrMsgPattern;`
`17`	`17`
`18`	`18`	`#region Sync`
`19`		`- [Theory]`
	`19`	`+ // Test relies on error 4060 for automatic retry, which is not reliable when using Azure or AAD auth`
	`20`	`+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]`
`20`	`21`	`[MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]`
`21`	`22`	`public void ConnectionRetryOpenInvalidCatalogFailed(string cnnString, SqlRetryLogicBaseProvider provider)`
`22`	`23`	`{`
`@@ -33,7 +34,8 @@ public void ConnectionRetryOpenInvalidCatalogFailed(string cnnString, SqlRetryLo`
`33`	`34`	`}`
`34`	`35`	`}`
`35`	`36`
`36`		`- [Theory]`
	`37`	`+ // Test relies on error 4060 for automatic retry, which is not reliable when using Azure or AAD auth`
	`38`	`+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]`
`37`	`39`	`[MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]`
`38`	`40`	`public void ConnectionCancelRetryOpenInvalidCatalog(string cnnString, SqlRetryLogicBaseProvider provider)`
`39`	`41`	`{`
`@@ -98,7 +100,8 @@ public void CreateDatabaseWhileTryingToConnect(string cnnString, SqlRetryLogicBa`
`98`	`100`	`Assert.True(currentRetries > 0);`
`99`	`101`	`}`
`100`	`102`
`101`		`- [Theory]`
	`103`	`+ // Test relies on AggregateException but SqlException is thrown for Azure auth (Address in #31453)`
	`104`	`+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsNotAzureServer))]`
`102`	`105`	`[MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]`
`103`	`106`	`public void ConcurrentExecution(string cnnString, SqlRetryLogicBaseProvider provider)`
`104`	`107`	`{`
`@@ -154,7 +157,8 @@ public void DefaultOpenWithoutRetry(string connectionString, SqlRetryLogicBasePr`
`154`	`157`	`#endregion`
`155`	`158`
`156`	`159`	`#region Async`
`157`		`- [Theory]`
	`160`	`+ // Test relies on error 4060 for automatic retry, which is not reliable when using Azure or AAD auth`
	`161`	`+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureServer))]`
`158`	`162`	`[MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 5 }, MemberType = typeof(RetryLogicTestHelper))]`
`159`	`163`	`public async void ConnectionRetryOpenAsyncInvalidCatalogFailed(string cnnString, SqlRetryLogicBaseProvider provider)`
`160`	`164`	`{`
`@@ -171,7 +175,8 @@ public async void ConnectionRetryOpenAsyncInvalidCatalogFailed(string cnnString,`
`171`	`175`	`}`
`172`	`176`	`}`
`173`	`177`
`174`		`- [Theory]`
	`178`	`+ // Test relies on error 4060 for automatic retry, which is not returned when using AAD auth`
	`179`	`+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.TcpConnectionStringDoesNotUseAadAuth))]`
`175`	`180`	`[MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCatalog), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]`
`176`	`181`	`public async void ConnectionCancelRetryOpenAsyncInvalidCatalog(string cnnString, SqlRetryLogicBaseProvider provider)`
`177`	`182`	`{`