NCO-58: Add more functional testing

- Add scope-level streaming and blocking tests for the sync API
- Add scope-level end-to-end test for the async API (start→poll→fetch)
- Add async metadata verification test at cluster level
- Provision bare dataverse in CI workflow for scope-level queries

Author: davidkelly

.github/workflows/functional-tests.yml

@@ -179,6 +179,15 @@ jobs:
           EOF
           echo "settings.json written:" && cat tests/Couchbase.Analytics.FunctionalTests/settings.json
 
+      - name: Create test dataverse for scope-level queries
+        run: |
+          echo "Creating test dataverse testdb.testscope for scope-level functional tests"
+          curl -sSf -k -u "${CBDINO_USER}:${CBDINO_PASS}" \
+            "${CBDINO_CONNSTR}/api/v1/request" \
+            --data-urlencode 'statement=CREATE DATAVERSE testdb.testscope IF NOT EXISTS;'
+          echo ""
+          echo "Dataverse created successfully"
+
       - name: Build and Run Functional Tests
         run: |
           dotnet test tests/Couchbase.Analytics.FunctionalTests/Couchbase.Analytics.FunctionalTests.csproj \

tests/Couchbase.Analytics.FunctionalTests/AsyncAnalyticsTests.cs

@@ -144,4 +144,94 @@ await Assert.ThrowsAsync<QueryNotFoundException>(async () =>
             await resultHandle.FetchResultsAsync(new FetchResultsOptions());
         });
     }
+
+    [Fact]
+    public async Task Test_AsyncAnalytics_EndToEnd_Scope()
+    {
+        var statement = "select i from array_range(1, 10) as i;";
+        var queryOptions = new StartQueryOptions()
+        {
+            QueryTimeout = TimeSpan.FromSeconds(30)
+        };
+
+        // 1. Start the query via scope
+        var handle = await _simpleFixture.TestScope.StartQueryAsync(statement, queryOptions);
+        Assert.NotNull(handle);
+
+        // 2. Poll for the query status
+        QueryStatus? queryStatus = null;
+        for (var i = 0; i < 20; i++)
+        {
+            queryStatus = await handle.FetchStatusAsync(new FetchStatusOptions());
+            if (queryStatus.ResultsReady)
+            {
+                break;
+            }
+            await Task.Delay(500);
+        }
+
+        Assert.NotNull(queryStatus);
+        Assert.True(queryStatus!.ResultsReady);
+
+        // 3. Fetch results
+        var resultHandle = queryStatus.ResultHandle();
+        Assert.NotNull(resultHandle);
+
+        var results = await resultHandle.FetchResultsAsync(new FetchResultsOptions());
+        Assert.NotNull(results);
+
+        var count = 0;
+        await foreach (var row in results.Rows)
+        {
+            count++;
+        }
+
+        Assert.Equal(9, count);
+        Assert.Equal(9, results.MetaData.Metrics?.ResultCount);
+    }
+
+    [Fact]
+    public async Task Test_AsyncAnalytics_Metadata_Cluster()
+    {
+        var statement = "select i from array_range(1, 100) as i;";
+        var queryOptions = new StartQueryOptions()
+        {
+            QueryTimeout = TimeSpan.FromSeconds(30)
+        };
+
+        var handle = await _simpleFixture.Cluster.StartQueryAsync(statement, queryOptions);
+        Assert.NotNull(handle);
+
+        QueryStatus? queryStatus = null;
+        for (var i = 0; i < 20; i++)
+        {
+            queryStatus = await handle.FetchStatusAsync(new FetchStatusOptions());
+            _outputHelper.WriteLine($"Status: {queryStatus}");
+            if (queryStatus.ResultsReady)
+            {
+                break;
+            }
+            await Task.Delay(500);
+        }
+
+        Assert.NotNull(queryStatus);
+        Assert.True(queryStatus!.ResultsReady);
+
+        var resultHandle = queryStatus.ResultHandle();
+        var results = await resultHandle.FetchResultsAsync(new FetchResultsOptions());
+
+        // Consume all rows
+        var count = 0;
+        await foreach (var row in results.Rows)
+        {
+            count++;
+        }
+
+        // Verify metrics
+        Assert.NotNull(results.MetaData);
+        Assert.NotNull(results.MetaData.Metrics);
+        Assert.Equal(99, results.MetaData.Metrics!.ResultCount);
+        Assert.NotNull(results.MetaData.Metrics.ElapsedTime);
+        Assert.NotNull(results.MetaData.Metrics.ExecutionTime);
+    }
 }

tests/Couchbase.Analytics.FunctionalTests/Fixtures/FixtureSettings.cs

@@ -36,4 +36,10 @@ public class FixtureSettings
 
     [JsonPropertyName("ClientKeyPath2")]
     public string? ClientKeyPath2 { get; set; }
+
+    [JsonPropertyName("TestDatabase")]
+    public string TestDatabase { get; set; } = "testdb";
+
+    [JsonPropertyName("TestScope")]
+    public string TestScope { get; set; } = "testscope";
 }

tests/Couchbase.Analytics.FunctionalTests/Fixtures/SimpleFixture.cs

@@ -20,6 +20,8 @@ public SimpleFixture()
 
         public Credential Credential { get; private set; }
 
+        public Scope TestScope => Cluster.Database(FixtureSettings.TestDatabase).Scope(FixtureSettings.TestScope);
+
         public string CapellaCaCert =
             "-----BEGIN CERTIFICATE-----\n" +
             "MIIFWzCCA0OgAwIBAgIBATANBgkqhkiG9w0BAQsFADA4MTYwNAYDVQQDEy1kaW5v\n" +

tests/Couchbase.Analytics.FunctionalTests/Internal/AnalyticsServiceTests.cs

@@ -153,4 +153,40 @@ public async Task Test_Cancellation_Works_Blocking()
 
         await Assert.ThrowsAsync<AnalyticsTimeoutException>(async () => await task.ConfigureAwait(false));
     }
+
+    [Fact]
+    public async Task Test_Streaming_Query_Scope()
+    {
+        var statement = "select i from array_range(1, 10) as i;";
+
+        var result = await _simpleFixture.TestScope.ExecuteQueryAsync(statement,
+            new QueryOptions() { Timeout = TimeSpan.FromSeconds(10), AsStreaming = true });
+
+        var count = 0;
+        await foreach (var row in result.Rows)
+        {
+            count++;
+        }
+
+        Assert.Equal(9, count);
+        Assert.Equal(9, result.MetaData.Metrics!.ResultCount);
+    }
+
+    [Fact]
+    public async Task Test_Blocking_Query_Scope()
+    {
+        var statement = "select i from array_range(1, 10) as i;";
+
+        var result = await _simpleFixture.TestScope.ExecuteQueryAsync(statement,
+            new QueryOptions() { Timeout = TimeSpan.FromSeconds(10), AsStreaming = false });
+
+        var count = 0;
+        await foreach (var row in result.Rows)
+        {
+            count++;
+        }
+
+        Assert.Equal(9, count);
+        Assert.Equal(9, result.MetaData.Metrics!.ResultCount);
+    }
 }