feat: recommendation

sharp/content.Tests/domainservice/Test.cs

@@ -0,0 +1,104 @@
+using content.domainservice;
+using content.repository;
+using Moq;
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+public class HistoryServiceTests
+{
+    [Fact]
+    public async Task GetHistory_ReturnsVideos()
+    {
+        // Arrange
+        var mockHistoryRepo = new Mock<HistoryRepository>(null!);
+        var mockClient = new Mock<QdrantClient>("localhost",default!,default!,default!,default!,default!);
+        var mockDomainService = new Mock<IDomainService>();
+        var userId = 1L;
+        var historyList = new List<long> { 1L, 2L };
+        var videoDtos = new List<VideoDto> { new VideoDto(), new VideoDto() };
+
+        mockHistoryRepo.Setup(x => x.GetHistorys(userId, It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(historyList);
+        mockDomainService.Setup(x => x.FindAllByIds(historyList)).ReturnsAsync(videoDtos);
+
+        var service = new HistoryService(mockHistoryRepo.Object, mockClient.Object, mockDomainService.Object);
+
+        // Act
+        var result = await service.GetHistory(userId);
+
+        // Assert
+        Assert.Equal(videoDtos, result.Items);
+    }
+
+    [Fact]
+    public async Task AddHistory_ReturnsTrue()
+    {
+        // Arrange
+        var mockHistoryRepo = new Mock<HistoryRepository>(null!);
+        var mockClient = new Mock<QdrantClient>("localhost",default!,default!,default!,default!,default!);
+        var mockDomainService = new Mock<IDomainService>();
+
+        var userId = 1L;
+        var videoId = 2L;
+
+        mockHistoryRepo.Setup(x => x.AddHistory(userId, videoId)).Returns(Task.FromResult(1L));
+
+        var service = new HistoryService(mockHistoryRepo.Object, mockClient.Object, mockDomainService.Object);
+
+        // Act
+        var result = await service.AddHistory(userId, videoId);
+
+        // Assert
+        Assert.True(result);
+    }
+
+/*     [Fact]
+    public async Task Recommendation_ReturnsPagination()
+    {
+        // Arrange
+        var mockHistoryRepo = new Mock<HistoryRepository>(null!);
+        var mockClient = new Mock<QdrantClient>("localhost",default!,default!,default!,default!,default!);
+        var mockDomainService = new Mock<IDomainService>();
+
+        var userId = 1L;
+        var page = 0UL;
+        var size = 10UL;
+        var historyList = new List<long> { 1L, 2L };
+        var recommendationResults = new List<ScoredPoint> { new ScoredPoint { Id = new PointId { Num = 1 } }, new ScoredPoint { Id = new PointId { Num = 2 } } };
+        var videoIds = recommendationResults.Select(x => (long)x.Id.Num).ToList();
+        var videoDtos = new List<VideoDto> { new (), new () };
+
+        mockHistoryRepo.Setup(x => x.GetHistorys(userId, It.IsAny<long?>(), It.IsAny<int?>())).ReturnsAsync(historyList);
+        mockClient.Setup(x => x.RecommendAsync(
+           It.IsAny<string>(),
+           It.IsAny<IReadOnlyList<ulong>>(),
+           It.IsAny<IReadOnlyList<ulong>?>(),
+           It.IsAny<ReadOnlyMemory<Vector>?>(),
+           It.IsAny<ReadOnlyMemory<Vector>?>(),
+           It.IsAny<RecommendStrategy?>(),
+           It.IsAny<Filter?>(),
+           It.IsAny<SearchParams?>(),
+           It.IsAny<ulong>(),
+           It.IsAny<ulong>(),
+           It.IsAny<WithPayloadSelector?>(),
+           It.IsAny<WithVectorsSelector?>(),
+           It.IsAny<float?>(),
+           It.IsAny<string?>(),
+           It.IsAny<LookupLocation?>(),
+           It.IsAny<ReadConsistency?>(),
+           It.IsAny<ShardKeySelector?>(),
+           It.IsAny<TimeSpan?>(),
+           It.IsAny<CancellationToken>()
+       )).ReturnsAsync(recommendationResults);
+        mockDomainService.Setup(x => x.FindAllByIds(videoIds)).ReturnsAsync(videoDtos);
+
+        var service = new HistoryService(mockHistoryRepo.Object, mockClient.Object, mockDomainService.Object);
+
+        // Act
+        var result = await service.Recommendation(userId, page, size);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(videoDtos, result.Items);
+        Assert.Equal((page + 1).ToString(), result.NextPage);
+    } */
+}

sharp/content.Tests/endpoints/EndpointsTest.cs

@@ -24,10 +24,7 @@ public class EndpointsTests
 {
     private readonly Mock<IDomainService> _mockService = new();
 
-    private readonly ClaimsPrincipal _user = new(new ClaimsIdentity(new Claim[]
-    {
-        new("id", "1"),
-    }));
+    private readonly ClaimsPrincipal _user = new(new ClaimsIdentity([new("id", "1")]));
 
     [Fact]
     public async Task UserVideos_ReturnsExpectedVideos()
@@ -114,50 +111,6 @@ public async Task CreateVideo_CallsServiceWithExpectedVideo()
             1L == _user.UserId())), Times.Once);
     }
 
-    private readonly Mock<IMessageDomain> _mockMessageDomain = new();
-
-    [Fact]
-    public async Task FindMessages_ReturnsCorrectPagination_WhenMessagesExist()
-    {
-        // Arrange
-        var expectedMessages = new Pagination<MessageDto>
-        {
-            Items = [new MessageDto { Id = 1 }, new MessageDto { Id = 2 }],
-            AllCount = 2
-        };
-        _mockMessageDomain.Setup(s =>
-                s.FindMessages(It.IsAny<long>(), It.IsAny<long>(), It.IsAny<int>(), It.IsAny<bool>()))
-            .ReturnsAsync(expectedMessages);
-
-        // Act
-        var result = await Endpoints.FindMessages(_mockMessageDomain.Object, 1, 1, 10, false);
-
-        // Assert
-        Assert.Equal(expectedMessages, result);
-    }
-
-    [Fact]
-    public async Task Save_ReturnsCorrectDto_WhenMessageIsSaved()
-    {
-        // Arrange
-        var request = new MessageRequest
-        {
-            ReceiverId = 1,
-            Content = "Test content",
-            Type = 1
-        };
-        var expectedMessage = new MessageDto
-        { Id = 1, ReceiverId = request.ReceiverId, Content = request.Content, Type = request.Type };
-        _mockMessageDomain.Setup(s => s.Save(It.IsAny<Message>())).ReturnsAsync(expectedMessage);
-
-        // Act
-        var result = await Endpoints.Save(_mockMessageDomain.Object, request, _user, new MessageRequestValidator());
-
-        // Assert
-        Assert.Equal(expectedMessage, result);
-    }
-
-
     [Fact]
     public void Validate_WithValidVideoRequest_DoesNotThrowException()
     {
@@ -333,23 +286,4 @@ public void EnsurePageAndSize_WithSizeGreaterThan20_ThrowsArgumentOutOfRangeExce
         Assert.Throws<ArgumentOutOfRangeException>(() => Endpoints.EnsurePageAndSize(page, size));
     }
 
-
-    [Fact]
-    public async Task MarkAsRead_UpdatesStatus_WhenCalled()
-    {
-        await Endpoints.MarkAsRead(_mockMessageDomain.Object, 1, _user);
-        _mockMessageDomain.Verify(service => service.MarkAsRead(1, 1), Times.Once);
-    }
-
-    [Fact]
-    public void Validate_ThrowsException_WhenContentIsInvalid()
-    {
-        var request = new MessageRequest
-        {
-            ReceiverId = 1,
-            Content = new string('a', 201),
-            Type = 1
-        };
-        Assert.Throws<ValidationException>(() => new MessageRequestValidator().ValidateAndThrow(request));
-    }
 }

sharp/content.Tests/repository/ClientTest.cs

@@ -177,14 +177,13 @@ public async Task SimilarSearch_ReturnsListOfVideoIds()
         };
 
         var mockHttpMessageHandler = new Mock<HttpMessageHandler>();
-        var mockFactory = new Mock<IHttpClientFactory>();
+
         var client = new HttpClient(mockHttpMessageHandler.Object)
         {
             BaseAddress = new Uri("http://localhost:5151")
         };
-        mockFactory.Setup(_ => _.CreateClient("Search")).Returns(client);
 
-        var searchClient = new SearchClient(mockFactory.Object, ConnectionMultiplexer.Connect("localhost").GetDatabase());
+        var searchClient = new SearchClient(client, ConnectionMultiplexer.Connect("localhost").GetDatabase());
 
         mockHttpMessageHandler.Protected()
             .Setup<Task<HttpResponseMessage>>(

sharp/content.Tests/repository/HistoryTest.cs

@@ -0,0 +1,40 @@
+using content.repository;
+using Moq;
+using StackExchange.Redis;
+
+public class HistoryRepositoryTests
+{
+    [Fact]
+    public async Task GetHistorys_ShouldReturnHistorys()
+    {
+        // Arrange
+        var mockDb = new Mock<IDatabase>();
+        var (userId, historyIds) = (123, new RedisValue[] { 1, 2, 3 });
+        mockDb.Setup(db => db.ListRangeAsync($"history:{userId}", It.IsAny<long>(), It.IsAny<long>(), CommandFlags.None)).ReturnsAsync(historyIds);
+        var repository = new HistoryRepository(mockDb.Object);
+
+        // Act
+        var result = await repository.GetHistorys(userId);
+
+        // Assert
+        Assert.Equal(historyIds.Length, result.Count);
+        for (int i = 0; i < historyIds.Length; i++)
+        {
+            Assert.Equal((long)historyIds[i], result[i]);
+        }
+    }
+
+    [Fact]
+    public async Task AddHistory_ShouldReturnCount()
+    {
+        // Arrange
+        var mockDb = new Mock<IDatabase>();
+        var (userId, historyId, expectedCount) = (123, 456, 1);
+        mockDb.Setup(db => db.ListRightPushAsync($"history:{userId}", historyId, When.Always, CommandFlags.None)).ReturnsAsync(expectedCount);
+        var repository = new HistoryRepository(mockDb.Object);
+        // Act
+        var result = await repository.AddHistory(userId, historyId);
+        // Assert
+        Assert.Equal(expectedCount, result);
+    }
+}