Extend AssertType to cover sync and async read/write converter paths (#6505)

Copilot · web-flow · commit 0eb4e956af01 · 2026-03-15T15:33:25.000+01:00
diff --git a/src/Npgsql/NpgsqlDataReader.cs b/src/Npgsql/NpgsqlDataReader.cs
@@ -89,6 +89,17 @@ public sealed class NpgsqlDataReader : DbDataReader, IDbColumnSchemaGenerator
     /// </summary>
     bool _isRowBuffered;
 
+    /// <summary>
+    /// Gets or sets whether the current row is fully buffered in memory.
+    /// When <see langword="false"/>, async reads will go through the real async converter path rather than the sync shortcut.
+    /// </summary>
+    /// <remarks>Settable for testing purposes.</remarks>
+    internal bool IsRowBuffered
+    {
+        get => _isRowBuffered;
+        set => _isRowBuffered = value;
+    }
+
     /// <summary>
     /// The RowDescription message for the current resultset being processed
     /// </summary>
diff --git a/test/Npgsql.Tests/Support/TestBase.cs b/test/Npgsql.Tests/Support/TestBase.cs
@@ -339,14 +339,31 @@ static async Task AssertTypeWriteCore<T>(
         cmd.CommandText = "SELECT " + string.Join(", ", Enumerable.Range(1, cmd.Parameters.Count).Select(i =>
             "pg_typeof($1)::text, $1::text".Replace("$1", $"${i}")));
 
-        await using var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SequentialAccess);
-        await reader.ReadAsync();
+        // Async execution: tests async write paths in converters
+        {
+            await using var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SequentialAccess);
+            await reader.ReadAsync();
+            AssertWriteResults(reader);
+        }
 
-        for (var i = 0; i < cmd.Parameters.Count * 2; i += 2)
+        // Sync execution: tests sync write paths in converters.
+        // Reset parameter values first so that one-shot values (e.g. streams) can be re-read from the start.
+        for (var i = 0; i < cmd.Parameters.Count; i++)
+            cmd.Parameters[i].Value = valueFactory();
         {
-            var error = errorIdentifier[i / 2];
-            Assert.That(reader[i], Is.EqualTo(dataTypeNameWithoutFacets), $"Got wrong data type name when writing with {error}");
-            Assert.That(reader[i+1], Is.EqualTo(sqlLiteral), $"Got wrong SQL literal when writing with {error}");
+            using var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
+            reader.Read();
+            AssertWriteResults(reader);
+        }
+
+        void AssertWriteResults(NpgsqlDataReader reader)
+        {
+            for (var i = 0; i < cmd.Parameters.Count * 2; i += 2)
+            {
+                var error = errorIdentifier[i / 2];
+                Assert.That(reader[i], Is.EqualTo(dataTypeNameWithoutFacets), $"Got wrong data type name when writing with {error}");
+                Assert.That(reader[i + 1], Is.EqualTo(sqlLiteral), $"Got wrong SQL literal when writing with {error}");
+            }
         }
 
         void DataTypeAsserts()
@@ -465,6 +482,8 @@ static async Task<T> AssertTypeReadCore<T>(
             sqlLiteral = sqlLiteral.Replace("'", "''");
 
         await using var cmd = new NpgsqlCommand($"SELECT '{sqlLiteral}'::{dataTypeName}", connection);
+
+        // Async execution: tests async and sync column reads within a single buffered query.
         await using var reader = await cmd.ExecuteReaderAsync();
         await reader.ReadAsync();
 
@@ -491,6 +510,15 @@ static async Task<T> AssertTypeReadCore<T>(
         T actual;
         if (valueTypeEqualsFieldType)
         {
+            // Set IsRowBuffered=false before the first read so _column is still -1, ensuring GetFieldValueAsync
+            // goes through the real async converter path (converter.ReadAsObjectAsync) rather than the sync shortcut.
+            reader.IsRowBuffered = false;
+            actual = (T)await reader.GetFieldValueAsync<object>(0);
+            Assert.That(actual, comparer is null ? Is.EqualTo(value) : Is.EqualTo(value).Using<T>(CreateEqualityComparer(comparer)),
+                $"Got wrong result from GetFieldValueAsync<object>() value when reading '{truncatedSqlLiteral}'");
+
+            // Restore IsRowBuffered so subsequent sync reads use the normal buffered code path.
+            reader.IsRowBuffered = true;
             actual = (T)reader.GetValue(0);
             Assert.That(actual, comparer is null ? Is.EqualTo(value) : Is.EqualTo(value).Using<T>(CreateEqualityComparer(comparer!)),
                 $"Got wrong result from GetValue() value when reading '{truncatedSqlLiteral}'");
@@ -502,8 +530,14 @@ static async Task<T> AssertTypeReadCore<T>(
             return actual;
         }
 
-        actual = reader.GetFieldValue<T>(0);
+        // See comment above about IsRowBuffered.
+        reader.IsRowBuffered = false;
+        actual = await reader.GetFieldValueAsync<T>(0);
+        Assert.That(actual, comparer is null ? Is.EqualTo(value) : Is.EqualTo(value).Using<T>(CreateEqualityComparer(comparer!)),
+            $"Got wrong result from GetFieldValueAsync<T>() value when reading '{truncatedSqlLiteral}'");
 
+        reader.IsRowBuffered = true;
+        actual = reader.GetFieldValue<T>(0);
         Assert.That(actual, comparer is null ? Is.EqualTo(value) : Is.EqualTo(value).Using<T>(CreateEqualityComparer(comparer!)),
             $"Got wrong result from GetFieldValue<T>() value when reading '{truncatedSqlLiteral}'");
 
