codecov update

Author: MPCoreDeveloper

tests/SharpCoreDB.Tests/Client/SharpCoreDBDataReaderTests.cs

@@ -0,0 +1,81 @@
+using Grpc.Core;
+using SharpCoreDB.Client;
+using SharpCoreDB.Server.Protocol;
+
+namespace SharpCoreDB.Tests.Client;
+
+public sealed class SharpCoreDBDataReaderTests
+{
+    [Fact]
+    public async Task ReadAsync_WhenReaderIsClosed_ShouldReturnFalse()
+    {
+        // Arrange
+        var stream = new FakeAsyncStreamReader();
+        await using var reader = new SharpCoreDBDataReader(stream, CancellationToken.None);
+        reader.Close();
+
+        // Act
+        var result = await reader.ReadAsync();
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task ReadAsync_WhenFirstResponseHasRows_ShouldReturnTrue()
+    {
+        // Arrange
+        var response = new QueryResponse();
+        response.Columns.Add(new ColumnMetadata { Name = "Id", Type = SharpCoreDB.Server.Protocol.DataType.Integer });
+        var row = new RowData();
+        row.Values.Add(new ParameterValue { IntValue = 123 });
+        response.Rows.Add(row);
+
+        var stream = new FakeAsyncStreamReader(response);
+        await using var reader = new SharpCoreDBDataReader(stream, CancellationToken.None);
+
+        // Act
+        var result = await reader.ReadAsync();
+
+        // Assert
+        Assert.True(result);
+        Assert.Equal(123, reader.GetInt32(0));
+    }
+
+    [Fact]
+    public async Task ReadAsync_WhenNoResponses_ShouldReturnFalse()
+    {
+        // Arrange
+        var stream = new FakeAsyncStreamReader();
+        await using var reader = new SharpCoreDBDataReader(stream, CancellationToken.None);
+
+        // Act
+        var result = await reader.ReadAsync();
+
+        // Assert
+        Assert.False(result);
+    }
+
+    private sealed class FakeAsyncStreamReader : IAsyncStreamReader<QueryResponse>
+    {
+        private readonly Queue<QueryResponse> _responses;
+
+        public FakeAsyncStreamReader(params QueryResponse[] responses)
+        {
+            _responses = new Queue<QueryResponse>(responses);
+        }
+
+        public QueryResponse Current { get; private set; } = new();
+
+        public Task<bool> MoveNext(CancellationToken cancellationToken)
+        {
+            if (_responses.Count == 0)
+            {
+                return Task.FromResult(false);
+            }
+
+            Current = _responses.Dequeue();
+            return Task.FromResult(true);
+        }
+    }
+}

tests/SharpCoreDB.Tests/DataProvider/SharpCoreDBConnectionAndParameterTests.cs

@@ -0,0 +1,45 @@
+using SharpCoreDB.Data.Provider;
+
+namespace SharpCoreDB.Tests.DataProvider;
+
+public sealed class SharpCoreDBConnectionAndParameterTests
+{
+    [Fact]
+    public void ConnectionString_WhenSetNull_ShouldBecomeEmptyString()
+    {
+        // Arrange
+        using var connection = new SharpCoreDBConnection();
+
+        // Act
+        connection.ConnectionString = null;
+
+        // Assert
+        Assert.Equal(string.Empty, connection.ConnectionString);
+    }
+
+    [Fact]
+    public void ParameterName_WhenSetNull_ShouldKeepNullAssignmentSafe()
+    {
+        // Arrange
+        var parameter = new SharpCoreDBParameter();
+
+        // Act
+        parameter.ParameterName = null;
+
+        // Assert
+        Assert.Null(parameter.ParameterName);
+    }
+
+    [Fact]
+    public void SourceColumn_WhenSetNull_ShouldKeepNullAssignmentSafe()
+    {
+        // Arrange
+        var parameter = new SharpCoreDBParameter();
+
+        // Act
+        parameter.SourceColumn = null;
+
+        // Assert
+        Assert.Null(parameter.SourceColumn);
+    }
+}

tests/SharpCoreDB.Tests/Services/CompiledQueryExecutorTests.cs

@@ -0,0 +1,55 @@
+using Moq;
+using SharpCoreDB.DataStructures;
+using SharpCoreDB.Interfaces;
+using SharpCoreDB.Services;
+
+namespace SharpCoreDB.Tests.QueryExecution;
+
+public sealed class CompiledQueryExecutorTests
+{
+    [Fact]
+    public void Execute_WithIndexedProjectionNullValue_ShouldProjectDBNull()
+    {
+        // Arrange
+        var rows = new List<Dictionary<string, object>>
+        {
+            new() { ["Name"] = "Alice" }
+        };
+
+        var tableMock = new Mock<ITable>();
+        tableMock.Setup(t => t.Select(null, null, true)).Returns(rows);
+
+        var tables = new Dictionary<string, ITable>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["Users"] = tableMock.Object,
+        };
+
+        var executor = new CompiledQueryExecutor(tables);
+
+        var plan = new CompiledQueryPlan(
+            sql: "SELECT Missing FROM Users",
+            tableName: "Users",
+            selectColumns: ["Missing"],
+            isSelectAll: false,
+            whereFilter: null,
+            whereFilterIndexed: null,
+            projectionFunc: static row => new Dictionary<string, object>(row),
+            orderByColumn: null,
+            orderByAscending: true,
+            limit: null,
+            offset: null,
+            parameterNames: [],
+            optimizedPlan: null,
+            optimizedCost: 0,
+            columnIndices: new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase) { ["Name"] = 0, ["Missing"] = 1 },
+            useDirectColumnAccess: true);
+
+        // Act
+        var result = executor.Execute(plan);
+
+        // Assert
+        Assert.Single(result);
+        Assert.True(result[0].ContainsKey("Missing"));
+        Assert.Equal(DBNull.Value, result[0]["Missing"]);
+    }
+}

tests/SharpCoreDB.Tests/SharpCoreDB.Tests.csproj

@@ -39,6 +39,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\SharpCoreDB\SharpCoreDB.csproj" />
+    <ProjectReference Include="..\..\src\SharpCoreDB.Client\SharpCoreDB.Client.csproj" />
     <ProjectReference Include="..\..\src\SharpCoreDB.Data.Provider\SharpCoreDB.Data.Provider.csproj" />
     <ProjectReference Include="..\..\src\SharpCoreDB.Functional\SharpCoreDB.Functional.csproj" />
     <ProjectReference Include="..\..\src\SharpCoreDB.Distributed\SharpCoreDB.Distributed.csproj" />