using System;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

    }

}

​

// Next prompt

// "Create unittests for the PostgresDBRepository file."

// Output:

using System.Threading;

using System.Threading.Tasks;

using Xunit;

using Moq;

using Npgsql;

using Thiccdal.Shared.Repositories;

​

namespace Thiccdal.Shared.Tests.Repositories

{

    public class PostgresDBRepositoryTests

    {

        private readonly Mock<NpgsqlConnection> _mockConnection;

        private readonly Mock<NpgsqlCommand> _mockCommand;

        private readonly Mock<NpgsqlDataReader> _mockReader;

        private readonly PostgresDBRepository _repository;

​

        public PostgresDBRepositoryTests()

        {

            _mockConnection = new Mock<NpgsqlConnection>();

            _mockCommand = new Mock<NpgsqlCommand>();

            _mockReader = new Mock<NpgsqlDataReader>();

            _repository = new PostgresDBRepository("connectionString");

​

            _mockConnection.Setup(c => c.OpenAsync(It.IsAny<CancellationToken>())).Verifiable();

            _mockConnection.Setup(c => c.CreateCommand()).Returns(_mockCommand.Object);

            _mockCommand.Setup(c => c.ExecuteReaderAsync(It.IsAny<CancellationToken>())).ReturnsAsync(_mockReader.Object);

        }

​

        [Fact]

        public async Task Get_ReturnsValue_WhenKeyExists()

        {

            // Arrange

            var expectedValue = new { Name = "Test", Value = 123 };

            var json = JsonSerializer.Serialize(expectedValue);

            _mockReader.Setup(r => r.HasRows).Returns(true);

            _mockReader.Setup(r => r.ReadAsync(It.IsAny<CancellationToken>())).ReturnsAsync(true);

            _mockReader.Setup(r => r.GetString(0)).Returns(json);

​

            // Act

            var result = await _repository.Get<object>("repoName", "key", CancellationToken.None);

​

            // Assert

            Assert.Equal(expectedValue, result);

            _mockConnection.Verify();

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@name", "repoName"), Times.Once);

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@key", "key"), Times.Once);

        }

​

        [Fact]

        public async Task Get_ReturnsNull_WhenKeyDoesNotExist()

        {

            // Arrange

            _mockReader.Setup(r => r.HasRows).Returns(false);

​

            // Act

            var result = await _repository.Get<object>("repoName", "key", CancellationToken.None);

​

            // Assert

            Assert.Null(result);

            _mockConnection.Verify();

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@name", "repoName"), Times.Once);

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@key", "key"), Times.Once);

        }

​

        [Fact]

        public async Task Set_InsertsValue_WhenKeyDoesNotExist()

        {

            // Arrange

            var value = new { Name = "Test", Value = 123 };

            var json = JsonSerializer.Serialize(value);

            _mockCommand.Setup(c => c.ExecuteNonQueryAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);

​

            // Act

            await _repository.Set("repoName", "key", value, CancellationToken.None);

​

            // Assert

            _mockConnection.Verify();

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@name", "repoName"), Times.Once);

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@key", "key"), Times.Once);

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@value", json), Times.Once);

        }

​

        [Fact]

        public async Task Set_UpdatesValue_WhenKeyExists()

        {

            // Arrange

            var value = new { Name = "Test", Value = 123 };

            var json = JsonSerializer.Serialize(value);

            _mockCommand.Setup(c => c.ExecuteNonQueryAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);

​

            // Act

            await _repository.Set("repoName", "key", value, CancellationToken.None);

​

            // Assert

            _mockConnection.Verify();

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@name", "repoName"), Times.Once);

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@key", "key"), Times.Once);

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@value", json), Times.Once);

        }

​

        [Fact]

        public async Task Remove_DeletesValue_WhenKeyExists()

        {

            // Arrange

            _mockCommand.Setup(c => c.ExecuteNonQueryAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);

​

            // Act

            await _repository.Remove("repoName", "key", CancellationToken.None);

​

            // Assert

            _mockConnection.Verify();

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@name", "repoName"), Times.Once);

            _mockCommand.Verify(c => c.Parameters.AddWithValue("@key", "key"), Times.Once);

        }

    }

}