472 lines
18 KiB
C#
472 lines
18 KiB
C#
using ChatBot.Data.Interfaces;
|
|
using ChatBot.Data.Repositories;
|
|
using ChatBot.Models.Entities;
|
|
using ChatBot.Tests.TestUtilities;
|
|
using FluentAssertions;
|
|
using Moq;
|
|
|
|
namespace ChatBot.Tests.Data.Interfaces;
|
|
|
|
public class IChatSessionRepositoryTests : UnitTestBase
|
|
{
|
|
[Fact]
|
|
public void IChatSessionRepository_ShouldHaveCorrectMethodSignatures()
|
|
{
|
|
// Arrange & Act
|
|
var interfaceType = typeof(IChatSessionRepository);
|
|
var methods = interfaceType.GetMethods();
|
|
|
|
// Assert
|
|
methods.Should().HaveCount(11);
|
|
|
|
// GetOrCreateAsync method
|
|
var getOrCreateAsyncMethod = methods.FirstOrDefault(m => m.Name == "GetOrCreateAsync");
|
|
getOrCreateAsyncMethod.Should().NotBeNull();
|
|
getOrCreateAsyncMethod!.ReturnType.Should().Be<Task<ChatSessionEntity>>();
|
|
getOrCreateAsyncMethod.GetParameters().Should().HaveCount(3);
|
|
getOrCreateAsyncMethod.GetParameters()[0].ParameterType.Should().Be<long>();
|
|
getOrCreateAsyncMethod.GetParameters()[1].ParameterType.Should().Be<string>();
|
|
getOrCreateAsyncMethod.GetParameters()[2].ParameterType.Should().Be<string>();
|
|
|
|
// GetByChatIdAsync method
|
|
var getByChatIdAsyncMethod = methods.FirstOrDefault(m => m.Name == "GetByChatIdAsync");
|
|
getByChatIdAsyncMethod.Should().NotBeNull();
|
|
getByChatIdAsyncMethod!.ReturnType.Should().Be<Task<ChatSessionEntity?>>();
|
|
getByChatIdAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
getByChatIdAsyncMethod.GetParameters()[0].ParameterType.Should().Be<long>();
|
|
|
|
// GetBySessionIdAsync method
|
|
var getBySessionIdAsyncMethod = methods.FirstOrDefault(m =>
|
|
m.Name == "GetBySessionIdAsync"
|
|
);
|
|
getBySessionIdAsyncMethod.Should().NotBeNull();
|
|
getBySessionIdAsyncMethod!.ReturnType.Should().Be<Task<ChatSessionEntity?>>();
|
|
getBySessionIdAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
getBySessionIdAsyncMethod.GetParameters()[0].ParameterType.Should().Be<string>();
|
|
|
|
// UpdateAsync method
|
|
var updateAsyncMethod = methods.FirstOrDefault(m => m.Name == "UpdateAsync");
|
|
updateAsyncMethod.Should().NotBeNull();
|
|
updateAsyncMethod!.ReturnType.Should().Be<Task<ChatSessionEntity>>();
|
|
updateAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
updateAsyncMethod.GetParameters()[0].ParameterType.Should().Be<ChatSessionEntity>();
|
|
|
|
// DeleteAsync method
|
|
var deleteAsyncMethod = methods.FirstOrDefault(m => m.Name == "DeleteAsync");
|
|
deleteAsyncMethod.Should().NotBeNull();
|
|
deleteAsyncMethod!.ReturnType.Should().Be<Task<bool>>();
|
|
deleteAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
deleteAsyncMethod.GetParameters()[0].ParameterType.Should().Be<long>();
|
|
|
|
// GetMessagesAsync method
|
|
var getMessagesAsyncMethod = methods.FirstOrDefault(m => m.Name == "GetMessagesAsync");
|
|
getMessagesAsyncMethod.Should().NotBeNull();
|
|
getMessagesAsyncMethod!.ReturnType.Should().Be<Task<List<ChatMessageEntity>>>();
|
|
getMessagesAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
getMessagesAsyncMethod.GetParameters()[0].ParameterType.Should().Be<int>();
|
|
|
|
// AddMessageAsync method
|
|
var addMessageAsyncMethod = methods.FirstOrDefault(m => m.Name == "AddMessageAsync");
|
|
addMessageAsyncMethod.Should().NotBeNull();
|
|
addMessageAsyncMethod!.ReturnType.Should().Be<Task<ChatMessageEntity>>();
|
|
addMessageAsyncMethod.GetParameters().Should().HaveCount(4);
|
|
addMessageAsyncMethod.GetParameters()[0].ParameterType.Should().Be<int>();
|
|
addMessageAsyncMethod.GetParameters()[1].ParameterType.Should().Be<string>();
|
|
addMessageAsyncMethod.GetParameters()[2].ParameterType.Should().Be<string>();
|
|
addMessageAsyncMethod.GetParameters()[3].ParameterType.Should().Be<int>();
|
|
|
|
// ClearMessagesAsync method
|
|
var clearMessagesAsyncMethod = methods.FirstOrDefault(m => m.Name == "ClearMessagesAsync");
|
|
clearMessagesAsyncMethod.Should().NotBeNull();
|
|
clearMessagesAsyncMethod!.ReturnType.Should().Be<Task>();
|
|
clearMessagesAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
clearMessagesAsyncMethod.GetParameters()[0].ParameterType.Should().Be<int>();
|
|
|
|
// GetActiveSessionsCountAsync method
|
|
var getActiveSessionsCountAsyncMethod = methods.FirstOrDefault(m =>
|
|
m.Name == "GetActiveSessionsCountAsync"
|
|
);
|
|
getActiveSessionsCountAsyncMethod.Should().NotBeNull();
|
|
getActiveSessionsCountAsyncMethod!.ReturnType.Should().Be<Task<int>>();
|
|
getActiveSessionsCountAsyncMethod.GetParameters().Should().BeEmpty();
|
|
|
|
// CleanupOldSessionsAsync method
|
|
var cleanupOldSessionsAsyncMethod = methods.FirstOrDefault(m =>
|
|
m.Name == "CleanupOldSessionsAsync"
|
|
);
|
|
cleanupOldSessionsAsyncMethod.Should().NotBeNull();
|
|
cleanupOldSessionsAsyncMethod!.ReturnType.Should().Be<Task<int>>();
|
|
cleanupOldSessionsAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
cleanupOldSessionsAsyncMethod.GetParameters()[0].ParameterType.Should().Be<int>();
|
|
|
|
// GetSessionsForCleanupAsync method
|
|
var getSessionsForCleanupAsyncMethod = methods.FirstOrDefault(m =>
|
|
m.Name == "GetSessionsForCleanupAsync"
|
|
);
|
|
getSessionsForCleanupAsyncMethod.Should().NotBeNull();
|
|
getSessionsForCleanupAsyncMethod!.ReturnType.Should().Be<Task<List<ChatSessionEntity>>>();
|
|
getSessionsForCleanupAsyncMethod.GetParameters().Should().HaveCount(1);
|
|
getSessionsForCleanupAsyncMethod.GetParameters()[0].ParameterType.Should().Be<int>();
|
|
}
|
|
|
|
[Fact]
|
|
public void IChatSessionRepository_ShouldBeImplementedByChatSessionRepository()
|
|
{
|
|
// Arrange & Act
|
|
var chatSessionRepositoryType = typeof(ChatSessionRepository);
|
|
var interfaceType = typeof(IChatSessionRepository);
|
|
|
|
// Assert
|
|
interfaceType.IsAssignableFrom(chatSessionRepositoryType).Should().BeTrue();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetOrCreateAsync_ShouldReturnChatSessionEntity()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var chatId = 12345L;
|
|
var chatType = "private";
|
|
var chatTitle = "Test Chat";
|
|
var expectedSession = TestDataBuilder.Mocks.CreateChatSessionEntity();
|
|
|
|
mock.Setup(x =>
|
|
x.GetOrCreateAsync(It.IsAny<long>(), It.IsAny<string>(), It.IsAny<string>())
|
|
)
|
|
.ReturnsAsync(expectedSession);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetOrCreateAsync(chatId, chatType, chatTitle);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedSession);
|
|
mock.Verify(x => x.GetOrCreateAsync(chatId, chatType, chatTitle), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetOrCreateAsync_ShouldUseDefaultValues()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var chatId = 12345L;
|
|
var expectedSession = TestDataBuilder.Mocks.CreateChatSessionEntity();
|
|
|
|
mock.Setup(x =>
|
|
x.GetOrCreateAsync(It.IsAny<long>(), It.IsAny<string>(), It.IsAny<string>())
|
|
)
|
|
.ReturnsAsync(expectedSession);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetOrCreateAsync(chatId);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedSession);
|
|
mock.Verify(x => x.GetOrCreateAsync(chatId, "private", ""), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetByChatIdAsync_ShouldReturnChatSessionEntityOrNull()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var chatId = 12345L;
|
|
var expectedSession = TestDataBuilder.Mocks.CreateChatSessionEntity();
|
|
|
|
mock.Setup(x => x.GetByChatIdAsync(It.IsAny<long>())).ReturnsAsync(expectedSession);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetByChatIdAsync(chatId);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedSession);
|
|
mock.Verify(x => x.GetByChatIdAsync(chatId), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetByChatIdAsync_ShouldReturnNullWhenNotFound()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var chatId = 12345L;
|
|
|
|
mock.Setup(x => x.GetByChatIdAsync(It.IsAny<long>()))
|
|
.ReturnsAsync((ChatSessionEntity?)null);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetByChatIdAsync(chatId);
|
|
|
|
// Assert
|
|
result.Should().BeNull();
|
|
mock.Verify(x => x.GetByChatIdAsync(chatId), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetBySessionIdAsync_ShouldReturnChatSessionEntityOrNull()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var sessionId = "test-session-id";
|
|
var expectedSession = TestDataBuilder.Mocks.CreateChatSessionEntity();
|
|
|
|
mock.Setup(x => x.GetBySessionIdAsync(It.IsAny<string>())).ReturnsAsync(expectedSession);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetBySessionIdAsync(sessionId);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedSession);
|
|
mock.Verify(x => x.GetBySessionIdAsync(sessionId), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_UpdateAsync_ShouldReturnUpdatedChatSessionEntity()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var session = TestDataBuilder.Mocks.CreateChatSessionEntity();
|
|
var expectedUpdatedSession = TestDataBuilder.Mocks.CreateChatSessionEntity();
|
|
|
|
mock.Setup(x => x.UpdateAsync(It.IsAny<ChatSessionEntity>()))
|
|
.ReturnsAsync(expectedUpdatedSession);
|
|
|
|
// Act
|
|
var result = await mock.Object.UpdateAsync(session);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedUpdatedSession);
|
|
mock.Verify(x => x.UpdateAsync(session), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_DeleteAsync_ShouldReturnBoolean()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var chatId = 12345L;
|
|
var expectedResult = true;
|
|
|
|
mock.Setup(x => x.DeleteAsync(It.IsAny<long>())).ReturnsAsync(expectedResult);
|
|
|
|
// Act
|
|
var result = await mock.Object.DeleteAsync(chatId);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedResult);
|
|
mock.Verify(x => x.DeleteAsync(chatId), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetMessagesAsync_ShouldReturnListOfMessages()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var sessionId = 1;
|
|
var expectedMessages = new List<ChatMessageEntity>
|
|
{
|
|
TestDataBuilder.Mocks.CreateChatMessageEntity(),
|
|
TestDataBuilder.Mocks.CreateChatMessageEntity(),
|
|
};
|
|
|
|
mock.Setup(x => x.GetMessagesAsync(It.IsAny<int>())).ReturnsAsync(expectedMessages);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetMessagesAsync(sessionId);
|
|
|
|
// Assert
|
|
result.Should().BeEquivalentTo(expectedMessages);
|
|
mock.Verify(x => x.GetMessagesAsync(sessionId), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_AddMessageAsync_ShouldReturnChatMessageEntity()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var sessionId = 1;
|
|
var content = "Test message";
|
|
var role = "user";
|
|
var messageOrder = 1;
|
|
var expectedMessage = TestDataBuilder.Mocks.CreateChatMessageEntity();
|
|
|
|
mock.Setup(x =>
|
|
x.AddMessageAsync(
|
|
It.IsAny<int>(),
|
|
It.IsAny<string>(),
|
|
It.IsAny<string>(),
|
|
It.IsAny<int>()
|
|
)
|
|
)
|
|
.ReturnsAsync(expectedMessage);
|
|
|
|
// Act
|
|
var result = await mock.Object.AddMessageAsync(sessionId, content, role, messageOrder);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedMessage);
|
|
mock.Verify(x => x.AddMessageAsync(sessionId, content, role, messageOrder), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_ClearMessagesAsync_ShouldReturnTask()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var sessionId = 1;
|
|
|
|
mock.Setup(x => x.ClearMessagesAsync(It.IsAny<int>())).Returns(Task.CompletedTask);
|
|
|
|
// Act
|
|
await mock.Object.ClearMessagesAsync(sessionId);
|
|
|
|
// Assert
|
|
mock.Verify(x => x.ClearMessagesAsync(sessionId), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetActiveSessionsCountAsync_ShouldReturnInt()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var expectedCount = 5;
|
|
|
|
mock.Setup(x => x.GetActiveSessionsCountAsync()).ReturnsAsync(expectedCount);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetActiveSessionsCountAsync();
|
|
|
|
// Assert
|
|
result.Should().Be(expectedCount);
|
|
mock.Verify(x => x.GetActiveSessionsCountAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_CleanupOldSessionsAsync_ShouldReturnInt()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var hoursOld = 24;
|
|
var expectedCleanedCount = 3;
|
|
|
|
mock.Setup(x => x.CleanupOldSessionsAsync(It.IsAny<int>()))
|
|
.ReturnsAsync(expectedCleanedCount);
|
|
|
|
// Act
|
|
var result = await mock.Object.CleanupOldSessionsAsync(hoursOld);
|
|
|
|
// Assert
|
|
result.Should().Be(expectedCleanedCount);
|
|
mock.Verify(x => x.CleanupOldSessionsAsync(hoursOld), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_CleanupOldSessionsAsync_ShouldUseDefaultValue()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var expectedCleanedCount = 2;
|
|
|
|
mock.Setup(x => x.CleanupOldSessionsAsync(It.IsAny<int>()))
|
|
.ReturnsAsync(expectedCleanedCount);
|
|
|
|
// Act
|
|
var result = await mock.Object.CleanupOldSessionsAsync();
|
|
|
|
// Assert
|
|
result.Should().Be(expectedCleanedCount);
|
|
mock.Verify(x => x.CleanupOldSessionsAsync(24), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetSessionsForCleanupAsync_ShouldReturnListOfSessions()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var hoursOld = 24;
|
|
var expectedSessions = new List<ChatSessionEntity>
|
|
{
|
|
TestDataBuilder.Mocks.CreateChatSessionEntity(),
|
|
TestDataBuilder.Mocks.CreateChatSessionEntity(),
|
|
};
|
|
|
|
mock.Setup(x => x.GetSessionsForCleanupAsync(It.IsAny<int>()))
|
|
.ReturnsAsync(expectedSessions);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetSessionsForCleanupAsync(hoursOld);
|
|
|
|
// Assert
|
|
result.Should().BeEquivalentTo(expectedSessions);
|
|
mock.Verify(x => x.GetSessionsForCleanupAsync(hoursOld), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IChatSessionRepository_GetSessionsForCleanupAsync_ShouldUseDefaultValue()
|
|
{
|
|
// Arrange
|
|
var mock = new Mock<IChatSessionRepository>();
|
|
var expectedSessions = new List<ChatSessionEntity>();
|
|
|
|
mock.Setup(x => x.GetSessionsForCleanupAsync(It.IsAny<int>()))
|
|
.ReturnsAsync(expectedSessions);
|
|
|
|
// Act
|
|
var result = await mock.Object.GetSessionsForCleanupAsync();
|
|
|
|
// Assert
|
|
result.Should().BeEquivalentTo(expectedSessions);
|
|
mock.Verify(x => x.GetSessionsForCleanupAsync(24), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public void IChatSessionRepository_ShouldBePublicInterface()
|
|
{
|
|
// Arrange & Act
|
|
var interfaceType = typeof(IChatSessionRepository);
|
|
|
|
// Assert
|
|
interfaceType.IsPublic.Should().BeTrue();
|
|
interfaceType.IsInterface.Should().BeTrue();
|
|
}
|
|
|
|
[Fact]
|
|
public void IChatSessionRepository_ShouldHaveCorrectNamespace()
|
|
{
|
|
// Arrange & Act
|
|
var interfaceType = typeof(IChatSessionRepository);
|
|
|
|
// Assert
|
|
interfaceType.Namespace.Should().Be("ChatBot.Data.Interfaces");
|
|
}
|
|
|
|
[Fact]
|
|
public void IChatSessionRepository_ShouldHaveCorrectGenericConstraints()
|
|
{
|
|
// Arrange & Act
|
|
var interfaceType = typeof(IChatSessionRepository);
|
|
var methods = interfaceType.GetMethods();
|
|
|
|
// Assert
|
|
// All methods should be public
|
|
methods.All(m => m.IsPublic).Should().BeTrue();
|
|
|
|
// GetOrCreateAsync should have default parameters
|
|
var getOrCreateAsyncMethod = methods.First(m => m.Name == "GetOrCreateAsync");
|
|
getOrCreateAsyncMethod.GetParameters()[1].HasDefaultValue.Should().BeTrue();
|
|
getOrCreateAsyncMethod.GetParameters()[1].DefaultValue.Should().Be("private");
|
|
getOrCreateAsyncMethod.GetParameters()[2].HasDefaultValue.Should().BeTrue();
|
|
getOrCreateAsyncMethod.GetParameters()[2].DefaultValue.Should().Be("");
|
|
|
|
// CleanupOldSessionsAsync should have default parameter
|
|
var cleanupOldSessionsAsyncMethod = methods.First(m => m.Name == "CleanupOldSessionsAsync");
|
|
cleanupOldSessionsAsyncMethod.GetParameters()[0].HasDefaultValue.Should().BeTrue();
|
|
cleanupOldSessionsAsyncMethod.GetParameters()[0].DefaultValue.Should().Be(24);
|
|
|
|
// GetSessionsForCleanupAsync should have default parameter
|
|
var getSessionsForCleanupAsyncMethod = methods.First(m =>
|
|
m.Name == "GetSessionsForCleanupAsync"
|
|
);
|
|
getSessionsForCleanupAsyncMethod.GetParameters()[0].HasDefaultValue.Should().BeTrue();
|
|
getSessionsForCleanupAsyncMethod.GetParameters()[0].DefaultValue.Should().Be(24);
|
|
}
|
|
}
|