KubeSQLServer-Operator/src/tests/OperatorTemplate.Operator.UnitTests/Controllers/ExternalSqlServerControllerTests.cs at 7e2c29e2d96c92436acb2e0b95139db7322a76fc · DotKube/KubeSQLServer-Operator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
using k8s.Models;
using KubeOps.KubernetesClient;
using Microsoft.Extensions.Logging;
using Moq;
using OperatorTemplate.Operator.UnitTests.Helpers;
using SqlServerOperator.Controllers.Services;
using SqlServerOperator.Controllers.V1Alpha1;
using SqlServerOperator.Entities.V1Alpha1;
using Xunit;

namespace OperatorTemplate.Operator.UnitTests.Controllers;

public class ExternalSqlServerControllerTests
{
    private readonly Mock<ILogger<ExternalSQLServerController>> _mockLogger;
    private readonly Mock<IKubernetesClient> _mockK8sClient;
    private readonly Mock<ISqlExecutor> _mockSqlExecutor;
    private readonly ExternalSQLServerController _controller;

    public ExternalSqlServerControllerTests()
    {
        _mockLogger = new Mock<ILogger<ExternalSQLServerController>>();
        _mockK8sClient = new Mock<IKubernetesClient>();
        _mockSqlExecutor = new Mock<ISqlExecutor>();

        _controller = new ExternalSQLServerController(
            _mockLogger.Object,
            _mockK8sClient.Object,
            _mockSqlExecutor.Object);
    }

    [Fact]
    public async Task ReconcileAsync_WithValidConnection_VerifiesSuccessfully()
    {
        // Arrange
        var entity = TestDataBuilder.CreateExternalSqlServer("external-sql", "default");
        var secret = TestDataBuilder.CreateSecret("external-secret", "default", "TestPass123!", "sa");

        _mockK8sClient.Setup(x => x.GetAsync<V1Secret>("external-secret", "default"))
            .ReturnsAsync(secret);
        _mockSqlExecutor.Setup(x => x.ExecuteScalarAsync<string>(It.IsAny<string>(), "SELECT @@VERSION", null))
            .ReturnsAsync("Microsoft SQL Server 2022");
        _mockK8sClient.Setup(x => x.UpdateStatusAsync(It.IsAny<V1Alpha1ExternalSQLServer>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer e, CancellationToken ct) => e);

        // Act
        var result = await _controller.ReconcileAsync(entity, CancellationToken.None);

        // Assert
        Assert.NotNull(result);
        Assert.Equal("Ready", entity.Status?.State);
        Assert.Equal("Connection verified successfully.", entity.Status?.Message);
        Assert.True(entity.Status?.IsConnected);
        _mockSqlExecutor.Verify(x => x.ExecuteScalarAsync<string>(
            It.IsAny<string>(),
            "SELECT @@VERSION",
            null),
            Times.Once);
    }

    [Fact]
    public async Task ReconcileAsync_WhenSecretMissing_ReturnsFailure()
    {
        // Arrange
        var entity = TestDataBuilder.CreateExternalSqlServer("external-sql", "default");

        _mockK8sClient.Setup(x => x.GetAsync<V1Secret>("external-secret", "default"))
            .ReturnsAsync((V1Secret?)null);
        _mockK8sClient.Setup(x => x.UpdateStatusAsync(It.IsAny<V1Alpha1ExternalSQLServer>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer e, CancellationToken ct) => e);

        // Act
        var result = await _controller.ReconcileAsync(entity, CancellationToken.None);

        // Assert
        Assert.Equal("Error", entity.Status?.State);
        Assert.False(entity.Status?.IsConnected);
        _mockSqlExecutor.Verify(x => x.ExecuteScalarAsync<string>(
            It.IsAny<string>(),
            It.IsAny<string>(),
            It.IsAny<Dictionary<string, object>>()),
            Times.Never);
    }

    [Fact]
    public async Task ReconcileAsync_WhenConnectionFails_ReturnsFailure()
    {
        // Arrange
        var entity = TestDataBuilder.CreateExternalSqlServer("external-sql", "default");
        var secret = TestDataBuilder.CreateSecret("external-secret", "default", "TestPass123!");

        _mockK8sClient.Setup(x => x.GetAsync<V1Secret>("external-secret", "default"))
            .ReturnsAsync(secret);
        _mockSqlExecutor.Setup(x => x.ExecuteScalarAsync<string>(It.IsAny<string>(), "SELECT @@VERSION", null))
            .ThrowsAsync(new Exception("Connection timeout"));
        _mockK8sClient.Setup(x => x.UpdateStatusAsync(It.IsAny<V1Alpha1ExternalSQLServer>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer e, CancellationToken ct) => e);

        // Act
        var result = await _controller.ReconcileAsync(entity, CancellationToken.None);

        // Assert
        Assert.Equal("Error", entity.Status?.State);
        Assert.Contains("Connection timeout", entity.Status?.Message);
        Assert.False(entity.Status?.IsConnected);
    }

    [Fact]
    public async Task DeletedAsync_ReturnsSuccess()
    {
        // Arrange
        var entity = TestDataBuilder.CreateExternalSqlServer();

        // Act
        var result = await _controller.DeletedAsync(entity, CancellationToken.None);

        // Assert
        Assert.NotNull(result);
    }
}