ChatBot/ChatBot.Tests/Services/TelegramBotClientWrapperTests.cs

using ChatBot.Services;
using ChatBot.Services.Interfaces;
using ChatBot.Tests.TestUtilities;
using FluentAssertions;
using Moq;
using Telegram.Bot;
using Telegram.Bot.Types;
using Xunit;

namespace ChatBot.Tests.Services;

public class TelegramBotClientWrapperTests : UnitTestBase
{
    private readonly Mock<ITelegramBotClient> _botClientMock;

    public TelegramBotClientWrapperTests()
    {
        _botClientMock = TestDataBuilder.Mocks.CreateTelegramBotClient();
    }

    [Fact]
    public void Constructor_ShouldInitializeCorrectly()
    {
        // Arrange
        var botClient = TestDataBuilder.Mocks.CreateTelegramBotClient().Object;

        // Act
        var wrapper = new TelegramBotClientWrapper(botClient);

        // Assert
        wrapper.Should().NotBeNull();
    }

    [Fact]
    public void Constructor_ShouldNotThrow_WhenBotClientIsNull()
    {
        // Arrange
        ITelegramBotClient? botClient = null;

        // Act
        var act = () => new TelegramBotClientWrapper(botClient!);

        // Assert
        // Note: The constructor doesn't validate null input
        act.Should().NotThrow();
    }

    [Fact]
    public void Wrapper_ShouldImplementITelegramBotClientWrapper()
    {
        // Arrange & Act
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Assert
        wrapper.Should().BeAssignableTo<ITelegramBotClientWrapper>();
    }

    [Fact]
    public void Wrapper_ShouldHaveGetMeAsyncMethod()
    {
        // Act & Assert
        var method = typeof(TelegramBotClientWrapper).GetMethod("GetMeAsync");
        method.Should().NotBeNull();
        method!.ReturnType.Should().Be<Task<User>>();

        var parameters = method.GetParameters();
        parameters.Should().HaveCount(1);
        parameters[0].ParameterType.Should().Be<CancellationToken>();
        parameters[0].HasDefaultValue.Should().BeTrue();
    }

    [Fact]
    public void Wrapper_ShouldNotBeDisposable()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        // TelegramBotClientWrapper doesn't implement IDisposable
        wrapper.Should().NotBeAssignableTo<IDisposable>();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectNamespace()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().Namespace.Should().Be("ChatBot.Services");
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectAssembly()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().Assembly.GetName().Name.Should().Be("ChatBot");
    }

    [Fact]
    public void Wrapper_ShouldNotBeSealed()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().IsSealed.Should().BeFalse();
    }

    [Fact]
    public void Wrapper_ShouldNotBeAbstract()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().IsAbstract.Should().BeFalse();
    }

    [Fact]
    public void Wrapper_ShouldBePublic()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().IsPublic.Should().BeTrue();
    }

    [Fact]
    public void Wrapper_ShouldHaveSingleConstructor()
    {
        // Arrange
        var constructors = typeof(TelegramBotClientWrapper).GetConstructors();

        // Act & Assert
        constructors.Should().HaveCount(1);

        var constructor = constructors[0];
        var parameters = constructor.GetParameters();
        parameters.Should().HaveCount(1);
        parameters[0].ParameterType.Should().Be<ITelegramBotClient>();
        parameters[0].Name.Should().Be("botClient");
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectBaseType()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().BaseType.Should().Be<object>();
    }

    [Fact]
    public void Wrapper_ShouldImplementCorrectInterface()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        var interfaces = wrapper.GetType().GetInterfaces();
        interfaces.Should().Contain(typeof(ITelegramBotClientWrapper));
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectInterfaceMethods()
    {
        // Arrange
        var interfaceType = typeof(ITelegramBotClientWrapper);

        // Act
        var interfaceMethods = interfaceType.GetMethods();

        // Assert
        interfaceMethods.Should().HaveCount(1);
        interfaceMethods[0].Name.Should().Be("GetMeAsync");
        interfaceMethods[0].ReturnType.Should().Be<Task<User>>();

        var parameters = interfaceMethods[0].GetParameters();
        parameters.Should().HaveCount(1);
        parameters[0].ParameterType.Should().Be<CancellationToken>();
        parameters[0].HasDefaultValue.Should().BeTrue();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectGenericTypeArguments()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().IsGenericType.Should().BeFalse();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectTypeName()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().Name.Should().Be("TelegramBotClientWrapper");
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectFullName()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper.GetType().FullName.Should().Be("ChatBot.Services.TelegramBotClientWrapper");
    }

    [Fact]
    public void Wrapper_ShouldBeInstantiable()
    {
        // Arrange
        var botClient = TestDataBuilder.Mocks.CreateTelegramBotClient().Object;

        // Act
        var wrapper = new TelegramBotClientWrapper(botClient);

        // Assert
        wrapper.Should().NotBeNull();
        wrapper.Should().BeOfType<TelegramBotClientWrapper>();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectHashCode()
    {
        // Arrange
        var wrapper1 = new TelegramBotClientWrapper(_botClientMock.Object);
        var wrapper2 = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act
        var hash1 = wrapper1.GetHashCode();
        var hash2 = wrapper2.GetHashCode();

        // Assert
        hash1.Should().NotBe(hash2); // Different instances should have different hash codes
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectToString()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act
        var toString = wrapper.ToString();

        // Assert
        toString.Should().NotBeNull();
        toString.Should().Contain("TelegramBotClientWrapper");
    }

    [Fact]
    public void Wrapper_ShouldBeEqualOnlyToItself()
    {
        // Arrange
        var wrapper1 = new TelegramBotClientWrapper(_botClientMock.Object);
        var wrapper2 = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        wrapper1.Should().NotBe(wrapper2);
        wrapper1.Should().Be(wrapper1);
        wrapper1.Equals(wrapper1).Should().BeTrue();
        wrapper1.Equals(wrapper2).Should().BeFalse();
        wrapper1.Equals(null).Should().BeFalse();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectTypeAttributes()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);

        // Act & Assert
        var attributes = wrapper.GetType().GetCustomAttributes(false);
        attributes.Should().NotBeNull();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectMethodAttributes()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);
        var getMeMethod = wrapper.GetType().GetMethod("GetMeAsync");

        // Act & Assert
        getMeMethod.Should().NotBeNull();
        var attributes = getMeMethod!.GetCustomAttributes(false);
        attributes.Should().NotBeNull();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectParameterAttributes()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);
        var getMeMethod = wrapper.GetType().GetMethod("GetMeAsync");
        var parameters = getMeMethod!.GetParameters();

        // Act & Assert
        parameters.Should().HaveCount(1);
        var parameter = parameters[0];
        var attributes = parameter.GetCustomAttributes(false);
        attributes.Should().NotBeNull();
    }

    [Fact]
    public void Wrapper_ShouldHaveCorrectReturnTypeAttributes()
    {
        // Arrange
        var wrapper = new TelegramBotClientWrapper(_botClientMock.Object);
        var getMeMethod = wrapper.GetType().GetMethod("GetMeAsync");

        // Act & Assert
        getMeMethod.Should().NotBeNull();
        var returnType = getMeMethod!.ReturnType;
        returnType.Should().Be<Task<User>>();

        var attributes = returnType.GetCustomAttributes(false);
        attributes.Should().NotBeNull();
    }

    // Note: Tests for GetMeAsync removed because GetMe is an extension method
    // and cannot be mocked with Moq. The wrapper simply delegates to the
    // TelegramBotClient extension method, which is tested by the Telegram.Bot library itself.
}