Tests | Activate SplitPacket Tests (#3061)

MichelZ · web-flow · commit f2a8cd29db8b · 2025-04-24T09:42:24.000-07:00
* Activate SplitPacketTest

* Close vs Dispose in netcore

* Minor refactoring to use existing functions

* Proxy does not work on named instances
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs
@@ -454,7 +454,18 @@ public static bool IsAADAuthorityURLSetup()
 
         public static bool IsNotAzureServer()
         {
-            return !AreConnStringsSetup() || !Utils.IsAzureSqlServer(new SqlConnectionStringBuilder((TCPConnectionString)).DataSource);
+            return !AreConnStringsSetup() || !Utils.IsAzureSqlServer(new SqlConnectionStringBuilder(TCPConnectionString).DataSource);
+        }
+
+        public static bool IsNotNamedInstance()
+        {
+            return !AreConnStringsSetup() || !new SqlConnectionStringBuilder(TCPConnectionString).DataSource.Contains(@"\");
+        }
+
+        public static bool IsLocalHost()
+        {
+            SqlConnectionStringBuilder builder = new(DataTestUtility.TCPConnectionString);
+            return ParseDataSource(builder.DataSource, out string hostname, out _, out _) && string.Equals("localhost", hostname, StringComparison.OrdinalIgnoreCase);
         }
 
         // Synapse: Always Encrypted is not supported with Azure Synapse.
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/SplitPacketTest/SplitPacketTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/SplitPacketTest/SplitPacketTest.cs
@@ -11,79 +11,83 @@
 
 namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
-    [ActiveIssue("5538")] // Only testable on localhost
-    public class SplitPacketTest
+    public class SplitPacketTest : IDisposable
     {
-        private int Port = -1;
-        private int SplitPacketSize = 1;
-        private string BaseConnString;
+        private int _port = -1;
+        private int _splitPacketSize = 1;
+        private string _baseConnString;
+        private TcpListener _listener;
+        private CancellationTokenSource _cts = new CancellationTokenSource();
 
         public SplitPacketTest()
         {
-            string actualHost;
-            int actualPort;
-
             SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(DataTestUtility.TCPConnectionString);
-            GetTcpInfoFromDataSource(builder.DataSource, out actualHost, out actualPort);
+            DataSourceBuilder dataSourceBuilder = new DataSourceBuilder(builder.DataSource);
 
-            Task.Factory.StartNew(() => { SetupProxy(actualHost, actualPort); });
+            Task.Factory.StartNew(() => { SetupProxy(dataSourceBuilder.ServerName, dataSourceBuilder.Port ?? 1433, _cts.Token); });
 
-            for (int i = 0; i < 10 && Port == -1; i++)
+            for (int i = 0; i < 10 && _port == -1; i++)
             {
                 Thread.Sleep(500);
             }
-            if (Port == -1)
+            if (_port == -1)
                 throw new InvalidOperationException("Proxy local port not defined!");
 
-            builder.DataSource = "tcp:127.0.0.1," + Port;
-            BaseConnString = builder.ConnectionString;
+            builder.DataSource = "tcp:127.0.0.1," + _port;
+            _baseConnString = builder.ConnectionString;
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]
         public void OneByteSplitTest()
         {
-            SplitPacketSize = 1;
+            _splitPacketSize = 1;
             OpenConnection();
+            Assert.True(true);
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]
         public void AlmostFullHeaderTest()
         {
-            SplitPacketSize = 7;
+            _splitPacketSize = 7;
             OpenConnection();
+            Assert.True(true);
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]
         public void FullHeaderTest()
         {
-            SplitPacketSize = 8;
+            _splitPacketSize = 8;
             OpenConnection();
+            Assert.True(true);
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]
         public void HeaderPlusOneTest()
         {
-            SplitPacketSize = 9;
+            _splitPacketSize = 9;
             OpenConnection();
+            Assert.True(true);
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]
         public void MARSSplitTest()
         {
-            SplitPacketSize = 1;
+            _splitPacketSize = 1;
             OpenMarsConnection("select * from Orders");
+            Assert.True(true);
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
+        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]
         public void MARSReplicateTest()
         {
-            SplitPacketSize = 1;
+            _splitPacketSize = 1;
             OpenMarsConnection("select REPLICATE('A', 10000)");
+            Assert.True(true);
         }
 
         private void OpenMarsConnection(string cmdText)
         {
-            using (SqlConnection conn = new SqlConnection((new SqlConnectionStringBuilder(BaseConnString) { MultipleActiveResultSets = true }).ConnectionString))
+            using (SqlConnection conn = new SqlConnection((new SqlConnectionStringBuilder(_baseConnString) { MultipleActiveResultSets = true }).ConnectionString))
             {
                 conn.Open();
                 using (SqlCommand cmd1 = new SqlCommand(cmdText, conn))
@@ -102,7 +106,7 @@ private void OpenMarsConnection(string cmdText)
 
         private void OpenConnection()
         {
-            using (SqlConnection conn = new SqlConnection(BaseConnString))
+            using (SqlConnection conn = new SqlConnection(_baseConnString))
             {
                 conn.Open();
                 using (SqlCommand cmd = new SqlCommand("select * from Orders", conn))
@@ -114,23 +118,23 @@ private void OpenConnection()
             }
         }
 
-        private void SetupProxy(string actualHost, int actualPort)
+        private void SetupProxy(string actualHost, int actualPort, CancellationToken cancellationToken)
         {
-            TcpListener listener = new TcpListener(IPAddress.Loopback, 0);
-            listener.Start();
-            Port = ((IPEndPoint)listener.LocalEndpoint).Port;
-            var client = listener.AcceptTcpClientAsync().GetAwaiter().GetResult();
+            _listener = new TcpListener(IPAddress.Loopback, 0);
+            _listener.Start();
+            _port = ((IPEndPoint)_listener.LocalEndpoint).Port;
+            var client = _listener.AcceptTcpClientAsync().GetAwaiter().GetResult();
 
             var sqlClient = new TcpClient();
-            sqlClient.ConnectAsync(actualHost, actualPort).Wait();
+            sqlClient.ConnectAsync(actualHost, actualPort).Wait(cancellationToken);
 
-            Task.Factory.StartNew(() => { ForwardToSql(client, sqlClient); });
-            Task.Factory.StartNew(() => { ForwardToClient(client, sqlClient); });
+            Task.Factory.StartNew(() => { ForwardToSql(client, sqlClient, cancellationToken); }, cancellationToken);
+            Task.Factory.StartNew(() => { ForwardToClient(client, sqlClient, cancellationToken); }, cancellationToken);
         }
 
-        private void ForwardToSql(TcpClient ourClient, TcpClient sqlClient)
+        private void ForwardToSql(TcpClient ourClient, TcpClient sqlClient, CancellationToken cancellationToken)
         {
-            while (true)
+            while (!cancellationToken.IsCancellationRequested)
             {
                 byte[] buffer = new byte[1024];
                 int bytesRead = ourClient.GetStream().Read(buffer, 0, buffer.Length);
@@ -139,11 +143,11 @@ private void ForwardToSql(TcpClient ourClient, TcpClient sqlClient)
             }
         }
 
-        private void ForwardToClient(TcpClient ourClient, TcpClient sqlClient)
+        private void ForwardToClient(TcpClient ourClient, TcpClient sqlClient, CancellationToken cancellationToken)
         {
-            while (true)
+            while (!cancellationToken.IsCancellationRequested)
             {
-                byte[] buffer = new byte[SplitPacketSize];
+                byte[] buffer = new byte[_splitPacketSize];
                 int bytesRead = sqlClient.GetStream().Read(buffer, 0, buffer.Length);
 
                 ourClient.GetStream().Write(buffer, 0, bytesRead);
@@ -155,22 +159,24 @@ private void ForwardToClient(TcpClient ourClient, TcpClient sqlClient)
             }
         }
 
-        private static void GetTcpInfoFromDataSource(string dataSource, out string hostName, out int port)
+        public void Dispose()
         {
-            string[] dataSourceParts = dataSource.Split(',');
-            if (dataSourceParts.Length == 1)
-            {
-                hostName = dataSourceParts[0].Replace("tcp:", "");
-                port = 1433;
-            }
-            else if (dataSourceParts.Length == 2)
-            {
-                hostName = dataSourceParts[0].Replace("tcp:", "");
-                port = int.Parse(dataSourceParts[1]);
-            }
-            else
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
             {
-                throw new InvalidOperationException("TCP Connection String not in correct format!");
+                _cts.Cancel();
+                _cts.Dispose();
+                _listener?.Server.Dispose();
+#if NETFRAMEWORK
+                _listener?.Stop();
+#else
+                _listener?.Dispose();
+#endif
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -11,79 +11,83 @@`
`11`	`11`
`12`	`12`	`namespace Microsoft.Data.SqlClient.ManualTesting.Tests`
`13`	`13`	`{`
`14`		`- [ActiveIssue("5538")] // Only testable on localhost`
`15`		`- public class SplitPacketTest`
	`14`	`+ public class SplitPacketTest : IDisposable`
`16`	`15`	`{`
`17`		`- private int Port = -1;`
`18`		`- private int SplitPacketSize = 1;`
`19`		`- private string BaseConnString;`
	`16`	`+ private int _port = -1;`
	`17`	`+ private int _splitPacketSize = 1;`
	`18`	`+ private string _baseConnString;`
	`19`	`+ private TcpListener _listener;`
	`20`	`+ private CancellationTokenSource _cts = new CancellationTokenSource();`
`20`	`21`
`21`	`22`	`public SplitPacketTest()`
`22`	`23`	`{`
`23`		`- string actualHost;`
`24`		`- int actualPort;`
`25`		`-`
`26`	`24`	`SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(DataTestUtility.TCPConnectionString);`
`27`		`- GetTcpInfoFromDataSource(builder.DataSource, out actualHost, out actualPort);`
	`25`	`+ DataSourceBuilder dataSourceBuilder = new DataSourceBuilder(builder.DataSource);`
`28`	`26`
`29`		`- Task.Factory.StartNew(() => { SetupProxy(actualHost, actualPort); });`
	`27`	`+ Task.Factory.StartNew(() => { SetupProxy(dataSourceBuilder.ServerName, dataSourceBuilder.Port ?? 1433, _cts.Token); });`
`30`	`28`
`31`		`- for (int i = 0; i < 10 && Port == -1; i++)`
	`29`	`+ for (int i = 0; i < 10 && _port == -1; i++)`
`32`	`30`	`{`
`33`	`31`	`Thread.Sleep(500);`
`34`	`32`	`}`
`35`		`- if (Port == -1)`
	`33`	`+ if (_port == -1)`
`36`	`34`	`throw new InvalidOperationException("Proxy local port not defined!");`
`37`	`35`
`38`		`- builder.DataSource = "tcp:127.0.0.1," + Port;`
`39`		`- BaseConnString = builder.ConnectionString;`
	`36`	`+ builder.DataSource = "tcp:127.0.0.1," + _port;`
	`37`	`+ _baseConnString = builder.ConnectionString;`
`40`	`38`	`}`
`41`	`39`
`42`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`40`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]`
`43`	`41`	`public void OneByteSplitTest()`
`44`	`42`	`{`
`45`		`- SplitPacketSize = 1;`
	`43`	`+ _splitPacketSize = 1;`
`46`	`44`	`OpenConnection();`
	`45`	`+ Assert.True(true);`
`47`	`46`	`}`
`48`	`47`
`49`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`48`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]`
`50`	`49`	`public void AlmostFullHeaderTest()`
`51`	`50`	`{`
`52`		`- SplitPacketSize = 7;`
	`51`	`+ _splitPacketSize = 7;`
`53`	`52`	`OpenConnection();`
	`53`	`+ Assert.True(true);`
`54`	`54`	`}`
`55`	`55`
`56`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`56`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]`
`57`	`57`	`public void FullHeaderTest()`
`58`	`58`	`{`
`59`		`- SplitPacketSize = 8;`
	`59`	`+ _splitPacketSize = 8;`
`60`	`60`	`OpenConnection();`
	`61`	`+ Assert.True(true);`
`61`	`62`	`}`
`62`	`63`
`63`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`64`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]`
`64`	`65`	`public void HeaderPlusOneTest()`
`65`	`66`	`{`
`66`		`- SplitPacketSize = 9;`
	`67`	`+ _splitPacketSize = 9;`
`67`	`68`	`OpenConnection();`
	`69`	`+ Assert.True(true);`
`68`	`70`	`}`
`69`	`71`
`70`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`72`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]`
`71`	`73`	`public void MARSSplitTest()`
`72`	`74`	`{`
`73`		`- SplitPacketSize = 1;`
	`75`	`+ _splitPacketSize = 1;`
`74`	`76`	`OpenMarsConnection("select * from Orders");`
	`77`	`+ Assert.True(true);`
`75`	`78`	`}`
`76`	`79`
`77`		`- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]`
	`80`	`+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsTCPConnStringSetup), nameof(DataTestUtility.IsLocalHost), nameof(DataTestUtility.IsNotNamedInstance))]`
`78`	`81`	`public void MARSReplicateTest()`
`79`	`82`	`{`
`80`		`- SplitPacketSize = 1;`
	`83`	`+ _splitPacketSize = 1;`
`81`	`84`	`OpenMarsConnection("select REPLICATE('A', 10000)");`
	`85`	`+ Assert.True(true);`
`82`	`86`	`}`
`83`	`87`
`84`	`88`	`private void OpenMarsConnection(string cmdText)`
`85`	`89`	`{`
`86`		`- using (SqlConnection conn = new SqlConnection((new SqlConnectionStringBuilder(BaseConnString) { MultipleActiveResultSets = true }).ConnectionString))`
	`90`	`+ using (SqlConnection conn = new SqlConnection((new SqlConnectionStringBuilder(_baseConnString) { MultipleActiveResultSets = true }).ConnectionString))`
`87`	`91`	`{`
`88`	`92`	`conn.Open();`
`89`	`93`	`using (SqlCommand cmd1 = new SqlCommand(cmdText, conn))`
`@@ -102,7 +106,7 @@ private void OpenMarsConnection(string cmdText)`
`102`	`106`
`103`	`107`	`private void OpenConnection()`
`104`	`108`	`{`
`105`		`- using (SqlConnection conn = new SqlConnection(BaseConnString))`
	`109`	`+ using (SqlConnection conn = new SqlConnection(_baseConnString))`
`106`	`110`	`{`
`107`	`111`	`conn.Open();`
`108`	`112`	`using (SqlCommand cmd = new SqlCommand("select * from Orders", conn))`
`@@ -114,23 +118,23 @@ private void OpenConnection()`
`114`	`118`	`}`
`115`	`119`	`}`
`116`	`120`
`117`		`- private void SetupProxy(string actualHost, int actualPort)`
	`121`	`+ private void SetupProxy(string actualHost, int actualPort, CancellationToken cancellationToken)`
`118`	`122`	`{`
`119`		`- TcpListener listener = new TcpListener(IPAddress.Loopback, 0);`
`120`		`- listener.Start();`
`121`		`- Port = ((IPEndPoint)listener.LocalEndpoint).Port;`
`122`		`- var client = listener.AcceptTcpClientAsync().GetAwaiter().GetResult();`
	`123`	`+ _listener = new TcpListener(IPAddress.Loopback, 0);`
	`124`	`+ _listener.Start();`
	`125`	`+ _port = ((IPEndPoint)_listener.LocalEndpoint).Port;`
	`126`	`+ var client = _listener.AcceptTcpClientAsync().GetAwaiter().GetResult();`
`123`	`127`
`124`	`128`	`var sqlClient = new TcpClient();`
`125`		`- sqlClient.ConnectAsync(actualHost, actualPort).Wait();`
	`129`	`+ sqlClient.ConnectAsync(actualHost, actualPort).Wait(cancellationToken);`
`126`	`130`
`127`		`- Task.Factory.StartNew(() => { ForwardToSql(client, sqlClient); });`
`128`		`- Task.Factory.StartNew(() => { ForwardToClient(client, sqlClient); });`
	`131`	`+ Task.Factory.StartNew(() => { ForwardToSql(client, sqlClient, cancellationToken); }, cancellationToken);`
	`132`	`+ Task.Factory.StartNew(() => { ForwardToClient(client, sqlClient, cancellationToken); }, cancellationToken);`
`129`	`133`	`}`
`130`	`134`
`131`		`- private void ForwardToSql(TcpClient ourClient, TcpClient sqlClient)`
	`135`	`+ private void ForwardToSql(TcpClient ourClient, TcpClient sqlClient, CancellationToken cancellationToken)`
`132`	`136`	`{`
`133`		`- while (true)`
	`137`	`+ while (!cancellationToken.IsCancellationRequested)`
`134`	`138`	`{`
`135`	`139`	`byte[] buffer = new byte[1024];`
`136`	`140`	`int bytesRead = ourClient.GetStream().Read(buffer, 0, buffer.Length);`
`@@ -139,11 +143,11 @@ private void ForwardToSql(TcpClient ourClient, TcpClient sqlClient)`
`139`	`143`	`}`
`140`	`144`	`}`
`141`	`145`
`142`		`- private void ForwardToClient(TcpClient ourClient, TcpClient sqlClient)`
	`146`	`+ private void ForwardToClient(TcpClient ourClient, TcpClient sqlClient, CancellationToken cancellationToken)`
`143`	`147`	`{`
`144`		`- while (true)`
	`148`	`+ while (!cancellationToken.IsCancellationRequested)`
`145`	`149`	`{`
`146`		`- byte[] buffer = new byte[SplitPacketSize];`
	`150`	`+ byte[] buffer = new byte[_splitPacketSize];`
`147`	`151`	`int bytesRead = sqlClient.GetStream().Read(buffer, 0, buffer.Length);`
`148`	`152`
`149`	`153`	`ourClient.GetStream().Write(buffer, 0, bytesRead);`
`@@ -155,22 +159,24 @@ private void ForwardToClient(TcpClient ourClient, TcpClient sqlClient)`
`155`	`159`	`}`
`156`	`160`	`}`
`157`	`161`
`158`		`- private static void GetTcpInfoFromDataSource(string dataSource, out string hostName, out int port)`
	`162`	`+ public void Dispose()`
`159`	`163`	`{`
`160`		`- string[] dataSourceParts = dataSource.Split(',');`
`161`		`- if (dataSourceParts.Length == 1)`
`162`		`- {`
`163`		`- hostName = dataSourceParts[0].Replace("tcp:", "");`
`164`		`- port = 1433;`
`165`		`- }`
`166`		`- else if (dataSourceParts.Length == 2)`
`167`		`- {`
`168`		`- hostName = dataSourceParts[0].Replace("tcp:", "");`
`169`		`- port = int.Parse(dataSourceParts[1]);`
`170`		`- }`
`171`		`- else`
	`164`	`+ Dispose(true);`
	`165`	`+ GC.SuppressFinalize(this);`
	`166`	`+ }`
	`167`	`+`
	`168`	`+ protected virtual void Dispose(bool disposing)`
	`169`	`+ {`
	`170`	`+ if (disposing)`
`172`	`171`	`{`
`173`		`- throw new InvalidOperationException("TCP Connection String not in correct format!");`
	`172`	`+ _cts.Cancel();`
	`173`	`+ _cts.Dispose();`
	`174`	`+ _listener?.Server.Dispose();`
	`175`	`+#if NETFRAMEWORK`
	`176`	`+ _listener?.Stop();`
	`177`	`+#else`
	`178`	`+ _listener?.Dispose();`
	`179`	`+#endif`
`174`	`180`	`}`
`175`	`181`	`}`
`176`	`182`	`}`