tp/main_dc/yalarba/api_yal/tests/integration/comment_test.go

package integration

import (
    "testing"
    "api_yal/tests/testutils"
)

func TestCommentEndpoints(t *testing.T) {
    config := testutils.NewTestConfig()

    t.Run("CreateComment", func(t *testing.T) {
        user := config.CreateTestUser(t)
        defer config.CleanupTestUser(t, user)

        objectID := config.CreateTestObject(t, user.Token)
        feedbackID := config.CreateTestFeedback(t, user.Token, objectID)

        commentData := testutils.CreateCommentRequest{
            FeedbackID: feedbackID,
            Text:       "Great review! I agree completely.",
        }

        resp, err := config.Request("POST", "/comments", commentData, user.Token)
        if err != nil {
            t.Fatalf("Failed to create comment: %v", err)
        }
        defer resp.Body.Close()

        if resp.StatusCode != 201 {
            t.Errorf("Expected status 201, got %d", resp.StatusCode)
        }

        var createdComment map[string]interface{}
        if err := config.ParseResponse(resp, &createdComment); err != nil {
            t.Fatalf("Failed to parse response: %v", err)
        }

        if _, ok := createdComment["id"]; !ok {
            t.Error("Comment ID not found")
        }
    })

    t.Run("GetCommentByID", func(t *testing.T) {
        user := config.CreateTestUser(t)
        defer config.CleanupTestUser(t, user)

        objectID := config.CreateTestObject(t, user.Token)
        feedbackID := config.CreateTestFeedback(t, user.Token, objectID)

        // Создаем комментарий
        commentData := testutils.CreateCommentRequest{
            FeedbackID: feedbackID,
            Text:       "Test comment",
        }
        resp, err := config.Request("POST", "/comments", commentData, user.Token)
        if err != nil {
            t.Fatalf("Failed to create comment: %v", err)
        }
        defer resp.Body.Close()

        var createdComment map[string]interface{}
        if err := config.ParseResponse(resp, &createdComment); err != nil {
            t.Fatalf("Failed to parse response: %v", err)
        }

        commentID := createdComment["id"].(float64)

        getResp, err := config.Request("GET", "/comments/"+string(rune(commentID)), nil, "")
        if err != nil {
            t.Fatalf("Failed to get comment: %v", err)
        }
        defer getResp.Body.Close()

        if getResp.StatusCode != 200 {
            t.Errorf("Expected status 200, got %d", getResp.StatusCode)
        }
    })

    t.Run("UpdateComment", func(t *testing.T) {
        user := config.CreateTestUser(t)
        defer config.CleanupTestUser(t, user)

        objectID := config.CreateTestObject(t, user.Token)
        feedbackID := config.CreateTestFeedback(t, user.Token, objectID)

        // Создаем комментарий
        commentData := testutils.CreateCommentRequest{
            FeedbackID: feedbackID,
            Text:       "Original comment",
        }
        resp, err := config.Request("POST", "/comments", commentData, user.Token)
        if err != nil {
            t.Fatalf("Failed to create comment: %v", err)
        }
        defer resp.Body.Close()

        var createdComment map[string]interface{}
        if err := config.ParseResponse(resp, &createdComment); err != nil {
            t.Fatalf("Failed to parse response: %v", err)
        }

        commentID := createdComment["id"].(float64)

        updateData := map[string]interface{}{
            "text": "Updated comment text",
        }

        updateResp, err := config.Request("PUT", "/comments/"+string(rune(commentID)), updateData, user.Token)
        if err != nil {
            t.Fatalf("Failed to update comment: %v", err)
        }
        defer updateResp.Body.Close()

        if updateResp.StatusCode != 200 {
            t.Errorf("Expected status 200, got %d", updateResp.StatusCode)
        }
    })

    t.Run("ListComments", func(t *testing.T) {
        resp, err := config.Request("GET", "/comments?page=1&page_size=20", nil, "")
        if err != nil {
            t.Fatalf("Failed to list comments: %v", err)
        }
        defer resp.Body.Close()

        if resp.StatusCode != 200 {
            t.Errorf("Expected status 200, got %d", resp.StatusCode)
        }
    })

    t.Run("MyComments", func(t *testing.T) {
        user := config.CreateTestUser(t)
        defer config.CleanupTestUser(t, user)

        resp, err := config.Request("GET", "/comments/my", nil, user.Token)
        if err != nil {
            t.Fatalf("Failed to get my comments: %v", err)
        }
        defer resp.Body.Close()

        if resp.StatusCode != 200 {
            t.Errorf("Expected status 200, got %d", resp.StatusCode)
        }
    })

    t.Run("CommentsByFeedback", func(t *testing.T) {
        user := config.CreateTestUser(t)
        defer config.CleanupTestUser(t, user)

        objectID := config.CreateTestObject(t, user.Token)
        feedbackID := config.CreateTestFeedback(t, user.Token, objectID)

        resp, err := config.Request("GET", "/comments/feedback/"+string(rune(feedbackID)), nil, "")
        if err != nil {
            t.Fatalf("Failed to get comments by feedback: %v", err)
        }
        defer resp.Body.Close()

        if resp.StatusCode != 200 {
            t.Errorf("Expected status 200, got %d", resp.StatusCode)
        }
    })

    t.Run("CommentStats", func(t *testing.T) {
        resp, err := config.Request("GET", "/comments/stats", nil, "")
        if err != nil {
            t.Fatalf("Failed to get comment stats: %v", err)
        }
        defer resp.Body.Close()

        if resp.StatusCode != 200 {
            t.Errorf("Expected status 200, got %d", resp.StatusCode)
        }

        var stats map[string]interface{}
        if err := config.ParseResponse(resp, &stats); err != nil {
            t.Fatalf("Failed to parse response: %v", err)
        }

        expectedFields := []string{"total_comments", "verified_comments", "unverified_comments"}
        for _, field := range expectedFields {
            if _, ok := stats[field]; !ok {
                t.Errorf("Expected field %s not found", field)
            }
        }
    })

    t.Run("DeleteComment", func(t *testing.T) {
        user := config.CreateTestUser(t)
        defer config.CleanupTestUser(t, user)

        objectID := config.CreateTestObject(t, user.Token)
        feedbackID := config.CreateTestFeedback(t, user.Token, objectID)

        // Создаем комментарий
        commentData := testutils.CreateCommentRequest{
            FeedbackID: feedbackID,
            Text:       "Comment to delete",
        }
        resp, err := config.Request("POST", "/comments", commentData, user.Token)
        if err != nil {
            t.Fatalf("Failed to create comment: %v", err)
        }
        defer resp.Body.Close()

        var createdComment map[string]interface{}
        if err := config.ParseResponse(resp, &createdComment); err != nil {
            t.Fatalf("Failed to parse response: %v", err)
        }

        commentID := createdComment["id"].(float64)

        deleteResp, err := config.Request("DELETE", "/comments/"+string(rune(commentID)), nil, user.Token)
        if err != nil {
            t.Fatalf("Failed to delete comment: %v", err)
        }
        defer deleteResp.Body.Close()

        if deleteResp.StatusCode != 200 {
            t.Errorf("Expected status 200, got %d", deleteResp.StatusCode)
        }
    })
}