add tests

ChatBot.Tests/Services/DatabaseSessionStorageTests.cs

@@ -176,4 +176,265 @@ public class DatabaseSessionStorageTests : TestBase
         result.Should().Be(expectedCount);
         _repositoryMock.Verify(x => x.CleanupOldSessionsAsync(24), Times.Once);
     }
+
+    [Fact]
+    public void GetOrCreate_ShouldThrowInvalidOperationException_WhenRepositoryThrows()
+    {
+        // Arrange
+        _repositoryMock
+            .Setup(x => x.GetOrCreateAsync(12345, "private", "Test Chat"))
+            .ThrowsAsync(new Exception("Database error"));
+
+        // Act
+        var act = () => _sessionStorage.GetOrCreate(12345, "private", "Test Chat");
+
+        // Assert
+        act.Should()
+            .Throw<InvalidOperationException>()
+            .WithMessage("Failed to get or create session for chat 12345")
+            .WithInnerException<Exception>()
+            .WithMessage("Database error");
+    }
+
+    [Fact]
+    public void Get_ShouldReturnNull_WhenRepositoryThrows()
+    {
+        // Arrange
+        _repositoryMock
+            .Setup(x => x.GetByChatIdAsync(12345))
+            .ThrowsAsync(new Exception("Database error"));
+
+        // Act
+        var result = _sessionStorage.Get(12345);
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Fact]
+    public async Task SaveSessionAsync_ShouldLogWarning_WhenSessionNotFound()
+    {
+        // Arrange
+        var session = TestDataBuilder.ChatSessions.CreateBasicSession(12345, "private");
+        _repositoryMock
+            .Setup(x => x.GetByChatIdAsync(12345))
+            .ReturnsAsync((ChatSessionEntity?)null);
+
+        // Act
+        await _sessionStorage.SaveSessionAsync(session);
+
+        // Assert
+        _repositoryMock.Verify(x => x.GetByChatIdAsync(12345), Times.Once);
+        _repositoryMock.Verify(x => x.UpdateAsync(It.IsAny<ChatSessionEntity>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task SaveSessionAsync_ShouldThrowInvalidOperationException_WhenRepositoryThrows()
+    {
+        // Arrange
+        var session = TestDataBuilder.ChatSessions.CreateBasicSession(12345, "private");
+        _repositoryMock
+            .Setup(x => x.GetByChatIdAsync(12345))
+            .ThrowsAsync(new Exception("Database error"));
+
+        // Act
+        var act = async () => await _sessionStorage.SaveSessionAsync(session);
+
+        // Assert
+        var exception = await act.Should()
+            .ThrowAsync<InvalidOperationException>()
+            .WithMessage("Failed to save session for chat 12345");
+        exception
+            .And.InnerException.Should()
+            .BeOfType<Exception>()
+            .Which.Message.Should()
+            .Be("Database error");
+    }
+
+    [Fact]
+    public async Task SaveSessionAsync_ShouldClearMessagesAndAddNew()
+    {
+        // Arrange
+        var session = TestDataBuilder.ChatSessions.CreateBasicSession(12345, "private");
+        session.AddUserMessage("Test message", "user1");
+        session.AddAssistantMessage("Test response");
+
+        var sessionEntity = TestDataBuilder.Mocks.CreateChatSessionEntity();
+        _repositoryMock.Setup(x => x.GetByChatIdAsync(12345)).ReturnsAsync(sessionEntity);
+        _repositoryMock
+            .Setup(x => x.UpdateAsync(It.IsAny<ChatSessionEntity>()))
+            .ReturnsAsync(sessionEntity);
+
+        // Act
+        await _sessionStorage.SaveSessionAsync(session);
+
+        // Assert
+        _repositoryMock.Verify(x => x.ClearMessagesAsync(It.IsAny<int>()), Times.Once);
+        _repositoryMock.Verify(
+            x =>
+                x.AddMessageAsync(
+                    It.IsAny<int>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<int>()
+                ),
+            Times.Exactly(2)
+        );
+        _repositoryMock.Verify(x => x.UpdateAsync(It.IsAny<ChatSessionEntity>()), Times.Once);
+    }
+
+    [Fact]
+    public void Remove_ShouldReturnFalse_WhenRepositoryThrows()
+    {
+        // Arrange
+        _repositoryMock
+            .Setup(x => x.DeleteAsync(12345))
+            .ThrowsAsync(new Exception("Database error"));
+
+        // Act
+        var result = _sessionStorage.Remove(12345);
+
+        // Assert
+        result.Should().BeFalse();
+    }
+
+    [Fact]
+    public void GetActiveSessionsCount_ShouldReturnZero_WhenRepositoryThrows()
+    {
+        // Arrange
+        _repositoryMock
+            .Setup(x => x.GetActiveSessionsCountAsync())
+            .ThrowsAsync(new Exception("Database error"));
+
+        // Act
+        var result = _sessionStorage.GetActiveSessionsCount();
+
+        // Assert
+        result.Should().Be(0);
+    }
+
+    [Fact]
+    public void CleanupOldSessions_ShouldReturnZero_WhenRepositoryThrows()
+    {
+        // Arrange
+        _repositoryMock
+            .Setup(x => x.CleanupOldSessionsAsync(24))
+            .ThrowsAsync(new Exception("Database error"));
+
+        // Act
+        var result = _sessionStorage.CleanupOldSessions(24);
+
+        // Assert
+        result.Should().Be(0);
+    }
+
+    [Fact]
+    public void GetOrCreate_WithCompressionService_ShouldSetCompressionService()
+    {
+        // Arrange
+        var compressionServiceMock = TestDataBuilder.Mocks.CreateCompressionServiceMock();
+        var storageWithCompression = new DatabaseSessionStorage(
+            _repositoryMock.Object,
+            Mock.Of<ILogger<DatabaseSessionStorage>>(),
+            compressionServiceMock.Object
+        );
+
+        var sessionEntity = TestDataBuilder.Mocks.CreateChatSessionEntity();
+        _repositoryMock
+            .Setup(x => x.GetOrCreateAsync(12345, "private", "Test Chat"))
+            .ReturnsAsync(sessionEntity);
+
+        // Act
+        var result = storageWithCompression.GetOrCreate(12345, "private", "Test Chat");
+
+        // Assert
+        result.Should().NotBeNull();
+        result.ChatId.Should().Be(12345);
+    }
+
+    [Fact]
+    public void Get_WithCompressionService_ShouldSetCompressionService()
+    {
+        // Arrange
+        var loggerMock = new Mock<ILogger<DatabaseSessionStorage>>();
+        var compressionServiceMock = TestDataBuilder.Mocks.CreateCompressionServiceMock();
+        var storageWithCompression = new DatabaseSessionStorage(
+            _repositoryMock.Object,
+            loggerMock.Object,
+            compressionServiceMock.Object
+        );
+
+        var sessionEntity = TestDataBuilder.Mocks.CreateChatSessionEntity();
+        sessionEntity.Messages.Add(
+            new ChatMessageEntity
+            {
+                Id = 1,
+                SessionId = sessionEntity.Id,
+                Content = "Test",
+                Role = "user",
+                MessageOrder = 0,
+                CreatedAt = DateTime.UtcNow,
+            }
+        );
+
+        _repositoryMock.Setup(x => x.GetByChatIdAsync(12345)).ReturnsAsync(sessionEntity);
+
+        // Act
+        var result = storageWithCompression.Get(12345);
+
+        // Assert
+        _repositoryMock.Verify(x => x.GetByChatIdAsync(12345), Times.Once);
+        result.Should().NotBeNull();
+        result!.GetMessageCount().Should().Be(1);
+    }
+
+    [Fact]
+    public async Task SaveSessionAsync_WithMultipleMessages_ShouldSaveInCorrectOrder()
+    {
+        // Arrange
+        var session = TestDataBuilder.ChatSessions.CreateBasicSession(12345, "private");
+        session.AddUserMessage("Message 1", "user1");
+        session.AddAssistantMessage("Response 1");
+        session.AddUserMessage("Message 2", "user1");
+        session.AddAssistantMessage("Response 2");
+
+        var sessionEntity = TestDataBuilder.Mocks.CreateChatSessionEntity();
+        _repositoryMock.Setup(x => x.GetByChatIdAsync(12345)).ReturnsAsync(sessionEntity);
+        _repositoryMock
+            .Setup(x => x.UpdateAsync(It.IsAny<ChatSessionEntity>()))
+            .ReturnsAsync(sessionEntity);
+
+        // Act
+        await _sessionStorage.SaveSessionAsync(session);
+
+        // Assert
+        _repositoryMock.Verify(x => x.ClearMessagesAsync(It.IsAny<int>()), Times.Once);
+        _repositoryMock.Verify(
+            x =>
+                x.AddMessageAsync(
+                    It.IsAny<int>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<int>()
+                ),
+            Times.Exactly(4)
+        );
+    }
+
+    [Fact]
+    public void GetOrCreate_WithDefaultParameters_ShouldUseDefaults()
+    {
+        // Arrange
+        var sessionEntity = TestDataBuilder.Mocks.CreateChatSessionEntity();
+        _repositoryMock
+            .Setup(x => x.GetOrCreateAsync(12345, "private", ""))
+            .ReturnsAsync(sessionEntity);
+
+        // Act
+        var result = _sessionStorage.GetOrCreate(12345);
+
+        // Assert
+        result.Should().NotBeNull();
+        _repositoryMock.Verify(x => x.GetOrCreateAsync(12345, "private", ""), Times.Once);
+    }
 }