Removed block nesting levels in a few tests by using block-scoped using statements (#1939)

Co-authored-by: John Doe <john@doe>

Author: Lehonti

tests/Dapper.Tests/AsyncTests.cs

@@ -224,12 +224,10 @@ public void TestLongOperationWithCancellation()
         [Fact]
         public async Task TestBasicStringUsageClosedAsync()
         {
-            using (var conn = GetClosedConnection())
-            {
-                var query = await conn.QueryAsync<string>("select 'abc' as [Value] union all select @txt", new { txt = "def" }).ConfigureAwait(false);
-                var arr = query.ToArray();
-                Assert.Equal(new[] { "abc", "def" }, arr);
-            }
+            using var conn = GetClosedConnection();
+            var query = await conn.QueryAsync<string>("select 'abc' as [Value] union all select @txt", new { txt = "def" }).ConfigureAwait(false);
+            var arr = query.ToArray();
+            Assert.Equal(new[] { "abc", "def" }, arr);
         }
 
         [Fact]
@@ -258,12 +256,10 @@ public async Task TestExecuteAsync()
         [Fact]
         public void TestExecuteClosedConnAsyncInner()
         {
-            using (var conn = GetClosedConnection())
-            {
-                var query = conn.ExecuteAsync("declare @foo table(id int not null); insert @foo values(@id);", new { id = 1 });
-                var val = query.Result;
-                Assert.Equal(1, val);
-            }
+            using var conn = GetClosedConnection();
+            var query = conn.ExecuteAsync("declare @foo table(id int not null); insert @foo values(@id);", new { id = 1 });
+            var val = query.Result;
+            Assert.Equal(1, val);
         }
 
         [Fact]
@@ -307,83 +303,69 @@ public async Task TestMultiMapArbitraryWithSplitAsync()
         public async Task TestMultiMapWithSplitClosedConnAsync()
         {
             const string sql = "select 1 as id, 'abc' as name, 2 as id, 'def' as name";
-            using (var conn = GetClosedConnection())
+
+            using var conn = GetClosedConnection();
+
+            var productQuery = await conn.QueryAsync<Product, Category, Product>(sql, (prod, cat) =>
             {
-                var productQuery = await conn.QueryAsync<Product, Category, Product>(sql, (prod, cat) =>
-                {
-                    prod.Category = cat;
-                    return prod;
-                }).ConfigureAwait(false);
-
-                var product = productQuery.First();
-                // assertions
-                Assert.Equal(1, product.Id);
-                Assert.Equal("abc", product.Name);
-                Assert.Equal(2, product.Category.Id);
-                Assert.Equal("def", product.Category.Name);
-            }
+                prod.Category = cat;
+                return prod;
+            }).ConfigureAwait(false);
+
+            var product = productQuery.First();
+            // assertions
+            Assert.Equal(1, product.Id);
+            Assert.Equal("abc", product.Name);
+            Assert.Equal(2, product.Category.Id);
+            Assert.Equal("def", product.Category.Name);
         }
 
         [Fact]
         public async Task TestMultiAsync()
         {
-            using (SqlMapper.GridReader multi = await connection.QueryMultipleAsync("select 1; select 2").ConfigureAwait(false))
-            {
-                Assert.Equal(1, multi.ReadAsync<int>().Result.Single());
-                Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
-            }
+            using SqlMapper.GridReader multi = await connection.QueryMultipleAsync("select 1; select 2").ConfigureAwait(false);
+            Assert.Equal(1, multi.ReadAsync<int>().Result.Single());
+            Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
         }
 
         [Fact]
         public async Task TestMultiConversionAsync()
         {
-            using (SqlMapper.GridReader multi = await connection.QueryMultipleAsync("select Cast(1 as BigInt) Col1; select Cast(2 as BigInt) Col2").ConfigureAwait(false))
-            {
-                Assert.Equal(1, multi.ReadAsync<int>().Result.Single());
-                Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
-            }
+            using SqlMapper.GridReader multi = await connection.QueryMultipleAsync("select Cast(1 as BigInt) Col1; select Cast(2 as BigInt) Col2").ConfigureAwait(false);
+            Assert.Equal(1, multi.ReadAsync<int>().Result.Single());
+            Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
         }
 
         [Fact]
         public async Task TestMultiAsyncViaFirstOrDefault()
         {
-            using (SqlMapper.GridReader multi = await connection.QueryMultipleAsync("select 1; select 2; select 3; select 4; select 5").ConfigureAwait(false))
-            {
-                Assert.Equal(1, multi.ReadFirstOrDefaultAsync<int>().Result);
-                Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
-                Assert.Equal(3, multi.ReadFirstOrDefaultAsync<int>().Result);
-                Assert.Equal(4, multi.ReadAsync<int>().Result.Single());
-                Assert.Equal(5, multi.ReadFirstOrDefaultAsync<int>().Result);
-            }
+            using SqlMapper.GridReader multi = await connection.QueryMultipleAsync("select 1; select 2; select 3; select 4; select 5").ConfigureAwait(false);
+            Assert.Equal(1, multi.ReadFirstOrDefaultAsync<int>().Result);
+            Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
+            Assert.Equal(3, multi.ReadFirstOrDefaultAsync<int>().Result);
+            Assert.Equal(4, multi.ReadAsync<int>().Result.Single());
+            Assert.Equal(5, multi.ReadFirstOrDefaultAsync<int>().Result);
         }
 
         [Fact]
         public async Task TestMultiClosedConnAsync()
         {
-            using (var conn = GetClosedConnection())
-            {
-                using (SqlMapper.GridReader multi = await conn.QueryMultipleAsync("select 1; select 2").ConfigureAwait(false))
-                {
-                    Assert.Equal(1, multi.ReadAsync<int>().Result.Single());
-                    Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
-                }
-            }
+            using var conn = GetClosedConnection();
+            using SqlMapper.GridReader multi = await conn.QueryMultipleAsync("select 1; select 2").ConfigureAwait(false);
+            Assert.Equal(1, multi.ReadAsync<int>().Result.Single());
+            Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
         }
 
         [Fact]
         public async Task TestMultiClosedConnAsyncViaFirstOrDefault()
         {
-            using (var conn = GetClosedConnection())
-            {
-                using (SqlMapper.GridReader multi = await conn.QueryMultipleAsync("select 1; select 2; select 3; select 4; select 5").ConfigureAwait(false))
-                {
-                    Assert.Equal(1, multi.ReadFirstOrDefaultAsync<int>().Result);
-                    Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
-                    Assert.Equal(3, multi.ReadFirstOrDefaultAsync<int>().Result);
-                    Assert.Equal(4, multi.ReadAsync<int>().Result.Single());
-                    Assert.Equal(5, multi.ReadFirstOrDefaultAsync<int>().Result);
-                }
-            }
+            using var conn = GetClosedConnection();
+            using SqlMapper.GridReader multi = await conn.QueryMultipleAsync("select 1; select 2; select 3; select 4; select 5").ConfigureAwait(false);
+            Assert.Equal(1, multi.ReadFirstOrDefaultAsync<int>().Result);
+            Assert.Equal(2, multi.ReadAsync<int>().Result.Single());
+            Assert.Equal(3, multi.ReadFirstOrDefaultAsync<int>().Result);
+            Assert.Equal(4, multi.ReadAsync<int>().Result.Single());
+            Assert.Equal(5, multi.ReadFirstOrDefaultAsync<int>().Result);
         }
 
         [Fact]
@@ -402,17 +384,15 @@ public async Task ExecuteReaderOpenAsync()
         [Fact]
         public async Task ExecuteReaderClosedAsync()
         {
-            using (var conn = GetClosedConnection())
-            {
-                var dt = new DataTable();
-                dt.Load(await conn.ExecuteReaderAsync("select 3 as [three], 4 as [four]").ConfigureAwait(false));
-                Assert.Equal(2, dt.Columns.Count);
-                Assert.Equal("three", dt.Columns[0].ColumnName);
-                Assert.Equal("four", dt.Columns[1].ColumnName);
-                Assert.Equal(1, dt.Rows.Count);
-                Assert.Equal(3, (int)dt.Rows[0][0]);
-                Assert.Equal(4, (int)dt.Rows[0][1]);
-            }
+            using var conn = GetClosedConnection();
+            var dt = new DataTable();
+            dt.Load(await conn.ExecuteReaderAsync("select 3 as [three], 4 as [four]").ConfigureAwait(false));
+            Assert.Equal(2, dt.Columns.Count);
+            Assert.Equal("three", dt.Columns[0].ColumnName);
+            Assert.Equal("four", dt.Columns[1].ColumnName);
+            Assert.Equal(1, dt.Rows.Count);
+            Assert.Equal(3, (int)dt.Rows[0][0]);
+            Assert.Equal(4, (int)dt.Rows[0][1]);
         }
 
         [Fact]
@@ -424,7 +404,8 @@ public async Task LiteralReplacementOpen()
         [Fact]
         public async Task LiteralReplacementClosed()
         {
-            using (var conn = GetClosedConnection()) await LiteralReplacement(conn).ConfigureAwait(false);
+            using var conn = GetClosedConnection();
+            await LiteralReplacement(conn).ConfigureAwait(false);
         }
 
         private static async Task LiteralReplacement(IDbConnection conn)
@@ -453,7 +434,8 @@ public async Task LiteralReplacementDynamicOpen()
         [Fact]
         public async Task LiteralReplacementDynamicClosed()
         {
-            using (var conn = GetClosedConnection()) await LiteralReplacementDynamic(conn).ConfigureAwait(false);
+            using var conn = GetClosedConnection();
+            await LiteralReplacementDynamic(conn).ConfigureAwait(false);
         }
 
         private static async Task LiteralReplacementDynamic(IDbConnection conn)
@@ -917,14 +899,12 @@ select @@Name
         [Fact]
         public async Task Issue1281_DataReaderOutOfOrderAsync()
         {
-            using (var reader = await connection.ExecuteReaderAsync("Select 0, 1, 2").ConfigureAwait(false))
-            {
-                Assert.True(reader.Read());
-                Assert.Equal(2, reader.GetInt32(2));
-                Assert.Equal(0, reader.GetInt32(0));
-                Assert.Equal(1, reader.GetInt32(1));
-                Assert.False(reader.Read());
-            }
+            using var reader = await connection.ExecuteReaderAsync("Select 0, 1, 2").ConfigureAwait(false);
+            Assert.True(reader.Read());
+            Assert.Equal(2, reader.GetInt32(2));
+            Assert.Equal(0, reader.GetInt32(0));
+            Assert.Equal(1, reader.GetInt32(1));
+            Assert.False(reader.Read());
         }
 
         [Fact]

tests/Dapper.Tests/DecimalTests.cs

@@ -34,11 +34,9 @@ private void Issue261_Decimals_ADONET(bool setPrecisionScaleViaAbstractApi)
         {
             try
             {
-                using (var cmd = connection.CreateCommand())
-                {
-                    cmd.CommandText = "create proc #Issue261Direct @c decimal(10,5) OUTPUT as begin set @c=11.884 end";
-                    cmd.ExecuteNonQuery();
-                }
+                using var cmd = connection.CreateCommand();
+                cmd.CommandText = "create proc #Issue261Direct @c decimal(10,5) OUTPUT as begin set @c=11.884 end";
+                cmd.ExecuteNonQuery();
             }
             catch { /* we don't care that it already exists */ }
 

tests/Dapper.Tests/EnumTests.cs

@@ -92,18 +92,16 @@ private class TestEnumClassNoNull
         [Fact]
         public void AdoNetEnumValue()
         {
-            using (var cmd = connection.CreateCommand())
-            {
-                cmd.CommandText = "select @foo";
-                var p = cmd.CreateParameter();
-                p.ParameterName = "@foo";
-                p.DbType = DbType.Int32; // it turns out that this is the key piece; setting the DbType
-                p.Value = AnEnum.B;
-                cmd.Parameters.Add(p);
-                object value = cmd.ExecuteScalar();
-                AnEnum val = (AnEnum)value;
-                Assert.Equal(AnEnum.B, val);
-            }
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = "select @foo";
+            var p = cmd.CreateParameter();
+            p.ParameterName = "@foo";
+            p.DbType = DbType.Int32; // it turns out that this is the key piece; setting the DbType
+            p.Value = AnEnum.B;
+            cmd.Parameters.Add(p);
+            object value = cmd.ExecuteScalar();
+            AnEnum val = (AnEnum)value;
+            Assert.Equal(AnEnum.B, val);
         }
 
         [Fact]

tests/Dapper.Tests/Helpers/Attributes.cs

@@ -59,14 +59,12 @@ public FactRequiredCompatibilityLevelAttribute(int level) : base()
         public static readonly int DetectedLevel;
         static FactRequiredCompatibilityLevelAttribute()
         {
-            using (var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection())
+            using var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection();
+            try
             {
-                try
-                {
-                    DetectedLevel = conn.QuerySingle<int>("SELECT compatibility_level FROM sys.databases where name = DB_NAME()");
-                }
-                catch { /* don't care */ }
+                DetectedLevel = conn.QuerySingle<int>("SELECT compatibility_level FROM sys.databases where name = DB_NAME()");
             }
+            catch { /* don't care */ }
         }
     }
 
@@ -84,20 +82,18 @@ public FactUnlessCaseSensitiveDatabaseAttribute() : base()
         public static readonly bool IsCaseSensitive;
         static FactUnlessCaseSensitiveDatabaseAttribute()
         {
-            using (var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection())
+            using var conn = DatabaseProvider<SystemSqlClientProvider>.Instance.GetOpenConnection();
+            try
             {
-                try
-                {
-                    conn.Execute("declare @i int; set @I = 1;");
-                }
-                catch (Exception ex) when (ex.GetType().Name == "SqlException")
-                {
-                    int err = ((dynamic)ex).Number;
-                    if (err == 137)
-                        IsCaseSensitive = true;
-                    else
-                        throw;
-                }
+                conn.Execute("declare @i int; set @I = 1;");
+            }
+            catch (Exception ex) when (ex.GetType().Name == "SqlException")
+            {
+                int err = ((dynamic)ex).Number;
+                if (err == 137)
+                    IsCaseSensitive = true;
+                else
+                    throw;
             }
         }
     }

tests/Dapper.Tests/MiscTests.cs

@@ -909,42 +909,34 @@ public Issue40_User()
         [Fact]
         public void ExecuteFromClosed()
         {
-            using (var conn = GetClosedConnection())
-            {
-                conn.Execute("-- nop");
-                Assert.Equal(ConnectionState.Closed, conn.State);
-            }
+            using var conn = GetClosedConnection();
+            conn.Execute("-- nop");
+            Assert.Equal(ConnectionState.Closed, conn.State);
         }
 
         [Fact]
         public void ExecuteInvalidFromClosed()
         {
-            using (var conn = GetClosedConnection())
-            {
-                var ex = Assert.ThrowsAny<Exception>(() => conn.Execute("nop"));
-                Assert.Equal(ConnectionState.Closed, conn.State);
-            }
+            using var conn = GetClosedConnection();
+            var ex = Assert.ThrowsAny<Exception>(() => conn.Execute("nop"));
+            Assert.Equal(ConnectionState.Closed, conn.State);
         }
 
         [Fact]
         public void QueryFromClosed()
         {
-            using (var conn = GetClosedConnection())
-            {
-                var i = conn.Query<int>("select 1").Single();
-                Assert.Equal(ConnectionState.Closed, conn.State);
-                Assert.Equal(1, i);
-            }
+            using var conn = GetClosedConnection();
+            var i = conn.Query<int>("select 1").Single();
+            Assert.Equal(ConnectionState.Closed, conn.State);
+            Assert.Equal(1, i);
         }
 
         [Fact]
         public void QueryInvalidFromClosed()
         {
-            using (var conn = GetClosedConnection())
-            {
-                Assert.ThrowsAny<Exception>(() => conn.Query<int>("select gibberish").Single());
-                Assert.Equal(ConnectionState.Closed, conn.State);
-            }
+            using var conn = GetClosedConnection();
+            Assert.ThrowsAny<Exception>(() => conn.Query<int>("select gibberish").Single());
+            Assert.Equal(ConnectionState.Closed, conn.State);
         }
 
         [Fact]
@@ -1148,13 +1140,11 @@ public void Issue178_SqlServer()
             using (var sqlCmd = connection.CreateCommand())
             {
                 sqlCmd.CommandText = sql;
-                using (IDataReader reader1 = sqlCmd.ExecuteReader())
-                {
-                    Assert.True(reader1.Read());
-                    Assert.Equal(0, reader1.GetInt32(0));
-                    Assert.False(reader1.Read());
-                    Assert.False(reader1.NextResult());
-                }
+                using IDataReader reader1 = sqlCmd.ExecuteReader();
+                Assert.True(reader1.Read());
+                Assert.Equal(0, reader1.GetInt32(0));
+                Assert.False(reader1.Read());
+                Assert.False(reader1.NextResult());
             }
 
             // dapper