KubeSQLServer-Operator/src/tests/OperatorTemplate.Operator.UnitTests/Services/SqlServerEndpointServiceTests.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
121
122
123
124
125
126
127
128
using k8s.Models;
using KubeOps.KubernetesClient;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Moq;
using OperatorTemplate.Operator.UnitTests.Helpers;
using SqlServerOperator.Controllers.Services;
using SqlServerOperator.Entities.V1Alpha1;
using Xunit;

namespace OperatorTemplate.Operator.UnitTests.Services;

public class SqlServerEndpointServiceTests
{
    private readonly Mock<ILogger<SqlServerEndpointService>> _mockLogger;
    private readonly Mock<IKubernetesClient> _mockK8sClient;
    private readonly Mock<IWebHostEnvironment> _mockEnvironment;
    private readonly SqlServerEndpointService _service;

    public SqlServerEndpointServiceTests()
    {
        _mockLogger = new Mock<ILogger<SqlServerEndpointService>>();
        _mockK8sClient = new Mock<IKubernetesClient>();
        _mockEnvironment = new Mock<IWebHostEnvironment>();

        _service = new SqlServerEndpointService(_mockLogger.Object, _mockK8sClient.Object, _mockEnvironment.Object);
    }

    [Fact]
    public async Task GetSqlServerEndpointAsync_WithExternalServer_ReturnsHostAndPort()
    {
        // Arrange
        var externalServer = TestDataBuilder.CreateExternalSqlServer("external-sql", "default");
        _mockK8sClient.Setup(x => x.GetAsync<V1Alpha1ExternalSQLServer>("external-sql", "default"))
            .ReturnsAsync(externalServer);

        // Act
        var result = await _service.GetSqlServerEndpointAsync("external-sql", "default");

        // Assert
        Assert.Equal("localhost,1433", result);
    }

    [Fact]
    public async Task GetSqlServerEndpointAsync_ProductionEnvironment_ReturnsHeadlessFQDN()
    {
        // Arrange
        _mockK8sClient.Setup(x => x.GetAsync<V1Alpha1ExternalSQLServer>(It.IsAny<string>(), It.IsAny<string>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer?)null);
        _mockEnvironment.Setup(x => x.EnvironmentName).Returns(Environments.Production);
        _mockK8sClient.Setup(x => x.GetAsync<V1Service>("sqlserver-service", "default"))
            .ReturnsAsync(TestDataBuilder.CreateService("sqlserver-service", "default"));

        // Act
        var result = await _service.GetSqlServerEndpointAsync("sqlserver", "default");

        // Assert
        Assert.Equal("sqlserver-headless.default.svc.cluster.local", result);
    }

    [Fact]
    public async Task GetSqlServerEndpointAsync_DevWithLoadBalancer_ReturnsExternalIP()
    {
        // Arrange
        _mockK8sClient.Setup(x => x.GetAsync<V1Alpha1ExternalSQLServer>(It.IsAny<string>(), It.IsAny<string>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer?)null);
        _mockEnvironment.Setup(x => x.EnvironmentName).Returns(Environments.Development);
        _mockK8sClient.Setup(x => x.GetAsync<V1Service>("sqlserver-service", "default"))
            .ReturnsAsync(TestDataBuilder.CreateService("sqlserver-service", "default", "LoadBalancer", "203.0.113.1"));

        // Act
        var result = await _service.GetSqlServerEndpointAsync("sqlserver", "default");

        // Assert
        Assert.Equal("203.0.113.1", result);
    }

    [Fact]
    public async Task GetSqlServerEndpointAsync_DevWithNodePort_ReturnsLocalhost()
    {
        // Arrange
        _mockK8sClient.Setup(x => x.GetAsync<V1Alpha1ExternalSQLServer>(It.IsAny<string>(), It.IsAny<string>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer?)null);
        _mockEnvironment.Setup(x => x.EnvironmentName).Returns(Environments.Development);
        _mockK8sClient.Setup(x => x.GetAsync<V1Service>("sqlserver-service", "default"))
            .ReturnsAsync(TestDataBuilder.CreateService("sqlserver-service", "default", "NodePort"));

        // Act
        var result = await _service.GetSqlServerEndpointAsync("sqlserver", "default");

        // Assert
        Assert.Equal("localhost,1434", result);
    }

    [Fact]
    public async Task GetSqlServerEndpointAsync_DevWithNoneServiceType_ReturnsHeadlessFQDN()
    {
        // Arrange
        _mockK8sClient.Setup(x => x.GetAsync<V1Alpha1ExternalSQLServer>(It.IsAny<string>(), It.IsAny<string>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer?)null);
        _mockEnvironment.Setup(x => x.EnvironmentName).Returns(Environments.Development);
        _mockK8sClient.Setup(x => x.GetAsync<V1Service>("sqlserver-service", "default"))
            .ReturnsAsync((V1Service?)null);

        // Act
        var result = await _service.GetSqlServerEndpointAsync("sqlserver", "default");

        // Assert
        Assert.Equal("sqlserver-headless.default.svc.cluster.local", result);
    }

    [Fact]
    public async Task GetSqlServerEndpointAsync_LoadBalancerWithoutIP_ThrowsException()
    {
        // Arrange
        _mockK8sClient.Setup(x => x.GetAsync<V1Alpha1ExternalSQLServer>(It.IsAny<string>(), It.IsAny<string>()))
            .ReturnsAsync((V1Alpha1ExternalSQLServer?)null);
        _mockEnvironment.Setup(x => x.EnvironmentName).Returns(Environments.Development);
        _mockK8sClient.Setup(x => x.GetAsync<V1Service>("sqlserver-service", "default"))
            .ReturnsAsync(TestDataBuilder.CreateService("sqlserver-service", "default", "LoadBalancer"));

        // Act & Assert
        var exception = await Assert.ThrowsAsync<Exception>(
            async () => await _service.GetSqlServerEndpointAsync("sqlserver", "default"));
        Assert.Contains("Unable to determine a valid SQL Server endpoint", exception.Message);
    }
}