[3.1] Changes to run tests on 1es pipelines (#1552)

Johnny Pham · web-flow · commit c944713bea65 · 2022-03-25T14:50:41.000-07:00
* 1es 3.1

* Update TcpDefaultForAzureTest.cs

* Update CspProviderExt.cs
diff --git a/BUILDGUIDE.md b/BUILDGUIDE.md
@@ -122,7 +122,7 @@ Manual Tests require the below setup to run:
   |SupportsFileStream | (Optional) Whether or not FileStream is enabled on SQL Server| `true` OR `false`|
   |UseManagedSNIOnWindows | (Optional) Enables testing with Managed SNI on Windows| `true` OR `false`|
   |IsAzureSynpase | (Optional) When set to 'true', test suite runs compatible tests for Azure Synapse/Parallel Data Warehouse. | `true` OR `false`|
-
+  |MakecertPath | The full path to makecert.exe. This is not required if the path is present in the PATH environment variable. | `D:\\escaped\\absolute\\path\\to\\makecert.exe` |
 ### Commands to run Manual Tests:
 
   - Windows (`netfx x86`):
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/AlwaysEncrypted/CspProviderExt.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/AlwaysEncrypted/CspProviderExt.cs
@@ -23,7 +23,7 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests.AlwaysEncrypted
     [PlatformSpecific(TestPlatforms.Windows)]
     public class CspProviderExt
     {
-        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringSetupForAE))]
         [ClassData(typeof(AEConnectionStringProvider))]
         public void TestKeysFromCertificatesCreatedWithMultipleCryptoProviders(string connectionString)
         {
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/AlwaysEncrypted/TestFixtures/Setup/CertificateUtilityWin.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/AlwaysEncrypted/TestFixtures/Setup/CertificateUtilityWin.cs
@@ -31,7 +31,8 @@ internal static void CreateCertificate(string certificateName, string certificat
             Assert.False(string.IsNullOrWhiteSpace(certificateName), "FAILED: certificateName should not be null or empty.");
             Assert.False(string.IsNullOrWhiteSpace(certificateLocation), "FAILED: certificateLocation should not be null or empty.");
 
-            ProcessStartInfo processStartInfo = new ProcessStartInfo(@"makecert");
+            string makecertPath = string.IsNullOrEmpty(DataTestUtility.MakecertPath) ? "makecert" : DataTestUtility.MakecertPath;
+            ProcessStartInfo processStartInfo = new ProcessStartInfo(makecertPath);
             processStartInfo.Arguments = string.Format(@"-n ""CN={0}"" -pe -sr {1} -r -eku 1.3.6.1.5.5.8.2.2,1.3.6.1.4.1.311.10.3.11 -ss my -sky exchange -sp ""{2}"" -sy {3} -len 2048 -a sha256",
                                         certificateName,
                                         certificateLocation,
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs
@@ -48,6 +48,7 @@ public static class DataTestUtility
         public static readonly bool UseManagedSNIOnWindows = false;
         public static readonly bool IsAzureSynapse = false;
         public static Uri AKVBaseUri = null;
+        public static readonly string MakecertPath = null;
 
         public static readonly string DNSCachingConnString = null;
         public static readonly string DNSCachingServerCR = null;  // this is for the control ring
@@ -95,6 +96,7 @@ static DataTestUtility()
             IsDNSCachingSupportedTR = c.IsDNSCachingSupportedTR;
             EnclaveAzureDatabaseConnString = c.EnclaveAzureDatabaseConnString;
             UserManagedIdentityClientId = c.UserManagedIdentityClientId;
+            MakecertPath = c.MakecertPath;
 
             System.Net.ServicePointManager.SecurityProtocol |= System.Net.SecurityProtocolType.Tls12;
 
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/AdapterTest/AdapterTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/AdapterTest/AdapterTest.cs
@@ -54,10 +54,10 @@ public class AdapterTest
         public AdapterTest()
         {
             // create random name for temp tables
-            _randomGuid = Guid.NewGuid().ToString();
-            _tempTable = Environment.MachineName + "_" + _randomGuid;
+            _tempTable = DataTestUtility.GetUniqueName("AdapterTest");
             _tempTable = _tempTable.Replace('-', '_');
 
+            _randomGuid = Guid.NewGuid().ToString();
             _tempKey = "employee_id_key_" + Environment.TickCount.ToString() + _randomGuid;
             _tempKey = _tempKey.Replace('-', '_');
 
@@ -179,15 +179,15 @@ public void PrepUnprepTest()
         public void SqlVariantTest()
         {
             string tableName = DataTestUtility.GenerateObjectName();
-            try
+            // good test for null values and unicode strings
+            using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
+            using (SqlCommand cmd = new SqlCommand(null, conn))
+            using (SqlDataAdapter sqlAdapter = new SqlDataAdapter())
             {
-                ExecuteNonQueryCommand("CREATE TABLE " + tableName + " (c0_bigint bigint, c1_variant sql_variant)");
-
-                // good test for null values and unicode strings
-                using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
-                using (SqlCommand cmd = new SqlCommand(null, conn))
-                using (SqlDataAdapter sqlAdapter = new SqlDataAdapter())
+                try
                 {
+                    ExecuteNonQueryCommand("CREATE TABLE " + tableName + " (c0_bigint bigint, c1_variant sql_variant)");
+
                     cmd.Connection.Open();
 
                     // the ORDER BY clause tests that we correctly ignore the ORDER token
@@ -263,10 +263,10 @@ public void SqlVariantTest()
                         }
                     }
                 }
-            }
-            finally
-            {
-                ExecuteNonQueryCommand("DROP TABLE " + tableName);
+                finally
+                {
+                    DataTestUtility.DropTable(conn, tableName);
+                }
             }
         }
 
@@ -659,7 +659,7 @@ public void UpdateTest()
                 }
                 finally
                 {
-                    ExecuteNonQueryCommand("DROP TABLE " + _tempTable);
+                    DataTestUtility.DropTable(conn, _tempTable);
                 }
             }
         }
@@ -757,7 +757,7 @@ public void BulkUpdateTest()
                 }
                 finally
                 {
-                    ExecuteNonQueryCommand("DROP TABLE " + _tempTable);
+                    DataTestUtility.DropTable(conn, _tempTable);
                 }
             }
         }
@@ -768,33 +768,35 @@ public void BulkUpdateTest()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public void UpdateRefreshTest()
         {
+            string identTableName = DataTestUtility.GetUniqueName("ID_");
             string createIdentTable =
-                "CREATE TABLE ID_" + _tempTable + "(id int IDENTITY," +
+                $"CREATE TABLE {identTableName} (id int IDENTITY," +
                 "LastName nvarchar(50) NULL," +
                 "Firstname nvarchar(50) NULL)";
 
+            string spName = DataTestUtility.GetUniqueName("sp_insert", withBracket: false);
             string spCreateInsert =
-                "CREATE PROCEDURE sp_insert" + _tempTable +
+                $"CREATE PROCEDURE {spName}" +
                 "(@FirstName nvarchar(50), @LastName nvarchar(50), @id int OUTPUT) " +
                 "AS INSERT INTO " + _tempTable + " (FirstName, LastName) " +
                 "VALUES (@FirstName, @LastName); " +
                 "SELECT @id=@@IDENTITY";
 
-            string spDropInsert = "DROP PROCEDURE sp_insert" + _tempTable;
+            string spDropInsert = $"DROP PROCEDURE {spName}";
             bool dropSP = false;
 
             using (SqlDataAdapter adapter = new SqlDataAdapter())
             using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
             using (SqlCommand cmd = new SqlCommand(null, conn))
-            using (SqlCommand temp = new SqlCommand("SELECT id, LastName, FirstName into " + _tempTable + " from ID_" + _tempTable, conn))
+            using (SqlCommand temp = new SqlCommand("SELECT id, LastName, FirstName into " + _tempTable + $" from {identTableName}", conn))
             using (SqlCommand tableClean = new SqlCommand("", conn))
             {
                 ExecuteNonQueryCommand(createIdentTable);
                 try
                 {
                     adapter.InsertCommand = new SqlCommand()
                     {
-                        CommandText = "sp_insert" + _tempTable,
+                        CommandText = spName,
                         CommandType = CommandType.StoredProcedure
                     };
                     adapter.InsertCommand.Parameters.Add(new SqlParameter("@FirstName", SqlDbType.NVarChar, 50, "FirstName"));
@@ -851,9 +853,9 @@ public void UpdateRefreshTest()
                 {
                     if (dropSP)
                     {
-                        ExecuteNonQueryCommand(spDropInsert);
-                        ExecuteNonQueryCommand("DROP TABLE " + _tempTable);
-                        ExecuteNonQueryCommand("DROP TABLE ID_" + _tempTable);
+                        DataTestUtility.DropStoredProcedure(conn, spName);
+                        DataTestUtility.DropTable(conn, _tempTable);
+                        DataTestUtility.DropTable(conn, identTableName);
                     }
                 }
             }
@@ -873,18 +875,18 @@ public void UpdateNullTest()
                 "VALUES (@val_cvarbin, @val_cimage)";
             bool dropSP = false;
 
-            try
-            {
-                ExecuteNonQueryCommand(createTable);
-                ExecuteNonQueryCommand(createSP);
-                dropSP = true;
 
-                using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
-                using (SqlCommand cmdInsert = new SqlCommand(procName, conn))
-                using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))
-                using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))
-                using (SqlDataAdapter adapter = new SqlDataAdapter())
+            using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
+            using (SqlCommand cmdInsert = new SqlCommand(procName, conn))
+            using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))
+            using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))
+            using (SqlDataAdapter adapter = new SqlDataAdapter())
+            {
+                try
                 {
+                    ExecuteNonQueryCommand(createTable);
+                    ExecuteNonQueryCommand(createSP);
+                    dropSP = true;
                     conn.Open();
 
                     cmdInsert.CommandType = CommandType.StoredProcedure;
@@ -905,13 +907,13 @@ public void UpdateNullTest()
                     DataTestUtility.AssertEqualsWithDescription(DBNull.Value, ds.Tables[0].Rows[0][0], "Unexpected value.");
                     DataTestUtility.AssertEqualsWithDescription(DBNull.Value, ds.Tables[0].Rows[0][1], "Unexpected value.");
                 }
-            }
-            finally
-            {
-                if (dropSP)
+                finally
                 {
-                    ExecuteNonQueryCommand("DROP PROCEDURE " + procName);
-                    ExecuteNonQueryCommand("DROP TABLE " + tableName);
+                    if (dropSP)
+                    {
+                        DataTestUtility.DropStoredProcedure(conn, procName);
+                        DataTestUtility.DropTable(conn, tableName);
+                    }
                 }
             }
         }
@@ -930,18 +932,18 @@ public void UpdateOffsetTest()
                 "VALUES (@val_cvarbin, @val_cimage)";
             bool dropSP = false;
 
-            try
-            {
-                ExecuteNonQueryCommand(createTable);
-                ExecuteNonQueryCommand(createSP);
-                dropSP = true;
 
-                using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
-                using (SqlCommand cmdInsert = new SqlCommand(procName, conn))
-                using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))
-                using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))
-                using (SqlDataAdapter adapter = new SqlDataAdapter())
+            using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
+            using (SqlCommand cmdInsert = new SqlCommand(procName, conn))
+            using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))
+            using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))
+            using (SqlDataAdapter adapter = new SqlDataAdapter())
+            {
+                try
                 {
+                    ExecuteNonQueryCommand(createTable);
+                    ExecuteNonQueryCommand(createSP);
+                    dropSP = true;
                     conn.Open();
 
                     cmdInsert.CommandType = CommandType.StoredProcedure;
@@ -978,13 +980,13 @@ public void UpdateOffsetTest()
                     val = (byte[])(ds.Tables[0].Rows[0][1]);
                     Assert.True(ByteArraysEqual(expectedBytes2, val), "FAILED: Test 2: Unequal byte arrays.");
                 }
-            }
-            finally
-            {
-                if (dropSP)
+                finally
                 {
-                    ExecuteNonQueryCommand("DROP PROCEDURE " + procName);
-                    ExecuteNonQueryCommand("DROP TABLE " + tableName);
+                    if (dropSP)
+                    {
+                        DataTestUtility.DropStoredProcedure(conn, procName);
+                        DataTestUtility.DropTable(conn, tableName);
+                    }
                 }
             }
         }
@@ -1069,7 +1071,7 @@ public void AutoGenUpdateTest()
                 }
                 finally
                 {
-                    ExecuteNonQueryCommand("DROP TABLE " + _tempTable);
+                    DataTestUtility.DropTable(conn, _tempTable);
                 }
             }
         }
@@ -1078,16 +1080,17 @@ public void AutoGenUpdateTest()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public void AutoGenErrorTest()
         {
+            string identTableName = DataTestUtility.GetUniqueName("ID_");
             string createIdentTable =
-                "CREATE TABLE ID_" + _tempTable + "(id int IDENTITY," +
+                $"CREATE TABLE {identTableName} (id int IDENTITY," +
                 "LastName nvarchar(50) NULL," +
                 "Firstname nvarchar(50) NULL)";
 
-            try
+            using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
+            using (SqlCommand cmd = new SqlCommand($"SELECT * into {_tempTable} from {identTableName}", conn))
+            using (SqlDataAdapter adapter = new SqlDataAdapter())
             {
-                using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))
-                using (SqlCommand cmd = new SqlCommand("SELECT * into " + _tempTable + " from ID_" + _tempTable, conn))
-                using (SqlDataAdapter adapter = new SqlDataAdapter())
+                try
                 {
                     ExecuteNonQueryCommand(createIdentTable);
 
@@ -1110,11 +1113,11 @@ public void AutoGenErrorTest()
                     SqlCommandBuilder builder = new SqlCommandBuilder(adapter);
                     adapter.Update(ds, _tempTable);
                 }
-            }
-            finally
-            {
-                ExecuteNonQueryCommand("DROP TABLE " + _tempTable);
-                ExecuteNonQueryCommand("DROP TABLE ID_" + _tempTable);
+                finally
+                {
+                    DataTestUtility.DropTable(conn, _tempTable);
+                    DataTestUtility.DropTable(conn, identTableName);
+                }
             }
         }
 
@@ -1206,7 +1209,7 @@ public void AutoGenBulkUpdateTest()
                 }
                 finally
                 {
-                    ExecuteNonQueryCommand("DROP TABLE " + _tempTable);
+                    DataTestUtility.DropTable(conn, _tempTable);
                 }
             }
         }
@@ -1319,6 +1322,48 @@ public void TestReadOnlyColumnMetadata()
             }
         }
 
+        [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
+        [InlineData(nameof(SqlCommandBuilder.GetInsertCommand), null)]
+        [InlineData(nameof(SqlCommandBuilder.GetInsertCommand), true)]
+        [InlineData(nameof(SqlCommandBuilder.GetInsertCommand), false)]
+        [InlineData(nameof(SqlCommandBuilder.GetUpdateCommand), null)]
+        [InlineData(nameof(SqlCommandBuilder.GetUpdateCommand), true)]
+        [InlineData(nameof(SqlCommandBuilder.GetUpdateCommand), false)]
+        [InlineData(nameof(SqlCommandBuilder.GetDeleteCommand), null)]
+        [InlineData(nameof(SqlCommandBuilder.GetDeleteCommand), false)]
+        [InlineData(nameof(SqlCommandBuilder.GetDeleteCommand), true)]
+        public void VerifyGetCommand(string methodName, bool? useColumnsForParameterNames)
+        {
+            using (SqlConnection connection = new SqlConnection(DataTestUtility.TCPConnectionString))
+            {
+                connection.Open();
+                using (SqlDataAdapter dataAdapter = new SqlDataAdapter("SELECT * FROM dbo.Customers", connection))
+                {
+                    using (SqlCommandBuilder commandBuilder = new SqlCommandBuilder(dataAdapter))
+                    {
+                        object[] parameters = null;
+                        Type[] parameterTypes = null;
+                        if (useColumnsForParameterNames != null)
+                        {
+                            parameters = new object[] { useColumnsForParameterNames };
+                            parameterTypes = new Type[] { typeof(bool) };
+                        }
+                        else
+                        {
+                            parameters = new object[] { };
+                            parameterTypes = new Type[] { };
+                        }
+
+                        MethodInfo method = commandBuilder.GetType().GetMethod(methodName, parameterTypes);
+                        using (SqlCommand cmd = (SqlCommand)method.Invoke(commandBuilder, parameters))
+                        {
+                            Assert.NotNull(cmd);
+                        }
+                    }
+                }
+            }
+        }
+
         #region Utility_Methods
         private void CheckParameters(SqlCommand cmd, string expectedResults)
         {
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ConnectivityTests/TcpDefaultForAzureTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ConnectivityTests/TcpDefaultForAzureTest.cs
@@ -41,7 +41,11 @@ static TcpDefaultForAzureTest()
         public static void NonAzureNoProtocolConnectionTest()
         {
             builder.DataSource = InvalidHostname;
+#if NETFRAMEWORK
+            CheckConnectionFailure(builder.ConnectionString, NP);
+#else
             CheckConnectionFailure(builder.ConnectionString, DataTestUtility.IsUsingManagedSNI() ? TCP : NP);
+#endif
         }
 
         [Fact]
diff --git a/src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/Config.cs b/src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/Config.cs
@@ -37,6 +37,7 @@ public class Config
         public bool IsDNSCachingSupportedTR = false;  // this is for the tenant ring
         public string EnclaveAzureDatabaseConnString = null;
         public string UserManagedIdentityClientId = null;
+        public string MakecertPath = null;
 
         public static Config Load(string configPath = @"config.json")
         {
diff --git a/src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/config.default.json b/src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/config.default.json
@@ -25,5 +25,6 @@
     "IsDNSCachingSupportedTR": false,
     "IsAzureSynapse": false,
     "EnclaveAzureDatabaseConnString": "",
-    "UserManagedIdentityClientId": ""
+    "UserManagedIdentityClientId": "",
+    "MakecertPath": ""
 }

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ namespace Microsoft.Data.SqlClient.ManualTesting.Tests.AlwaysEncrypted`
`23`	`23`	`[PlatformSpecific(TestPlatforms.Windows)]`
`24`	`24`	`public class CspProviderExt`
`25`	`25`	`{`
`26`		`- [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`26`	`+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringSetupForAE))]`
`27`	`27`	`[ClassData(typeof(AEConnectionStringProvider))]`
`28`	`28`	`public void TestKeysFromCertificatesCreatedWithMultipleCryptoProviders(string connectionString)`
`29`	`29`	`{`
Original file line number	Diff line number	Diff line change
`@@ -54,10 +54,10 @@ public class AdapterTest`
`54`	`54`	`public AdapterTest()`
`55`	`55`	`{`
`56`	`56`	`// create random name for temp tables`
`57`		`- _randomGuid = Guid.NewGuid().ToString();`
`58`		`- _tempTable = Environment.MachineName + "_" + _randomGuid;`
	`57`	`+ _tempTable = DataTestUtility.GetUniqueName("AdapterTest");`
`59`	`58`	`_tempTable = _tempTable.Replace('-', '_');`
`60`	`59`
	`60`	`+ _randomGuid = Guid.NewGuid().ToString();`
`61`	`61`	`_tempKey = "employee_id_key_" + Environment.TickCount.ToString() + _randomGuid;`
`62`	`62`	`_tempKey = _tempKey.Replace('-', '_');`
`63`	`63`
`@@ -179,15 +179,15 @@ public void PrepUnprepTest()`
`179`	`179`	`public void SqlVariantTest()`
`180`	`180`	`{`
`181`	`181`	`string tableName = DataTestUtility.GenerateObjectName();`
`182`		`- try`
	`182`	`+ // good test for null values and unicode strings`
	`183`	`+ using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
	`184`	`+ using (SqlCommand cmd = new SqlCommand(null, conn))`
	`185`	`+ using (SqlDataAdapter sqlAdapter = new SqlDataAdapter())`
`183`	`186`	`{`
`184`		`- ExecuteNonQueryCommand("CREATE TABLE " + tableName + " (c0_bigint bigint, c1_variant sql_variant)");`
`185`		`-`
`186`		`- // good test for null values and unicode strings`
`187`		`- using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
`188`		`- using (SqlCommand cmd = new SqlCommand(null, conn))`
`189`		`- using (SqlDataAdapter sqlAdapter = new SqlDataAdapter())`
	`187`	`+ try`
`190`	`188`	`{`
	`189`	`+ ExecuteNonQueryCommand("CREATE TABLE " + tableName + " (c0_bigint bigint, c1_variant sql_variant)");`
	`190`	`+`
`191`	`191`	`cmd.Connection.Open();`
`192`	`192`
`193`	`193`	`// the ORDER BY clause tests that we correctly ignore the ORDER token`
`@@ -263,10 +263,10 @@ public void SqlVariantTest()`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`	`}`
`266`		`- }`
`267`		`- finally`
`268`		`- {`
`269`		`- ExecuteNonQueryCommand("DROP TABLE " + tableName);`
	`266`	`+ finally`
	`267`	`+ {`
	`268`	`+ DataTestUtility.DropTable(conn, tableName);`
	`269`	`+ }`
`270`	`270`	`}`
`271`	`271`	`}`
`272`	`272`
`@@ -659,7 +659,7 @@ public void UpdateTest()`
`659`	`659`	`}`
`660`	`660`	`finally`
`661`	`661`	`{`
`662`		`- ExecuteNonQueryCommand("DROP TABLE " + _tempTable);`
	`662`	`+ DataTestUtility.DropTable(conn, _tempTable);`
`663`	`663`	`}`
`664`	`664`	`}`
`665`	`665`	`}`
`@@ -757,7 +757,7 @@ public void BulkUpdateTest()`
`757`	`757`	`}`
`758`	`758`	`finally`
`759`	`759`	`{`
`760`		`- ExecuteNonQueryCommand("DROP TABLE " + _tempTable);`
	`760`	`+ DataTestUtility.DropTable(conn, _tempTable);`
`761`	`761`	`}`
`762`	`762`	`}`
`763`	`763`	`}`
`@@ -768,33 +768,35 @@ public void BulkUpdateTest()`
`768`	`768`	`[ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]`
`769`	`769`	`public void UpdateRefreshTest()`
`770`	`770`	`{`
	`771`	`+ string identTableName = DataTestUtility.GetUniqueName("ID_");`
`771`	`772`	`string createIdentTable =`
`772`		`- "CREATE TABLE ID_" + _tempTable + "(id int IDENTITY," +`
	`773`	`+ $"CREATE TABLE {identTableName} (id int IDENTITY," +`
`773`	`774`	`"LastName nvarchar(50) NULL," +`
`774`	`775`	`"Firstname nvarchar(50) NULL)";`
`775`	`776`
	`777`	`+ string spName = DataTestUtility.GetUniqueName("sp_insert", withBracket: false);`
`776`	`778`	`string spCreateInsert =`
`777`		`- "CREATE PROCEDURE sp_insert" + _tempTable +`
	`779`	`+ $"CREATE PROCEDURE {spName}" +`
`778`	`780`	`"(@FirstName nvarchar(50), @LastName nvarchar(50), @id int OUTPUT) " +`
`779`	`781`	`"AS INSERT INTO " + _tempTable + " (FirstName, LastName) " +`
`780`	`782`	`"VALUES (@FirstName, @LastName); " +`
`781`	`783`	`"SELECT @id=@@IDENTITY";`
`782`	`784`
`783`		`- string spDropInsert = "DROP PROCEDURE sp_insert" + _tempTable;`
	`785`	`+ string spDropInsert = $"DROP PROCEDURE {spName}";`
`784`	`786`	`bool dropSP = false;`
`785`	`787`
`786`	`788`	`using (SqlDataAdapter adapter = new SqlDataAdapter())`
`787`	`789`	`using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
`788`	`790`	`using (SqlCommand cmd = new SqlCommand(null, conn))`
`789`		`- using (SqlCommand temp = new SqlCommand("SELECT id, LastName, FirstName into " + _tempTable + " from ID_" + _tempTable, conn))`
	`791`	`+ using (SqlCommand temp = new SqlCommand("SELECT id, LastName, FirstName into " + _tempTable + $" from {identTableName}", conn))`
`790`	`792`	`using (SqlCommand tableClean = new SqlCommand("", conn))`
`791`	`793`	`{`
`792`	`794`	`ExecuteNonQueryCommand(createIdentTable);`
`793`	`795`	`try`
`794`	`796`	`{`
`795`	`797`	`adapter.InsertCommand = new SqlCommand()`
`796`	`798`	`{`
`797`		`- CommandText = "sp_insert" + _tempTable,`
	`799`	`+ CommandText = spName,`
`798`	`800`	`CommandType = CommandType.StoredProcedure`
`799`	`801`	`};`
`800`	`802`	`adapter.InsertCommand.Parameters.Add(new SqlParameter("@FirstName", SqlDbType.NVarChar, 50, "FirstName"));`
`@@ -851,9 +853,9 @@ public void UpdateRefreshTest()`
`851`	`853`	`{`
`852`	`854`	`if (dropSP)`
`853`	`855`	`{`
`854`		`- ExecuteNonQueryCommand(spDropInsert);`
`855`		`- ExecuteNonQueryCommand("DROP TABLE " + _tempTable);`
`856`		`- ExecuteNonQueryCommand("DROP TABLE ID_" + _tempTable);`
	`856`	`+ DataTestUtility.DropStoredProcedure(conn, spName);`
	`857`	`+ DataTestUtility.DropTable(conn, _tempTable);`
	`858`	`+ DataTestUtility.DropTable(conn, identTableName);`
`857`	`859`	`}`
`858`	`860`	`}`
`859`	`861`	`}`
`@@ -873,18 +875,18 @@ public void UpdateNullTest()`
`873`	`875`	`"VALUES (@val_cvarbin, @val_cimage)";`
`874`	`876`	`bool dropSP = false;`
`875`	`877`
`876`		`- try`
`877`		`- {`
`878`		`- ExecuteNonQueryCommand(createTable);`
`879`		`- ExecuteNonQueryCommand(createSP);`
`880`		`- dropSP = true;`
`881`	`878`
`882`		`- using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
`883`		`- using (SqlCommand cmdInsert = new SqlCommand(procName, conn))`
`884`		`- using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))`
`885`		`- using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))`
`886`		`- using (SqlDataAdapter adapter = new SqlDataAdapter())`
	`879`	`+ using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
	`880`	`+ using (SqlCommand cmdInsert = new SqlCommand(procName, conn))`
	`881`	`+ using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))`
	`882`	`+ using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))`
	`883`	`+ using (SqlDataAdapter adapter = new SqlDataAdapter())`
	`884`	`+ {`
	`885`	`+ try`
`887`	`886`	`{`
	`887`	`+ ExecuteNonQueryCommand(createTable);`
	`888`	`+ ExecuteNonQueryCommand(createSP);`
	`889`	`+ dropSP = true;`
`888`	`890`	`conn.Open();`
`889`	`891`
`890`	`892`	`cmdInsert.CommandType = CommandType.StoredProcedure;`
`@@ -905,13 +907,13 @@ public void UpdateNullTest()`
`905`	`907`	`DataTestUtility.AssertEqualsWithDescription(DBNull.Value, ds.Tables[0].Rows[0][0], "Unexpected value.");`
`906`	`908`	`DataTestUtility.AssertEqualsWithDescription(DBNull.Value, ds.Tables[0].Rows[0][1], "Unexpected value.");`
`907`	`909`	`}`
`908`		`- }`
`909`		`- finally`
`910`		`- {`
`911`		`- if (dropSP)`
	`910`	`+ finally`
`912`	`911`	`{`
`913`		`- ExecuteNonQueryCommand("DROP PROCEDURE " + procName);`
`914`		`- ExecuteNonQueryCommand("DROP TABLE " + tableName);`
	`912`	`+ if (dropSP)`
	`913`	`+ {`
	`914`	`+ DataTestUtility.DropStoredProcedure(conn, procName);`
	`915`	`+ DataTestUtility.DropTable(conn, tableName);`
	`916`	`+ }`
`915`	`917`	`}`
`916`	`918`	`}`
`917`	`919`	`}`
`@@ -930,18 +932,18 @@ public void UpdateOffsetTest()`
`930`	`932`	`"VALUES (@val_cvarbin, @val_cimage)";`
`931`	`933`	`bool dropSP = false;`
`932`	`934`
`933`		`- try`
`934`		`- {`
`935`		`- ExecuteNonQueryCommand(createTable);`
`936`		`- ExecuteNonQueryCommand(createSP);`
`937`		`- dropSP = true;`
`938`	`935`
`939`		`- using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
`940`		`- using (SqlCommand cmdInsert = new SqlCommand(procName, conn))`
`941`		`- using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))`
`942`		`- using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))`
`943`		`- using (SqlDataAdapter adapter = new SqlDataAdapter())`
	`936`	`+ using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
	`937`	`+ using (SqlCommand cmdInsert = new SqlCommand(procName, conn))`
	`938`	`+ using (SqlCommand cmdSelect = new SqlCommand("select * from " + tableName, conn))`
	`939`	`+ using (SqlCommand tableClean = new SqlCommand("delete " + tableName, conn))`
	`940`	`+ using (SqlDataAdapter adapter = new SqlDataAdapter())`
	`941`	`+ {`
	`942`	`+ try`
`944`	`943`	`{`
	`944`	`+ ExecuteNonQueryCommand(createTable);`
	`945`	`+ ExecuteNonQueryCommand(createSP);`
	`946`	`+ dropSP = true;`
`945`	`947`	`conn.Open();`
`946`	`948`
`947`	`949`	`cmdInsert.CommandType = CommandType.StoredProcedure;`
`@@ -978,13 +980,13 @@ public void UpdateOffsetTest()`
`978`	`980`	`val = (byte[])(ds.Tables[0].Rows[0][1]);`
`979`	`981`	`Assert.True(ByteArraysEqual(expectedBytes2, val), "FAILED: Test 2: Unequal byte arrays.");`
`980`	`982`	`}`
`981`		`- }`
`982`		`- finally`
`983`		`- {`
`984`		`- if (dropSP)`
	`983`	`+ finally`
`985`	`984`	`{`
`986`		`- ExecuteNonQueryCommand("DROP PROCEDURE " + procName);`
`987`		`- ExecuteNonQueryCommand("DROP TABLE " + tableName);`
	`985`	`+ if (dropSP)`
	`986`	`+ {`
	`987`	`+ DataTestUtility.DropStoredProcedure(conn, procName);`
	`988`	`+ DataTestUtility.DropTable(conn, tableName);`
	`989`	`+ }`
`988`	`990`	`}`
`989`	`991`	`}`
`990`	`992`	`}`
`@@ -1069,7 +1071,7 @@ public void AutoGenUpdateTest()`
`1069`	`1071`	`}`
`1070`	`1072`	`finally`
`1071`	`1073`	`{`
`1072`		`- ExecuteNonQueryCommand("DROP TABLE " + _tempTable);`
	`1074`	`+ DataTestUtility.DropTable(conn, _tempTable);`
`1073`	`1075`	`}`
`1074`	`1076`	`}`
`1075`	`1077`	`}`
`@@ -1078,16 +1080,17 @@ public void AutoGenUpdateTest()`
`1078`	`1080`	`[ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]`
`1079`	`1081`	`public void AutoGenErrorTest()`
`1080`	`1082`	`{`
	`1083`	`+ string identTableName = DataTestUtility.GetUniqueName("ID_");`
`1081`	`1084`	`string createIdentTable =`
`1082`		`- "CREATE TABLE ID_" + _tempTable + "(id int IDENTITY," +`
	`1085`	`+ $"CREATE TABLE {identTableName} (id int IDENTITY," +`
`1083`	`1086`	`"LastName nvarchar(50) NULL," +`
`1084`	`1087`	`"Firstname nvarchar(50) NULL)";`
`1085`	`1088`
`1086`		`- try`
	`1089`	`+ using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
	`1090`	`+ using (SqlCommand cmd = new SqlCommand($"SELECT * into {_tempTable} from {identTableName}", conn))`
	`1091`	`+ using (SqlDataAdapter adapter = new SqlDataAdapter())`
`1087`	`1092`	`{`
`1088`		`- using (SqlConnection conn = new SqlConnection(DataTestUtility.TCPConnectionString))`
`1089`		`- using (SqlCommand cmd = new SqlCommand("SELECT * into " + _tempTable + " from ID_" + _tempTable, conn))`
`1090`		`- using (SqlDataAdapter adapter = new SqlDataAdapter())`
	`1093`	`+ try`
`1091`	`1094`	`{`
`1092`	`1095`	`ExecuteNonQueryCommand(createIdentTable);`
`1093`	`1096`
`@@ -1110,11 +1113,11 @@ public void AutoGenErrorTest()`
`1110`	`1113`	`SqlCommandBuilder builder = new SqlCommandBuilder(adapter);`
`1111`	`1114`	`adapter.Update(ds, _tempTable);`
`1112`	`1115`	`}`
`1113`		`- }`
`1114`		`- finally`
`1115`		`- {`
`1116`		`- ExecuteNonQueryCommand("DROP TABLE " + _tempTable);`
`1117`		`- ExecuteNonQueryCommand("DROP TABLE ID_" + _tempTable);`
	`1116`	`+ finally`
	`1117`	`+ {`
	`1118`	`+ DataTestUtility.DropTable(conn, _tempTable);`
	`1119`	`+ DataTestUtility.DropTable(conn, identTableName);`
	`1120`	`+ }`
`1118`	`1121`	`}`
`1119`	`1122`	`}`
`1120`	`1123`
`@@ -1206,7 +1209,7 @@ public void AutoGenBulkUpdateTest()`
`1206`	`1209`	`}`
`1207`	`1210`	`finally`
`1208`	`1211`	`{`
`1209`		`- ExecuteNonQueryCommand("DROP TABLE " + _tempTable);`
	`1212`	`+ DataTestUtility.DropTable(conn, _tempTable);`
`1210`	`1213`	`}`
`1211`	`1214`	`}`
`1212`	`1215`	`}`
`@@ -1319,6 +1322,48 @@ public void TestReadOnlyColumnMetadata()`
`1319`	`1322`	`}`
`1320`	`1323`	`}`
`1321`	`1324`
	`1325`	`+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]`
	`1326`	`+ [InlineData(nameof(SqlCommandBuilder.GetInsertCommand), null)]`
	`1327`	`+ [InlineData(nameof(SqlCommandBuilder.GetInsertCommand), true)]`
	`1328`	`+ [InlineData(nameof(SqlCommandBuilder.GetInsertCommand), false)]`
	`1329`	`+ [InlineData(nameof(SqlCommandBuilder.GetUpdateCommand), null)]`
	`1330`	`+ [InlineData(nameof(SqlCommandBuilder.GetUpdateCommand), true)]`
	`1331`	`+ [InlineData(nameof(SqlCommandBuilder.GetUpdateCommand), false)]`
	`1332`	`+ [InlineData(nameof(SqlCommandBuilder.GetDeleteCommand), null)]`
	`1333`	`+ [InlineData(nameof(SqlCommandBuilder.GetDeleteCommand), false)]`
	`1334`	`+ [InlineData(nameof(SqlCommandBuilder.GetDeleteCommand), true)]`
	`1335`	`+ public void VerifyGetCommand(string methodName, bool? useColumnsForParameterNames)`
	`1336`	`+ {`
	`1337`	`+ using (SqlConnection connection = new SqlConnection(DataTestUtility.TCPConnectionString))`
	`1338`	`+ {`
	`1339`	`+ connection.Open();`
	`1340`	`+ using (SqlDataAdapter dataAdapter = new SqlDataAdapter("SELECT * FROM dbo.Customers", connection))`
	`1341`	`+ {`
	`1342`	`+ using (SqlCommandBuilder commandBuilder = new SqlCommandBuilder(dataAdapter))`
	`1343`	`+ {`
	`1344`	`+ object[] parameters = null;`
	`1345`	`+ Type[] parameterTypes = null;`
	`1346`	`+ if (useColumnsForParameterNames != null)`
	`1347`	`+ {`
	`1348`	`+ parameters = new object[] { useColumnsForParameterNames };`
	`1349`	`+ parameterTypes = new Type[] { typeof(bool) };`
	`1350`	`+ }`
	`1351`	`+ else`
	`1352`	`+ {`
	`1353`	`+ parameters = new object[] { };`
	`1354`	`+ parameterTypes = new Type[] { };`
	`1355`	`+ }`
	`1356`	`+`
	`1357`	`+ MethodInfo method = commandBuilder.GetType().GetMethod(methodName, parameterTypes);`
	`1358`	`+ using (SqlCommand cmd = (SqlCommand)method.Invoke(commandBuilder, parameters))`
	`1359`	`+ {`
	`1360`	`+ Assert.NotNull(cmd);`
	`1361`	`+ }`
	`1362`	`+ }`
	`1363`	`+ }`
	`1364`	`+ }`
	`1365`	`+ }`
	`1366`	`+`
`1322`	`1367`	`#region Utility_Methods`
`1323`	`1368`	`private void CheckParameters(SqlCommand cmd, string expectedResults)`
`1324`	`1369`	`{`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,11 @@ static TcpDefaultForAzureTest()`
`41`	`41`	`public static void NonAzureNoProtocolConnectionTest()`
`42`	`42`	`{`
`43`	`43`	`builder.DataSource = InvalidHostname;`
	`44`	`+#if NETFRAMEWORK`
	`45`	`+ CheckConnectionFailure(builder.ConnectionString, NP);`
	`46`	`+#else`
`44`	`47`	`CheckConnectionFailure(builder.ConnectionString, DataTestUtility.IsUsingManagedSNI() ? TCP : NP);`
	`48`	`+#endif`
`45`	`49`	`}`
`46`	`50`
`47`	`51`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ public class Config`
`37`	`37`	`public bool IsDNSCachingSupportedTR = false; // this is for the tenant ring`
`38`	`38`	`public string EnclaveAzureDatabaseConnString = null;`
`39`	`39`	`public string UserManagedIdentityClientId = null;`
	`40`	`+ public string MakecertPath = null;`
`40`	`41`
`41`	`42`	`public static Config Load(string configPath = @"config.json")`
`42`	`43`	`{`
Original file line number	Diff line number	Diff line change
`@@ -25,5 +25,6 @@`
`25`	`25`	`"IsDNSCachingSupportedTR": false,`
`26`	`26`	`"IsAzureSynapse": false,`
`27`	`27`	`"EnclaveAzureDatabaseConnString": "",`
`28`		`- "UserManagedIdentityClientId": ""`
	`28`	`+ "UserManagedIdentityClientId": "",`
	`29`	`+ "MakecertPath": ""`
`29`	`30`	`}`