611 lines
14 KiB
Go
611 lines
14 KiB
Go
package handler
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"tss-rocks-be/ent"
|
|
"tss-rocks-be/internal/config"
|
|
"tss-rocks-be/internal/service/mock"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/suite"
|
|
"go.uber.org/mock/gomock"
|
|
|
|
"errors"
|
|
"strings"
|
|
)
|
|
|
|
type PostHandlerTestSuite struct {
|
|
suite.Suite
|
|
ctrl *gomock.Controller
|
|
service *mock.MockService
|
|
handler *Handler
|
|
router *gin.Engine
|
|
}
|
|
|
|
func (s *PostHandlerTestSuite) SetupTest() {
|
|
s.ctrl = gomock.NewController(s.T())
|
|
s.service = mock.NewMockService(s.ctrl)
|
|
cfg := &config.Config{}
|
|
s.handler = NewHandler(cfg, s.service)
|
|
|
|
// Setup Gin router
|
|
gin.SetMode(gin.TestMode)
|
|
s.router = gin.New()
|
|
s.handler.RegisterRoutes(s.router)
|
|
}
|
|
|
|
func (s *PostHandlerTestSuite) TearDownTest() {
|
|
s.ctrl.Finish()
|
|
}
|
|
|
|
func TestPostHandlerSuite(t *testing.T) {
|
|
suite.Run(t, new(PostHandlerTestSuite))
|
|
}
|
|
|
|
// Test cases for ListPosts
|
|
func (s *PostHandlerTestSuite) TestListPosts() {
|
|
categoryID := 1
|
|
testCases := []struct {
|
|
name string
|
|
langCode string
|
|
categoryID string
|
|
limit string
|
|
offset string
|
|
setupMock func()
|
|
expectedStatus int
|
|
expectedBody interface{}
|
|
}{
|
|
{
|
|
name: "Success with default language",
|
|
langCode: "",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
ListPosts(gomock.Any(), "en", nil, 10, 0).
|
|
Return([]*ent.Post{
|
|
{
|
|
ID: 1,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: []*ent.Post{
|
|
{
|
|
ID: 1,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Success with specific language",
|
|
langCode: "zh",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
ListPosts(gomock.Any(), "zh", nil, 10, 0).
|
|
Return([]*ent.Post{
|
|
{
|
|
ID: 1,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "zh",
|
|
Title: "测试帖子",
|
|
ContentMarkdown: "测试内容",
|
|
Summary: "测试摘要",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: []*ent.Post{
|
|
{
|
|
ID: 1,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "zh",
|
|
Title: "测试帖子",
|
|
ContentMarkdown: "测试内容",
|
|
Summary: "测试摘要",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Success with category filter",
|
|
langCode: "en",
|
|
categoryID: "1",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
ListPosts(gomock.Any(), "en", &categoryID, 10, 0).
|
|
Return([]*ent.Post{
|
|
{
|
|
ID: 1,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: []*ent.Post{
|
|
{
|
|
ID: 1,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Success with pagination",
|
|
langCode: "en",
|
|
limit: "2",
|
|
offset: "1",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
ListPosts(gomock.Any(), "en", nil, 2, 1).
|
|
Return([]*ent.Post{
|
|
{
|
|
ID: 2,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "en",
|
|
Title: "Test Post 2",
|
|
ContentMarkdown: "Test Content 2",
|
|
Summary: "Test Summary 2",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: []*ent.Post{
|
|
{
|
|
ID: 2,
|
|
Status: "published",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "en",
|
|
Title: "Test Post 2",
|
|
ContentMarkdown: "Test Content 2",
|
|
Summary: "Test Summary 2",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Service Error",
|
|
langCode: "en",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
ListPosts(gomock.Any(), "en", nil, 10, 0).
|
|
Return(nil, errors.New("service error"))
|
|
},
|
|
expectedStatus: http.StatusInternalServerError,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
s.Run(tc.name, func() {
|
|
// Setup mock
|
|
tc.setupMock()
|
|
|
|
// Create request
|
|
url := "/api/v1/posts"
|
|
if tc.langCode != "" {
|
|
url += "?lang=" + tc.langCode
|
|
}
|
|
if tc.categoryID != "" {
|
|
if strings.Contains(url, "?") {
|
|
url += "&"
|
|
} else {
|
|
url += "?"
|
|
}
|
|
url += "category_id=" + tc.categoryID
|
|
}
|
|
if tc.limit != "" {
|
|
if strings.Contains(url, "?") {
|
|
url += "&"
|
|
} else {
|
|
url += "?"
|
|
}
|
|
url += "limit=" + tc.limit
|
|
}
|
|
if tc.offset != "" {
|
|
if strings.Contains(url, "?") {
|
|
url += "&"
|
|
} else {
|
|
url += "?"
|
|
}
|
|
url += "offset=" + tc.offset
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodGet, url, nil)
|
|
w := httptest.NewRecorder()
|
|
|
|
// Perform request
|
|
s.router.ServeHTTP(w, req)
|
|
|
|
// Assert response
|
|
s.Equal(tc.expectedStatus, w.Code)
|
|
if tc.expectedBody != nil {
|
|
var response []*ent.Post
|
|
err := json.Unmarshal(w.Body.Bytes(), &response)
|
|
s.NoError(err)
|
|
s.Equal(tc.expectedBody, response)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test cases for GetPost
|
|
func (s *PostHandlerTestSuite) TestGetPost() {
|
|
testCases := []struct {
|
|
name string
|
|
langCode string
|
|
slug string
|
|
setupMock func()
|
|
expectedStatus int
|
|
expectedBody interface{}
|
|
}{
|
|
{
|
|
name: "Success with default language",
|
|
langCode: "",
|
|
slug: "test-post",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
GetPostBySlug(gomock.Any(), "en", "test-post").
|
|
Return(&ent.Post{
|
|
ID: 1,
|
|
Status: "published",
|
|
Slug: "test-post",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: gin.H{
|
|
"id": 1,
|
|
"status": "published",
|
|
"slug": "test-post",
|
|
"edges": gin.H{
|
|
"contents": []gin.H{
|
|
{
|
|
"language_code": "en",
|
|
"title": "Test Post",
|
|
"content_markdown": "Test Content",
|
|
"summary": "Test Summary",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Success with specific language",
|
|
langCode: "zh",
|
|
slug: "test-post",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
GetPostBySlug(gomock.Any(), "zh", "test-post").
|
|
Return(&ent.Post{
|
|
ID: 1,
|
|
Status: "published",
|
|
Slug: "test-post",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{
|
|
{
|
|
LanguageCode: "zh",
|
|
Title: "测试帖子",
|
|
ContentMarkdown: "测试内容",
|
|
Summary: "测试摘要",
|
|
},
|
|
},
|
|
},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: gin.H{
|
|
"id": 1,
|
|
"status": "published",
|
|
"slug": "test-post",
|
|
"edges": gin.H{
|
|
"contents": []gin.H{
|
|
{
|
|
"language_code": "zh",
|
|
"title": "测试帖子",
|
|
"content_markdown": "测试内容",
|
|
"summary": "测试摘要",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Service error",
|
|
slug: "test-post",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
GetPostBySlug(gomock.Any(), "en", "test-post").
|
|
Return(nil, errors.New("service error"))
|
|
},
|
|
expectedStatus: http.StatusInternalServerError,
|
|
expectedBody: gin.H{"error": "Failed to get post"},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
s.Run(tc.name, func() {
|
|
tc.setupMock()
|
|
|
|
url := "/api/v1/posts/" + tc.slug
|
|
if tc.langCode != "" {
|
|
url += "?lang=" + tc.langCode
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodGet, url, nil)
|
|
w := httptest.NewRecorder()
|
|
s.router.ServeHTTP(w, req)
|
|
|
|
s.Equal(tc.expectedStatus, w.Code, "HTTP status code mismatch")
|
|
|
|
if tc.expectedBody != nil {
|
|
expectedJSON, err := json.Marshal(tc.expectedBody)
|
|
s.NoError(err, "Failed to marshal expected body")
|
|
s.JSONEq(string(expectedJSON), w.Body.String(), "Response body mismatch")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test cases for CreatePost
|
|
func (s *PostHandlerTestSuite) TestCreatePost() {
|
|
testCases := []struct {
|
|
name string
|
|
setupMock func()
|
|
expectedStatus int
|
|
expectedBody interface{}
|
|
}{
|
|
{
|
|
name: "Success",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
CreatePost(gomock.Any(), "draft").
|
|
Return(&ent.Post{
|
|
ID: 1,
|
|
Status: "draft",
|
|
Edges: ent.PostEdges{
|
|
Contents: []*ent.PostContent{},
|
|
},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusCreated,
|
|
expectedBody: gin.H{
|
|
"id": 1,
|
|
"status": "draft",
|
|
"edges": gin.H{
|
|
"contents": []gin.H{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Service error",
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
CreatePost(gomock.Any(), "draft").
|
|
Return(nil, errors.New("service error"))
|
|
},
|
|
expectedStatus: http.StatusInternalServerError,
|
|
expectedBody: gin.H{"error": "Failed to create post"},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
s.Run(tc.name, func() {
|
|
tc.setupMock()
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/v1/posts", nil)
|
|
w := httptest.NewRecorder()
|
|
s.router.ServeHTTP(w, req)
|
|
|
|
s.Equal(tc.expectedStatus, w.Code, "HTTP status code mismatch")
|
|
|
|
if tc.expectedBody != nil {
|
|
expectedJSON, err := json.Marshal(tc.expectedBody)
|
|
s.NoError(err, "Failed to marshal expected body")
|
|
s.JSONEq(string(expectedJSON), w.Body.String(), "Response body mismatch")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test cases for AddPostContent
|
|
func (s *PostHandlerTestSuite) TestAddPostContent() {
|
|
testCases := []struct {
|
|
name string
|
|
postID string
|
|
body interface{}
|
|
setupMock func()
|
|
expectedStatus int
|
|
expectedBody interface{}
|
|
}{
|
|
{
|
|
name: "Success",
|
|
postID: "1",
|
|
body: AddPostContentRequest{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
MetaKeywords: "test,keywords",
|
|
MetaDescription: "Test meta description",
|
|
},
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
AddPostContent(
|
|
gomock.Any(),
|
|
1,
|
|
"en",
|
|
"Test Post",
|
|
"Test Content",
|
|
"Test Summary",
|
|
"test,keywords",
|
|
"Test meta description",
|
|
).
|
|
Return(&ent.PostContent{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
MetaKeywords: "test,keywords",
|
|
MetaDescription: "Test meta description",
|
|
Edges: ent.PostContentEdges{},
|
|
}, nil)
|
|
},
|
|
expectedStatus: http.StatusCreated,
|
|
expectedBody: gin.H{
|
|
"language_code": "en",
|
|
"title": "Test Post",
|
|
"content_markdown": "Test Content",
|
|
"summary": "Test Summary",
|
|
"meta_keywords": "test,keywords",
|
|
"meta_description": "Test meta description",
|
|
"edges": gin.H{},
|
|
},
|
|
},
|
|
{
|
|
name: "Invalid post ID",
|
|
postID: "invalid",
|
|
body: AddPostContentRequest{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
},
|
|
setupMock: func() {},
|
|
expectedStatus: http.StatusBadRequest,
|
|
expectedBody: gin.H{"error": "Invalid post ID"},
|
|
},
|
|
{
|
|
name: "Invalid request body",
|
|
postID: "1",
|
|
body: map[string]interface{}{
|
|
"language_code": "en",
|
|
// Missing required fields
|
|
},
|
|
setupMock: func() {},
|
|
expectedStatus: http.StatusBadRequest,
|
|
expectedBody: gin.H{"error": "Key: 'AddPostContentRequest.Title' Error:Field validation for 'Title' failed on the 'required' tag\nKey: 'AddPostContentRequest.ContentMarkdown' Error:Field validation for 'ContentMarkdown' failed on the 'required' tag\nKey: 'AddPostContentRequest.Summary' Error:Field validation for 'Summary' failed on the 'required' tag"},
|
|
},
|
|
{
|
|
name: "Service error",
|
|
postID: "1",
|
|
body: AddPostContentRequest{
|
|
LanguageCode: "en",
|
|
Title: "Test Post",
|
|
ContentMarkdown: "Test Content",
|
|
Summary: "Test Summary",
|
|
MetaKeywords: "test,keywords",
|
|
MetaDescription: "Test meta description",
|
|
},
|
|
setupMock: func() {
|
|
s.service.EXPECT().
|
|
AddPostContent(
|
|
gomock.Any(),
|
|
1,
|
|
"en",
|
|
"Test Post",
|
|
"Test Content",
|
|
"Test Summary",
|
|
"test,keywords",
|
|
"Test meta description",
|
|
).
|
|
Return(nil, errors.New("service error"))
|
|
},
|
|
expectedStatus: http.StatusInternalServerError,
|
|
expectedBody: gin.H{"error": "Failed to add post content"},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
s.Run(tc.name, func() {
|
|
tc.setupMock()
|
|
|
|
body, err := json.Marshal(tc.body)
|
|
s.NoError(err, "Failed to marshal request body")
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/v1/posts/"+tc.postID+"/contents", bytes.NewReader(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
s.router.ServeHTTP(w, req)
|
|
|
|
s.Equal(tc.expectedStatus, w.Code, "HTTP status code mismatch")
|
|
|
|
if tc.expectedBody != nil {
|
|
expectedJSON, err := json.Marshal(tc.expectedBody)
|
|
s.NoError(err, "Failed to marshal expected body")
|
|
s.JSONEq(string(expectedJSON), w.Body.String(), "Response body mismatch")
|
|
}
|
|
})
|
|
}
|
|
}
|