Finished most parts, lacking authentication on removals/updatesa

Author: otvegg

exercise.tests/IntegrationTests/PostTests.cs

@@ -361,7 +361,7 @@ public async Task AddCommentToPost_Failure(int postId, int userId, string conten
         public async Task GetCommentsForPost_Success()
         {
             // Arrange
-            int postId = 6;
+            int postId = 5;
 
             // Act
             var response = await _client.GetAsync($"/posts/{postId}/comments");
@@ -463,5 +463,101 @@ public async Task DeleteComment_SuccessAndThenNotFound()
             Assert.That(deleteAgainResponse.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
         }
 
+
+        [Test]
+        public async Task GetPostsByUser_Success()
+        {
+            // Arrange
+            int userId = 1; // CHeck if this user still has posts if this test fails (manuially)
+
+            // Act
+            var response = await _client.GetAsync($"/posts/user/{userId}");
+            var contentString = await response.Content.ReadAsStringAsync();
+            var message = JsonNode.Parse(contentString);
+            Console.WriteLine(message);
+            // Assert status
+            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+            
+            Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo("Success"));
+            var data = message?["data"]?.AsArray();
+            Assert.That(data, Is.Not.Null);
+            Assert.That(data!.Count, Is.GreaterThan(0), "Expected user 1 to have at least one post.");
+
+            // Assert that ALL posts in the response belong to the correct user
+            foreach (var post in data!)
+            {
+                Assert.That(post?["user"]?["id"]?.GetValue<int>(), Is.EqualTo(userId));
+            }
+
+            var firstPost = data.First();
+            Assert.That(firstPost?["id"]?.GetValue<int>(), Is.GreaterThan(0));
+            Assert.That(firstPost?["content"]?.GetValue<string>(), Is.Not.Null);
+        }
+
+        [Test]
+        public async Task GetPostsByUser_NotFound()
+        {
+            // Arrange
+            int nonExistentUserId = 99999;
+
+            // Act
+            var response = await _client.GetAsync($"/posts/user/{nonExistentUserId}");
+            var contentString = await response.Content.ReadAsStringAsync();
+            var message = JsonNode.Parse(contentString);
+
+            // Assert
+            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+            Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo("No posts found for this user"));
+            Assert.That(message?["data"], Is.Null);
+        }
+
+        [Test]
+        public async Task GetCommentsByUser_Success()
+        {
+            // Arrange
+            int userId = 1; // Check if this user still has comments if this fails
+
+            // Act
+            var response = await _client.GetAsync($"/comments/user/{userId}");
+            var contentString = await response.Content.ReadAsStringAsync();
+            var message = JsonNode.Parse(contentString);
+            Console.WriteLine(message);
+            // Assert status
+            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+            Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo("Success"));
+            var data = message?["data"]?.AsArray();
+            Assert.That(data, Is.Not.Null);
+            Assert.That(data!.Count, Is.GreaterThan(0), "Expected user 1 to have at least one comment.");
+
+            // Assert that ALL comments in the response belong to the correct user
+            foreach (var comment in data!)
+            {
+                Assert.That(comment?["user"]?["id"]?.GetValue<int>(), Is.EqualTo(userId));
+            }
+
+            var firstComment = data.First();
+            Assert.That(firstComment?["id"]?.GetValue<int>(), Is.GreaterThan(0));
+            Assert.That(firstComment?["content"]?.GetValue<string>(), Is.Not.Null.Or.Empty);
+        }
+
+        [Test]
+        public async Task GetCommentsByUser_NotFound()
+        {
+            // Arrange
+            int nonExistentUserId = 99999;
+
+            // Act
+            var response = await _client.GetAsync($"/comments/user/{nonExistentUserId}");
+            var contentString = await response.Content.ReadAsStringAsync();
+            var message = JsonNode.Parse(contentString);
+
+            // Assert
+            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+            Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo("No comments found for this user"));
+            Assert.That(message?["data"], Is.Null);
+        }
+
     }
 }

exercise.wwwapi/Endpoints/PostEndpoints.cs

@@ -21,13 +21,16 @@ public static void ConfigurePostEndpoints(this WebApplication app)
             posts.MapDelete("/{id}", DeletePost).WithSummary("Remove a certain post");
 
             posts.MapPost("/{postId}/comments", AddCommentToPost).WithSummary("Add a new comment to a post");
-            posts.MapGet("/{postId}/comments", GetCommentsForPost).WithSummary("Get comments for a specific post (with pagination)");
+            posts.MapGet("/{postId}/comments", GetCommentsForPost).WithSummary("Get comments for a specific post");
 
             // Standalone comment endpoints for editing/deleting
             var comments = app.MapGroup("comments");
             comments.MapPatch("/{id}", UpdateComment).WithSummary("Edit an existing comment");
             comments.MapDelete("/{id}", DeleteCommentById).WithSummary("Remove an existing comment");
 
+            // Endpoints to get by user
+            posts.MapGet("/user/{userId}", GetPostsByUser).WithSummary("Get posts by a specific user");
+            comments.MapGet("/user/{userId}", GetCommentsByUser).WithSummary("Get comments by a specific user");
         }
 
 
@@ -156,12 +159,13 @@ private static IResult AddCommentToPost(IRepository<PostComment> commentService,
         }
 
         [ProducesResponseType(StatusCodes.Status200OK)]
-        private static IResult GetCommentsForPost(IRepository<PostComment> service, IMapper mapper, int postId)
+        private static IResult GetCommentsForPost(IRepository<Post> postservice, IMapper mapper, int postId)
         {
-            PostComment? comment = service.GetById(postId, q => q.Include(c => c.User));
-            if (comment == null) return TypedResults.NotFound(new ResponseDTO<Object> { Message = "Comment not found" });
-            PostCommentDTO commentDTO = mapper.Map<PostCommentDTO>(comment);
-            return TypedResults.Ok(new ResponseDTO<PostCommentDTO> { Message = "Success", Data = commentDTO });
+            Post? post = postservice.GetById(postId, q => q.Include(p => p.User).Include(p => p.Comments).ThenInclude(c => c.User));
+            if (post == null) return TypedResults.NotFound(new ResponseDTO<Object> { Message = "Post not found" });
+            List<PostComment> comments = [.. post.Comments];
+            List<PostCommentDTO> commentsDTO = mapper.Map<List<PostCommentDTO>>(comments);
+            return TypedResults.Ok(new ResponseDTO<List<PostCommentDTO>> { Message = "Success", Data = commentsDTO });
         }
 
         [ProducesResponseType(StatusCodes.Status200OK)]
@@ -205,5 +209,37 @@ private static IResult DeleteCommentById(IRepository<PostComment> service, int i
 
             return TypedResults.Ok(new ResponseDTO<object> { Message = "Comment deleted successfully." });
         }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        private static IResult GetPostsByUser(IRepository<Post> service, IMapper mapper, int userid)
+        {
+            IEnumerable<Post> results = service.GetWithIncludes(q => q.Where(p => p.UserId == userid).Include(p => p.User).Include(p => p.Comments).ThenInclude(c => c.User));
+            if (results.Count() == 0) return TypedResults.NotFound(new ResponseDTO<Object> { Message = "No posts found for this user" });
+
+            IEnumerable<PostDTO> postDTOs = mapper.Map<IEnumerable<PostDTO>>(results);
+            ResponseDTO<IEnumerable<PostDTO>> response = new ResponseDTO<IEnumerable<PostDTO>>()
+            {
+                Message = "Success",
+                Data = postDTOs
+            };
+            return TypedResults.Ok(response);
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        private static IResult GetCommentsByUser(IRepository<PostComment> service, IMapper mapper, int userid)
+        {
+            IEnumerable<PostComment> results = service.GetWithIncludes(q => q.Where(p => p.UserId == userid).Include(p => p.User));
+            if (results.Count() == 0) return TypedResults.NotFound(new ResponseDTO<Object> { Message = "No comments found for this user" });
+
+            IEnumerable<PostCommentDTO> PostCommentDTOs = mapper.Map<IEnumerable<PostCommentDTO>>(results);
+            ResponseDTO<IEnumerable<PostCommentDTO>> response = new ResponseDTO<IEnumerable<PostCommentDTO>>()
+            {
+                Message = "Success",
+                Data = PostCommentDTOs
+            };
+            return TypedResults.Ok(response);
+        }
     }
 }