byom-customer-api/handlers/profile_test.go

package handlers

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"git.linuxforward.com/byom/byom-core/common"
	"git.linuxforward.com/byom/byom-core/errors"
	"git.linuxforward.com/byom/byom-core/middleware"
	testhelpers "git.linuxforward.com/byom/byom-core/testing"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestProfileHandler_Create(t *testing.T) {
	// Setup test database and handler
	store := testhelpers.TestDB(t)
	handler := NewProfileHandler(store)

	// Setup gin test router with error handler
	gin.SetMode(gin.TestMode)
	router := gin.New()
	router.Use(middleware.ErrorHandler())
	router.POST("/api/v1/core/profiles", handler.Create)

	tests := []struct {
		name          string
		request       *common.ProfileCreateRequest
		expectedCode  int
		expectedError string
	}{
		{
			name: "valid_request",
			request: &common.ProfileCreateRequest{
				Name:        "Test Profile",
				WorkspaceID: uuid.New(),
			},
			expectedCode: http.StatusCreated,
		},
		{
			name: "missing_name",
			request: &common.ProfileCreateRequest{
				WorkspaceID: uuid.New(),
			},
			expectedCode:  http.StatusBadRequest,
			expectedError: "Invalid request format",
		},
		{
			name: "missing_workspace_ID",
			request: &common.ProfileCreateRequest{
				Name: "Test Profile",
			},
			expectedCode:  http.StatusBadRequest,
			expectedError: "Invalid request format",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			body, err := json.Marshal(tt.request)
			require.NoError(t, err)

			w := httptest.NewRecorder()
			req := httptest.NewRequest(http.MethodPost, "/api/v1/core/profiles", bytes.NewReader(body))
			req.Header.Set("Content-Type", "application/json")
			router.ServeHTTP(w, req)

			assert.Equal(t, tt.expectedCode, w.Code)
			if tt.expectedError != "" {
				var resp gin.H
				err := json.NewDecoder(w.Body).Decode(&resp)
				require.NoError(t, err)
				assert.Equal(t, tt.expectedError, resp["error"])
			}
		})
	}
}

func TestProfileHandler_Get(t *testing.T) {
	// Setup test database and handler
	store := testhelpers.TestDB(t)
	handler := NewProfileHandler(store)

	// Create a test profile
	testProfile := &common.Profile{
		ID:          uuid.New(),
		Name:        "Test Profile",
		WorkspaceID: uuid.New(),
	}
	ctx, cancel := testhelpers.TestContext()
	defer cancel()
	err := store.CreateProfile(ctx, testProfile)
	require.NoError(t, err)

	// Setup gin test router with error handler
	gin.SetMode(gin.TestMode)
	router := gin.New()
	router.Use(middleware.ErrorHandler())
	router.GET("/api/v1/core/profiles/:id", handler.Get)

	tests := []struct {
		name          string
		profileID     string
		expectedCode  int
		expectedError *errors.AppError
	}{
		{
			name:         "existing_profile",
			profileID:    testProfile.ID.String(),
			expectedCode: http.StatusOK,
		},
		{
			name:         "non-existent_profile",
			profileID:    uuid.New().String(),
			expectedCode: http.StatusNotFound,
			expectedError: &errors.AppError{
				Type:    errors.ErrorTypeNotFound,
				Message: "Profile not found",
			},
		},
		{
			name:         "invalid_UUID",
			profileID:    "invalid-uuid",
			expectedCode: http.StatusBadRequest,
			expectedError: &errors.AppError{
				Type:    errors.ErrorTypeValidation,
				Message: "Profile ID is required",
				Field:   "id",
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			w := httptest.NewRecorder()
			req := httptest.NewRequest(http.MethodGet, "/api/v1/core/profiles/"+tt.profileID, nil)
			router.ServeHTTP(w, req)

			assert.Equal(t, tt.expectedCode, w.Code)

			if tt.expectedError != nil {
				var resp errors.AppError
				err := json.NewDecoder(w.Body).Decode(&resp)
				require.NoError(t, err)
				assert.Equal(t, tt.expectedError.Type, resp.Type)
				assert.Equal(t, tt.expectedError.Message, resp.Message)
				if tt.expectedError.Field != "" {
					assert.Equal(t, tt.expectedError.Field, resp.Field)
				}
			} else {
				var resp common.ProfileResponse
				err := json.NewDecoder(w.Body).Decode(&resp)
				require.NoError(t, err)
				assert.Equal(t, testProfile.ID, resp.Profile.ID)
				assert.Equal(t, testProfile.Name, resp.Profile.Name)
				assert.Equal(t, testProfile.WorkspaceID, resp.Profile.WorkspaceID)
			}
		})
	}
}