296 lines
7.4 KiB
Go
296 lines
7.4 KiB
Go
package tests
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"mohportal/config"
|
|
"mohportal/db"
|
|
"mohportal/models"
|
|
"mohportal/handlers"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/assert"
|
|
"gorm.io/driver/sqlite"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
var testDB *gorm.DB
|
|
|
|
func init() {
|
|
// Initialize test database
|
|
var err error
|
|
testDB, err = gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
|
|
if err != nil {
|
|
panic("failed to connect to test database")
|
|
}
|
|
|
|
// Run migrations
|
|
err = testDB.AutoMigrate(
|
|
&models.Tenant{},
|
|
&models.User{},
|
|
&models.OIDCIdentity{},
|
|
&models.SocialIdentity{},
|
|
&models.JobPosition{},
|
|
&models.Resume{},
|
|
&models.Application{},
|
|
)
|
|
if err != nil {
|
|
panic("failed to migrate test database")
|
|
}
|
|
|
|
// Replace the main DB with test DB
|
|
db.DB = testDB
|
|
}
|
|
|
|
func setupRouter() *gin.Engine {
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
|
|
// Health check endpoint
|
|
router.GET("/health", handlers.HealthCheck)
|
|
|
|
// API routes
|
|
api := router.Group("/api/v1")
|
|
{
|
|
tenants := api.Group("/tenants")
|
|
{
|
|
tenants.POST("/", handlers.CreateTenant)
|
|
tenants.GET("/", handlers.GetTenants)
|
|
tenants.GET("/:id", handlers.GetTenant)
|
|
}
|
|
|
|
auth := api.Group("/auth")
|
|
{
|
|
auth.POST("/login", handlers.Login)
|
|
auth.POST("/register", handlers.Register)
|
|
}
|
|
|
|
positions := api.Group("/positions")
|
|
{
|
|
positions.GET("/", handlers.GetPositions)
|
|
positions.GET("/:id", handlers.GetPosition)
|
|
positions.POST("/", handlers.CreatePosition)
|
|
}
|
|
|
|
applications := api.Group("/applications")
|
|
{
|
|
applications.GET("/", handlers.GetApplications)
|
|
applications.POST("/", handlers.CreateApplication)
|
|
}
|
|
|
|
resumes := api.Group("/resumes")
|
|
{
|
|
resumes.POST("/", handlers.UploadResume)
|
|
resumes.GET("/:id", handlers.GetResume)
|
|
}
|
|
}
|
|
|
|
return router
|
|
}
|
|
|
|
func TestHealthCheck(t *testing.T) {
|
|
router := setupRouter()
|
|
|
|
req, _ := http.NewRequest("GET", "/health", nil)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
var response map[string]interface{}
|
|
err := json.Unmarshal(w.Body.Bytes(), &response)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "healthy", response["status"])
|
|
}
|
|
|
|
func TestCreateTenant(t *testing.T) {
|
|
router := setupRouter()
|
|
|
|
tenantData := map[string]string{
|
|
"name": "Test Tenant",
|
|
"slug": "test-tenant",
|
|
"description": "A test tenant for testing purposes",
|
|
}
|
|
|
|
jsonData, _ := json.Marshal(tenantData)
|
|
req, _ := http.NewRequest("POST", "/api/v1/tenants/", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusCreated, w.Code)
|
|
}
|
|
|
|
func TestGetTenants(t *testing.T) {
|
|
router := setupRouter()
|
|
|
|
req, _ := http.NewRequest("GET", "/api/v1/tenants/", nil)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
}
|
|
|
|
func TestCreateUser(t *testing.T) {
|
|
// First create a tenant for the user
|
|
var tenant models.Tenant
|
|
tenantData := map[string]string{
|
|
"name": "Test Tenant",
|
|
"slug": "test-tenant-user",
|
|
"description": "A test tenant for user testing",
|
|
}
|
|
|
|
jsonData, _ := json.Marshal(tenantData)
|
|
|
|
router := setupRouter()
|
|
req, _ := http.NewRequest("POST", "/api/v1/tenants/", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusCreated, w.Code)
|
|
|
|
err := json.Unmarshal(w.Body.Bytes(), &tenant)
|
|
assert.NoError(t, err)
|
|
|
|
// Now register a user
|
|
userData := map[string]interface{}{
|
|
"tenant_id": tenant.ID.String(),
|
|
"email": "test@example.com",
|
|
"username": "testuser",
|
|
"first_name": "Test",
|
|
"last_name": "User",
|
|
"phone": "1234567890",
|
|
"role": "job_seeker",
|
|
"password": "password123",
|
|
}
|
|
|
|
jsonData, _ = json.Marshal(userData)
|
|
req, _ = http.NewRequest("POST", "/api/v1/auth/register", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w = httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusCreated, w.Code)
|
|
}
|
|
|
|
func TestLogin(t *testing.T) {
|
|
// First create a user for login test
|
|
router := setupRouter()
|
|
|
|
// Create a tenant first
|
|
tenantData := map[string]string{
|
|
"name": "Test Tenant",
|
|
"slug": "test-tenant-login",
|
|
"description": "A test tenant for login testing",
|
|
}
|
|
jsonData, _ := json.Marshal(tenantData)
|
|
|
|
req, _ := http.NewRequest("POST", "/api/v1/tenants/", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
var tenant models.Tenant
|
|
err := json.Unmarshal(w.Body.Bytes(), &tenant)
|
|
assert.NoError(t, err)
|
|
|
|
// Create a user
|
|
userData := map[string]interface{}{
|
|
"tenant_id": tenant.ID.String(),
|
|
"email": "login@example.com",
|
|
"username": "loginuser",
|
|
"first_name": "Login",
|
|
"last_name": "User",
|
|
"phone": "0987654321",
|
|
"role": "job_seeker",
|
|
"password": "password123",
|
|
}
|
|
jsonData, _ = json.Marshal(userData)
|
|
|
|
req, _ = http.NewRequest("POST", "/api/v1/auth/register", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w = httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusCreated, w.Code)
|
|
|
|
// Now try to login
|
|
loginData := map[string]string{
|
|
"email": "login@example.com",
|
|
"password": "password123",
|
|
}
|
|
jsonData, _ = json.Marshal(loginData)
|
|
|
|
req, _ = http.NewRequest("POST", "/api/v1/auth/login", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w = httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
}
|
|
|
|
func TestCreateJobPosition(t *testing.T) {
|
|
router := setupRouter()
|
|
|
|
// Create a tenant and user first
|
|
tenantData := map[string]string{
|
|
"name": "Test Tenant",
|
|
"slug": "test-tenant-position",
|
|
"description": "A test tenant for position testing",
|
|
}
|
|
jsonData, _ := json.Marshal(tenantData)
|
|
|
|
req, _ := http.NewRequest("POST", "/api/v1/tenants/", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
var tenant models.Tenant
|
|
err := json.Unmarshal(w.Body.Bytes(), &tenant)
|
|
assert.NoError(t, err)
|
|
|
|
// Create a user
|
|
userData := map[string]interface{}{
|
|
"tenant_id": tenant.ID.String(),
|
|
"email": "position@example.com",
|
|
"username": "positionuser",
|
|
"first_name": "Position",
|
|
"last_name": "User",
|
|
"phone": "5555555555",
|
|
"role": "job_provider",
|
|
"password": "password123",
|
|
}
|
|
jsonData, _ = json.Marshal(userData)
|
|
|
|
req, _ = http.NewRequest("POST", "/api/v1/auth/register", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w = httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusCreated, w.Code)
|
|
|
|
// Now create a job position
|
|
positionData := map[string]interface{}{
|
|
"title": "Software Engineer",
|
|
"description": "A software engineering position",
|
|
"requirements": "3+ years of experience with Go",
|
|
"location": "Remote",
|
|
"employment_type": "full_time",
|
|
"salary_min": 80000.0,
|
|
"salary_max": 120000.0,
|
|
"experience_level": "mid_level",
|
|
}
|
|
|
|
jsonData, _ = json.Marshal(positionData)
|
|
req, _ = http.NewRequest("POST", "/api/v1/positions/", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w = httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusCreated, w.Code)
|
|
} |