test: add more tests

Author: olavloite

drivers/spanner-ado-net/spanner-ado-net-tests/AbstractMockServerTests.cs

@@ -53,4 +53,53 @@ public void Reset()
     {
         Fixture.SpannerMock.Reset();
     }
-}
+
+    protected async Task<SpannerConnection> OpenConnectionAsync()
+    {
+        var connection = new SpannerConnection(ConnectionString);
+        await connection.OpenAsync();
+        return connection;
+    }
+
+    protected SpannerDataSource CreateDataSource()
+    {
+        return CreateDataSource(_ => { });
+    }
+    
+    protected SpannerDataSource CreateDataSource(Action<SpannerConnectionStringBuilder> connectionStringBuilderAction)
+    {
+        var connectionStringBuilder = new SpannerConnectionStringBuilder(ConnectionString);
+        connectionStringBuilderAction(connectionStringBuilder);
+        return SpannerDataSource.Create(connectionStringBuilder);
+    }
+
+}
+
+public static class SpannerConnectionExtensions
+{
+    public static int ExecuteNonQuery(this SpannerConnection conn, string sql, SpannerTransaction? tx = null)
+    {
+        using var command = tx == null ? new SpannerCommand(sql, conn) : new SpannerCommand(sql, conn, tx);
+        return command.ExecuteNonQuery();
+    }
+
+    public static object? ExecuteScalar(this SpannerConnection conn, string sql, SpannerTransaction? tx = null)
+    {
+        using var command = tx == null ? new SpannerCommand(sql, conn) : new SpannerCommand(sql, conn, tx);
+        return command.ExecuteScalar();
+    }
+
+    public static async Task<int> ExecuteNonQueryAsync(
+        this SpannerConnection conn, string sql, SpannerTransaction? tx = null, CancellationToken cancellationToken = default)
+    {
+        await using var command = tx == null ? new SpannerCommand(sql, conn) : new SpannerCommand(sql, conn, tx);
+        return await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    public static async Task<object?> ExecuteScalarAsync(
+        this SpannerConnection conn, string sql, SpannerTransaction? tx = null, CancellationToken cancellationToken = default)
+    {
+        await using var command = tx == null ? new SpannerCommand(sql, conn) : new SpannerCommand(sql, conn, tx);
+        return await command.ExecuteScalarAsync(cancellationToken);
+    }
+}

drivers/spanner-ado-net/spanner-ado-net-tests/CommandTests.cs

@@ -13,8 +13,10 @@
 // limitations under the License.
 
 using System;
+using System.Data;
 using System.Data.Common;
 using System.Linq;
+using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 using Google.Cloud.Spanner.V1;
@@ -167,7 +169,106 @@ public async Task TestAllParameterTypes()
         Assert.That(fields["p23"].ListValue.Values[0].NumberValue, Is.EqualTo(3.14f));
         Assert.That(fields["p23"].ListValue.Values[1].HasNullValue, Is.True);
     }
+    
+    [Test]
+    [TestCase(new[] { true }, TestName = "SingleQuery")]
+    [TestCase(new[] { false }, TestName = "SingleNonQuery")]
+    [TestCase(new[] { true, true }, TestName = "TwoQueries")]
+    [TestCase(new[] { false, false }, TestName = "TwoNonQueries")]
+    [TestCase(new[] { false, true }, TestName = "NonQueryQuery")]
+    [TestCase(new[] { true, false }, TestName = "QueryNonQuery")]
+    [Ignore("Requires support for multi-statements strings in the shared library")]
+    public async Task MultipleStatements(bool[] queries)
+    {
+        const string update = "UPDATE my_table SET name='yo' WHERE 1=0;";
+        const string select = "SELECT 1;";
+        Fixture.SpannerMock.AddOrUpdateStatementResult(update, StatementResult.CreateUpdateCount(0));
+        
+        await using var conn = await OpenConnectionAsync();
+        var sb = new StringBuilder();
+        foreach (var query in queries)
+        {
+            sb.Append(query ? select : update);
+        }
+        var sql = sb.ToString();
+        foreach (var prepare in new[] { false, true })
+        {
+            await using var cmd = conn.CreateCommand();
+            cmd.CommandText = sql;
+            if (prepare)
+            {
+                await cmd.PrepareAsync();
+            }
+            await using var reader = await cmd.ExecuteReaderAsync();
+            var numResultSets = queries.Count(q => q);
+            for (var i = 0; i < numResultSets; i++)
+            {
+                Assert.That(await reader.ReadAsync(), Is.True);
+                Assert.That(reader[0], Is.EqualTo(1));
+                Assert.That(await reader.NextResultAsync(), Is.EqualTo(i != numResultSets - 1));
+            }
+        }
+    }
 
+    [Test]
+    [Ignore("Requires support for multi-statements strings in the shared library")]
+    public async Task MultipleStatementsWithParameters([Values(PrepareOrNot.NotPrepared, PrepareOrNot.Prepared)] PrepareOrNot prepare)
+    {
+        await using var conn = await OpenConnectionAsync();
+        await using var cmd = conn.CreateCommand();
+        cmd.CommandText = "SELECT @p1; SELECT @p2";
+        var p1 = new SpannerParameter{ParameterName = "p1"};
+        var p2 = new SpannerParameter{ParameterName = "p2"};
+        cmd.Parameters.Add(p1);
+        cmd.Parameters.Add(p2);
+        if (prepare == PrepareOrNot.Prepared)
+        {
+            await cmd.PrepareAsync();
+        }
+        p1.Value = 8;
+        p2.Value = "foo";
+        await using var reader = await cmd.ExecuteReaderAsync();
+        Assert.That(await reader.ReadAsync(), Is.True);
+        Assert.That(reader.GetInt32(0), Is.EqualTo(8));
+        Assert.That(await reader.NextResultAsync(), Is.True);
+        Assert.That(await reader.ReadAsync(), Is.True);
+        Assert.That(reader.GetString(0), Is.EqualTo("foo"));
+        Assert.That(await reader.NextResultAsync(), Is.False);
+    }
+    
+    [Test]
+    [Ignore("Requires support for multi-statements strings in the shared library")]
+    public async Task SingleRowMultipleStatements([Values(PrepareOrNot.NotPrepared, PrepareOrNot.Prepared)] PrepareOrNot prepare)
+    {
+        await using var conn = await OpenConnectionAsync();
+        await using var cmd = new SpannerCommand("SELECT 1; SELECT 2", conn);
+        if (prepare == PrepareOrNot.Prepared)
+        {
+            await cmd.PrepareAsync();
+        }
+        await using var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SingleRow);
+        Assert.That(await reader.ReadAsync(), Is.True);
+        Assert.That(reader.GetInt32(0), Is.EqualTo(1));
+        Assert.That(await reader.ReadAsync(), Is.False);
+        Assert.That(await reader.NextResultAsync(), Is.False);
+    }
+
+    [Test]
+    [Ignore("Requires support for statement_timeout in the shared library")]
+    public async Task Timeout()
+    {
+        Fixture.SpannerMock.AddOrUpdateExecutionTime(nameof(Fixture.SpannerMock.ExecuteStreamingSql), ExecutionTime.FromMillis(10, 0));
+        
+        await using var dataSource = CreateDataSource(csb => csb.CommandTimeout = 1);
+        await using var conn = await dataSource.OpenConnectionAsync() as SpannerConnection;
+        await using var cmd = new SpannerCommand("SELECT 1", conn!);
+        Assert.That(() => cmd.ExecuteScalar(), Throws.Exception
+            .TypeOf<SpannerDbException>()
+            .With.InnerException.TypeOf<TimeoutException>()
+        );
+        Assert.That(conn!.State, Is.EqualTo(ConnectionState.Open));
+    }
+    
     private void AddParameter(DbCommand command, string name, object? value)
     {
         var parameter = command.CreateParameter();

drivers/spanner-ado-net/spanner-ado-net-tests/ConnectionStringBuilderTests.cs

@@ -13,15 +13,10 @@
 // limitations under the License.
 
 using System.Data;
-using Google.Cloud.SpannerLib;
-using Google.Cloud.SpannerLib.MockServer;
-using Google.Rpc;
-using Grpc.Core;
-using Status = Grpc.Core.Status;
 
 namespace Google.Cloud.Spanner.DataProvider.Tests;
 
-public class ConnectionStringBuilderTests : AbstractMockServerTests
+public class ConnectionStringBuilderTests
 {
     [Test]
     public void Basic()
@@ -172,126 +167,5 @@ public void PropertiesToConnectionString()
         Assert.That(builder.ConnectionString, Is.EqualTo("Data Source=projects/project1/instances/instance1/databases/database1;Host=localhost;Port=80;UsePlainText=True;DefaultIsolationLevel=RepeatableRead"));
         Assert.That(builder.SpannerLibConnectionString, Is.EqualTo("localhost:80/projects/project1/instances/instance1/databases/database1;UsePlainText=True;DefaultIsolationLevel=RepeatableRead"));
     }
-
-    [Test]
-    public void RequiredConnectionStringProperties()
-    {
-        using var connection = new SpannerConnection();
-        Assert.Throws<ArgumentException>(() => connection.ConnectionString = "Host=localhost;Port=80");
-    }
-
-    [Test]
-    public void FailedConnectThenSucceed()
-    {
-        // Close all current pools to ensure that we get a fresh pool.
-        SpannerPool.CloseSpannerLib();
-        // TODO: Make this a public property in the mock server.
-        const string detectDialectQuery =
-            "select option_value from information_schema.database_options where option_name='database_dialect'";
-        Fixture.SpannerMock.AddOrUpdateStatementResult(detectDialectQuery, StatementResult.CreateException(new RpcException(new Status(StatusCode.NotFound, "Database not found"))));
-        using var conn = new SpannerConnection();
-        conn.ConnectionString = ConnectionString;
-        var exception = Assert.Throws<SpannerException>(() => conn.Open());
-        Assert.That(exception.Code, Is.EqualTo(Code.NotFound));
-        Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));
-        
-        // Remove the error and retry.
-        Fixture.SpannerMock.AddOrUpdateStatementResult(detectDialectQuery, StatementResult.CreateResultSet(new List<Tuple<Google.Cloud.Spanner.V1.TypeCode, string>>
-        {
-            Tuple.Create<Google.Cloud.Spanner.V1.TypeCode, string>(V1.TypeCode.String, "option_value")
-        }, new List<object[]>
-        {
-            new object[] { "GOOGLE_STANDARD_SQL" }
-        }));
-        conn.Open();
-        Assert.That(conn.State, Is.EqualTo(ConnectionState.Open));
-    }
-
-    [Test]
-    [Ignore("Needs connect_timeout property")]
-    public void OpenTimeout()
-    {
-        // TODO: Add connect_timeout property.
-        var builder = new SpannerConnectionStringBuilder
-        {
-            Host = Fixture.Host,
-            Port = (uint) Fixture.Port,
-            UsePlainText = true,
-            DataSource = "projects/project1/instances/instance1/databases/database1",
-            //ConnectTimeout = TimeSpan.FromMicroseconds(1),
-        };
-        using var connection = new SpannerConnection();
-        connection.ConnectionString = builder.ConnectionString;
-        var exception = Assert.Throws<SpannerDbException>(() => connection.Open());
-        Assert.That(exception.ErrorCode, Is.EqualTo((int) Code.DeadlineExceeded));
-    }
-
-    [Test]
-    [Ignore("OpenAsync must be implemented")]
-    public async Task OpenCancel()
-    {
-        // Close all current pools to ensure that we get a fresh pool.
-        SpannerPool.CloseSpannerLib();
-        Fixture.SpannerMock.AddOrUpdateExecutionTime(nameof(Fixture.SpannerMock.CreateSession), ExecutionTime.FromMillis(20, 0));
-        var builder = new SpannerConnectionStringBuilder
-        {
-            Host = Fixture.Host,
-            Port = (uint) Fixture.Port,
-            UsePlainText = true,
-            DataSource = "projects/project1/instances/instance1/databases/database1",
-        };
-        await using var connection = new SpannerConnection();
-        connection.ConnectionString = builder.ConnectionString;
-        var tokenSource = new CancellationTokenSource(5);
-        // TODO: Implement actual async opening of connections
-        Assert.ThrowsAsync<OperationCanceledException>(async () => await connection.OpenAsync(tokenSource.Token));
-        Assert.That(connection.State, Is.EqualTo(ConnectionState.Closed));
-    }
-    
-    [Test]
-    public void DataSourceProperty()
-    {
-        using var conn = new SpannerConnection();
-        Assert.That(conn.DataSource, Is.EqualTo(string.Empty));
-
-        var builder = new SpannerConnectionStringBuilder(ConnectionString);
-
-        conn.ConnectionString = builder.ConnectionString;
-        Assert.That(conn.DataSource, Is.EqualTo("projects/p1/instances/i1/databases/d1"));
-    }
-    
-    [Test]
-    public void SettingConnectionStringWhileOpenThrows()
-    {
-        using var conn = new SpannerConnection();
-        conn.ConnectionString = ConnectionString;
-        conn.Open();
-        Assert.That(() => conn.ConnectionString = "", Throws.Exception.TypeOf<InvalidOperationException>());
-    }
-
-    [Test]
-    public void EmptyConstructor()
-    {
-        var conn = new SpannerConnection();
-        Assert.That(conn.ConnectionTimeout, Is.EqualTo(15));
-        Assert.That(conn.ConnectionString, Is.SameAs(string.Empty));
-        Assert.That(() => conn.Open(), Throws.Exception.TypeOf<InvalidOperationException>());
-    }
-
-    [Test]
-    public void Constructor_with_null_connection_string()
-    {
-        var conn = new SpannerConnection(null);
-        Assert.That(conn.ConnectionString, Is.SameAs(string.Empty));
-        Assert.That(() => conn.Open(), Throws.Exception.TypeOf<InvalidOperationException>());
-    }
-
-    [Test]
-    public void Constructor_with_empty_connection_string()
-    {
-        var conn = new NpgsqlConnection("");
-        Assert.That(conn.ConnectionString, Is.SameAs(string.Empty));
-        Assert.That(() => conn.Open(), Throws.Exception.TypeOf<InvalidOperationException>());
-    }
 
 }