Merge pull request #84 from boolean-uk/73-backend---create-endpoints-for-getpostputdelete-post

73 backend   create endpoints for getpostputdelete post

Author: otvegg

exercise.tests/IntegrationTests/PostTests.cs

@@ -0,0 +1,263 @@
+using exercise.wwwapi.DTOs.Posts;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Threading.Tasks;
+
+namespace exercise.tests.IntegrationTests
+{
+    [TestFixture]
+    public class PostTests
+    {
+        private WebApplicationFactory<Program> _factory;
+        private HttpClient _client;
+
+        [SetUp]
+        public void SetUp()
+        {
+            // Arrange 
+            _factory = new WebApplicationFactory<Program>();
+            _client = _factory.CreateClient();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _client.Dispose();
+            _factory.Dispose();
+        }
+
+        [Test]
+        public async Task SuccessfulCreatePostStatus()
+        {
+            int userid = 1;
+            string content = "Some content";
+            CreatePostDTO body = new CreatePostDTO
+            {
+                Userid = userid,
+                Content = content
+            };
+            var json = JsonSerializer.Serialize(body);
+            var requestBody = new StringContent(json, Encoding.UTF8, "application/json");
+
+            // Act
+            var response = await _client.PostAsync("/posts", requestBody);
+
+            var contentString = await response.Content.ReadAsStringAsync();
+
+            JsonNode? message = null;
+            if (!string.IsNullOrWhiteSpace(contentString))
+            {
+                message = JsonNode.Parse(contentString);
+            }
+
+            Console.WriteLine("Message: " + message);
+            // Assert
+            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
+        }
+
+        [Test]
+        public async Task SuccessfulCreatePostMessage()
+        {
+            int userid = 1;
+            string content = "Some content";
+            CreatePostDTO body = new CreatePostDTO
+            {
+                Userid = userid,
+                Content = content
+            };
+            var json = JsonSerializer.Serialize(body);
+            var requestBody = new StringContent(json, Encoding.UTF8, "application/json");
+
+            // Act
+            var response = await _client.PostAsync("/posts", requestBody);
+
+            var contentString = await response.Content.ReadAsStringAsync();
+
+            JsonNode? message = null;
+            if (!string.IsNullOrWhiteSpace(contentString))
+            {
+                message = JsonNode.Parse(contentString);
+            }
+
+            Console.WriteLine("Message: " + message);
+            // Assert
+
+            // Assert JSON structure
+            Assert.That(message, Is.Not.Null);
+            Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo("success"));
+
+            var data = message["data"];
+            Assert.That(data, Is.Not.Null);
+            Assert.That(data?["id"]?.GetValue<int>(), Is.GreaterThan(0));
+            Assert.That(data["content"]?.GetValue<string>(), Is.EqualTo(content));
+            Assert.That(data["numLikes"]?.GetValue<int>(), Is.EqualTo(0));
+            Assert.That(data["comments"]?.AsArray().Count, Is.EqualTo(0));
+
+            // Check User object inside data
+            var user = data["user"];
+            Assert.That(user, Is.Not.Null);
+            Assert.That(user!["id"]?.GetValue<int>(), Is.EqualTo(userid));
+            Assert.That(user["firstName"]?.GetValue<string>(), Is.Not.Null);
+            Assert.That(user["lastName"]?.GetValue<string>(), Is.Not.Null);
+            Assert.That(user["photo"]?.GetValue<string>(), Is.Not.Null);
+
+            Assert.That(message["timestamp"], Is.Not.Null);
+            Assert.That(data["createdAt"], Is.Not.Null);
+        }
+
+        [TestCase(9999999, "somecontent", HttpStatusCode.NotFound)]
+        [TestCase(5, "", HttpStatusCode.BadRequest)]
+        [TestCase(5, "      ", HttpStatusCode.BadRequest)]
+        [TestCase(5, "          ", HttpStatusCode.BadRequest)]
+        public async Task FailedlCreatePostStatus(int userid, string content, HttpStatusCode expected)
+        {
+            CreatePostDTO body = new CreatePostDTO
+            {
+                Userid = userid,
+                Content = content
+            };
+            var json = JsonSerializer.Serialize(body);
+            var requestBody = new StringContent(json, Encoding.UTF8, "application/json");
+
+            // Act
+            var response = await _client.PostAsync("/posts", requestBody);
+
+            var contentString = await response.Content.ReadAsStringAsync();
+
+            JsonNode? message = null;
+            if (!string.IsNullOrWhiteSpace(contentString))
+            {
+                message = JsonNode.Parse(contentString);
+            }
+
+            Console.WriteLine("Message: " + message);
+            // Assert
+            Assert.That(response.StatusCode, Is.EqualTo(expected));
+        }
+
+        [TestCase(9999999, "somecontent", "Invalid userID")]
+        [TestCase(5, "", "Content cannot be empty")]
+        [TestCase(5, "      ", "Content cannot be empty")]
+        [TestCase(5, "          ", "Content cannot be empty")]
+        public async Task FailedCreatePostMessage(int userid, string content, string expectedmessage)
+        {
+            CreatePostDTO body = new CreatePostDTO
+            {
+                Userid = userid,
+                Content = content
+            };
+            var json = JsonSerializer.Serialize(body);
+            var requestBody = new StringContent(json, Encoding.UTF8, "application/json");
+
+            // Act
+            var response = await _client.PostAsync("/posts", requestBody);
+
+            var contentString = await response.Content.ReadAsStringAsync();
+
+            JsonNode? message = null;
+            if (!string.IsNullOrWhiteSpace(contentString))
+            {
+                message = JsonNode.Parse(contentString);
+            }
+
+            Console.WriteLine("Message: " + message);
+
+            // Assert JSON structure
+            Assert.That(message, Is.Not.Null);
+            Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo(expectedmessage));
+            Assert.That(message["data"], Is.Null);
+            Assert.That(message["timestamp"], Is.Not.Null);
+        }
+        [Test]
+        public async Task DeletePostById_SuccessAndNotFound()
+        {
+            // Arrange, create a post first
+            var newPost = new CreatePostDTO
+            {
+                Userid = 1,
+                Content = "Temp post to delete"
+            };
+            var json = JsonSerializer.Serialize(newPost);
+            var requestBody = new StringContent(json, Encoding.UTF8, "application/json");
+
+            var createResponse = await _client.PostAsync("/posts", requestBody);
+            var createContent = await createResponse.Content.ReadAsStringAsync();
+            var createMessage = JsonNode.Parse(createContent);
+
+            int createdPostId = createMessage!["data"]!["id"]!.GetValue<int>();
+
+            // Act, delete the post
+            var deleteResponse = await _client.DeleteAsync($"/posts/{createdPostId}");
+            var deleteContent = await deleteResponse.Content.ReadAsStringAsync();
+
+            // Assert delete success
+            Assert.That(deleteResponse.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+            // Act again, try deleting same post (should now be gone)
+            var deleteAgainResponse = await _client.DeleteAsync($"/posts/{createdPostId}");
+            var deleteAgainContent = await deleteAgainResponse.Content.ReadAsStringAsync();
+            var deleteAgainMessage = JsonNode.Parse(deleteAgainContent);
+
+            // Assert not found
+            Assert.That(deleteAgainResponse.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+            Assert.That(deleteAgainMessage?["message"]?.GetValue<string>(), Is.EqualTo("Post not found"));
+        }
+
+
+
+
+        [TestCase(5, "Updated content", HttpStatusCode.OK)]
+        [TestCase(9999999, "Updated content", HttpStatusCode.NotFound)]
+        [TestCase(5, "", HttpStatusCode.BadRequest)]
+        public async Task UpdatePostById(int postId, string newContent, HttpStatusCode expected)
+        {
+            // Arrange
+            UpdatePostDTO body = new UpdatePostDTO { Content = newContent };
+            var json = JsonSerializer.Serialize(body);
+            var requestBody = new StringContent(json, Encoding.UTF8, "application/json");
+
+            // Act
+            var response = await _client.PatchAsync($"/posts/{postId}", requestBody);
+            var contentString = await response.Content.ReadAsStringAsync();
+
+            JsonNode? message = null;
+            if (!string.IsNullOrWhiteSpace(contentString))
+            {
+                message = JsonNode.Parse(contentString);
+            }
+
+            Console.WriteLine("Message: " + message);
+
+            // Assert status
+            Assert.That(response.StatusCode, Is.EqualTo(expected));
+
+            if (expected == HttpStatusCode.OK)
+            {
+                var data = message?["data"];
+                Assert.That(data, Is.Not.Null);
+                Assert.That(data?["id"]?.GetValue<int>(), Is.EqualTo(postId));
+                Assert.That(data?["content"]?.GetValue<string>(), Is.EqualTo(newContent));
+                Assert.That(data?["updatedAt"], Is.Not.Null);
+            }
+            else if (expected == HttpStatusCode.NotFound)
+            {
+                Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo("Post not found"));
+                Assert.That(message?["data"], Is.Null);
+            }
+            else if (expected == HttpStatusCode.BadRequest)
+            {
+                Assert.That(message?["message"]?.GetValue<string>(), Is.EqualTo("Content cannot be empty"));
+                Assert.That(message?["data"], Is.Null);
+            }
+        }
+
+
+    }
+}

exercise.wwwapi/DTOs/Posts/CreatePostDTO.cs

@@ -0,0 +1,14 @@
+using exercise.wwwapi.DTOs.GetUsers;
+using exercise.wwwapi.Models;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace exercise.wwwapi.DTOs.Posts
+{
+    public class CreatePostDTO
+    {
+        public required int Userid { get; set; }
+        public required string Content { get; set; }
+
+    }
+}

exercise.wwwapi/DTOs/Posts/UpdatePostDTO.cs

@@ -0,0 +1,7 @@
+namespace exercise.wwwapi.DTOs.Posts
+{
+    public class UpdatePostDTO
+    {
+        public string Content { get; set; } = string.Empty;
+    }
+}

exercise.wwwapi/Endpoints/PostEndpoints.cs

@@ -1,4 +1,12 @@
-using Microsoft.AspNetCore.Mvc;
+using AutoMapper;
+using exercise.wwwapi.Data;
+using exercise.wwwapi.DTOs;
+using exercise.wwwapi.DTOs.GetUsers;
+using exercise.wwwapi.DTOs.Posts;
+using exercise.wwwapi.Models;
+using exercise.wwwapi.Repository;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
 
 namespace exercise.wwwapi.Endpoints
 {
@@ -9,16 +17,90 @@ public static void ConfigurePostEndpoints(this WebApplication app)
             var posts = app.MapGroup("posts");
             posts.MapPost("/", CreatePost).WithSummary("Create post");
             posts.MapGet("/", GetAllPosts).WithSummary("Get all posts");
+            posts.MapPatch("/{id}", UpdatePost).WithSummary("Update a certain post");
+            posts.MapDelete("/{id}", DeletePost).WithSummary("Remove a certain post");
         }
+
         [ProducesResponseType(StatusCodes.Status200OK)]
-        public static async Task<IResult> CreatePost()
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        public static IResult CreatePost(IRepository<User> userservice, IRepository<Post> postservice, IMapper mapper, CreatePostDTO request)
         {
-            return TypedResults.Ok();
+
+            User? user = userservice.GetById(request.Userid);
+            if (user == null)
+                return Results.NotFound(new ResponseDTO<Object>{Message = "Invalid userID"});
+
+            if (string.IsNullOrWhiteSpace(request.Content))
+                return Results.BadRequest(new ResponseDTO<Object> { Message = "Content cannot be empty" });
+
+            Post post = new Post() { CreatedAt = DateTime.UtcNow, NumLikes = 0, UserId=request.Userid, Content=request.Content };
+
+            // is a try catch needed here?
+            postservice.Insert(post);
+            postservice.Save();
+
+
+            UserBasicDTO userBasicDTO = mapper.Map<UserBasicDTO>(user);
+            PostDTO postDTO = mapper.Map<PostDTO>(post);
+            postDTO.User = userBasicDTO;
+
+            ResponseDTO<PostDTO> response = new ResponseDTO<PostDTO>
+            {
+                Message = "success",
+                Data = postDTO
+            };
+
+            return Results.Created($"/posts/{post.Id}", response);
+        }
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public static IResult GetAllPosts(IRepository<Post> service, IMapper mapper)
+        {
+            IEnumerable<Post> results = service.GetWithIncludes(q => q.Include(p => p.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)]
-        public static async Task<IResult> GetAllPosts()
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        public static IResult UpdatePost(IRepository<Post> service, IMapper mapper, int id, UpdatePostDTO request)
         {
-            return TypedResults.Ok();
+            if (string.IsNullOrWhiteSpace(request.Content)) return TypedResults.BadRequest(new ResponseDTO<object>{
+                    Message = "Content cannot be empty"
+                });
+            
+            Post? post = service.GetById(id, q=>q.Include(p => p.User));
+
+            if (post == null) return TypedResults.NotFound(new ResponseDTO<Object> { Message = "Post not found" });
+
+            post.Content = request.Content;
+            post.UpdatedAt = DateTime.UtcNow;
+
+            service.Update(post);
+            service.Save();
+
+            PostDTO postDTO = mapper.Map<PostDTO>(post);
+
+
+            return TypedResults.Ok(new ResponseDTO<PostDTO> { Message = "Success", Data = postDTO });
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        private static IResult DeletePost(IRepository<Post> service, int id)
+        {
+            Post? post = service.GetById(id, q => q.Include(p => p.User));
+            if (post == null) return TypedResults.NotFound(new ResponseDTO<Object> { Message = "Post not found" });
+
+            service.Delete(id);
+            service.Save();
+
+            return TypedResults.Ok(new ResponseDTO<PostDTO> { Message = "Success" });
         }
     }
 }