gohorsejobs/backend/internal/services/admin_service_test.go

package services

import (
	"context"
	"testing"
	"time"

	"github.com/DATA-DOG/go-sqlmock"
)

func TestAdminService_ListCompanies(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("Failed to create mock db: %v", err)
	}
	defer db.Close()

	service := NewAdminService(db)
	ctx := context.Background()

	t.Run("returns empty list when no companies", func(t *testing.T) {
		// Count query
		mock.ExpectQuery("SELECT COUNT").WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
		// Data query
		mock.ExpectQuery("SELECT id, name, slug").WillReturnRows(sqlmock.NewRows([]string{
			"id", "name", "slug", "type", "document", "address", "region_id", "city_id",
			"phone", "email", "website", "logo_url", "description", "active", "verified",
			"created_at", "updated_at",
		}))

		companies, total, err := service.ListCompanies(ctx, nil, 1, 10)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}
		if total != 0 {
			t.Errorf("Expected total=0, got %d", total)
		}
		if len(companies) != 0 {
			t.Errorf("Expected 0 companies, got %d", len(companies))
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})

	t.Run("filters by verified status", func(t *testing.T) {
		verified := true
		mock.ExpectQuery("SELECT COUNT").WithArgs(verified).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
		mock.ExpectQuery("SELECT id, name, slug").WithArgs(verified, 10, 0).WillReturnRows(sqlmock.NewRows([]string{
			"id", "name", "slug", "type", "document", "address", "region_id", "city_id",
			"phone", "email", "website", "logo_url", "description", "active", "verified",
			"created_at", "updated_at",
		}))

		_, _, err := service.ListCompanies(ctx, &verified, 1, 10)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})
}

func TestAdminService_ListTags(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("Failed to create mock db: %v", err)
	}
	defer db.Close()

	service := NewAdminService(db)
	ctx := context.Background()

	t.Run("returns empty list when no tags", func(t *testing.T) {
		mock.ExpectQuery("SELECT id, name, category, active, created_at, updated_at FROM job_tags").
			WillReturnRows(sqlmock.NewRows([]string{"id", "name", "category", "active", "created_at", "updated_at"}))

		tags, err := service.ListTags(ctx, nil)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}
		if len(tags) != 0 {
			t.Errorf("Expected 0 tags, got %d", len(tags))
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})

	t.Run("filters by category", func(t *testing.T) {
		category := "stack"
		mock.ExpectQuery("SELECT id, name, category, active, created_at, updated_at FROM job_tags WHERE category").
			WithArgs(category).
			WillReturnRows(sqlmock.NewRows([]string{"id", "name", "category", "active", "created_at", "updated_at"}))

		_, err := service.ListTags(ctx, &category)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})
}

func TestAdminService_CreateTag(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("Failed to create mock db: %v", err)
	}
	defer db.Close()

	service := NewAdminService(db)
	ctx := context.Background()

	t.Run("creates a new tag", func(t *testing.T) {
		mock.ExpectQuery("INSERT INTO job_tags").
			WithArgs("Go", "stack", true, sqlmock.AnyArg(), sqlmock.AnyArg()).
			WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(1))

		tag, err := service.CreateTag(ctx, "Go", "stack")
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}
		if tag == nil {
			t.Fatal("Expected tag, got nil")
		}
		if tag.Name != "Go" {
			t.Errorf("Expected name='Go', got '%s'", tag.Name)
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})

	t.Run("rejects empty tag name", func(t *testing.T) {
		_, err := service.CreateTag(ctx, "   ", "stack")
		if err == nil {
			t.Error("Expected error for empty tag name")
		}
	})
}

func TestAdminService_GetUser(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("Failed to create mock db: %v", err)
	}
	defer db.Close()

	service := NewAdminService(db)
	ctx := context.Background()

	t.Run("returns user by id", func(t *testing.T) {
		userID := "019b5290-9680-7c06-9ee3-c9e0e117251b"
		now := time.Now()
		mock.ExpectQuery("SELECT id, full_name, email, role, created_at FROM users WHERE id").
			WithArgs(userID).
			WillReturnRows(sqlmock.NewRows([]string{"id", "name", "email", "role", "created_at"}).
				AddRow(userID, "Test User", "test@example.com", "admin", now))

		user, err := service.GetUser(ctx, userID)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}
		if user == nil {
			t.Fatal("Expected user, got nil")
		}
		if user.Name != "Test User" {
			t.Errorf("Expected name='Test User', got '%s'", user.Name)
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})
}

func TestAdminService_UpdateCompanyStatus(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("Failed to create mock db: %v", err)
	}
	defer db.Close()

	service := NewAdminService(db)
	ctx := context.Background()

	companyColumns := []string{
		"id", "name", "slug", "type", "document", "address", "region_id", "city_id",
		"phone", "email", "website", "logo_url", "description", "active", "verified",
		"created_at", "updated_at",
	}

	t.Run("updates active status successfully", func(t *testing.T) {
		companyID := "019b5290-9680-7c06-9ee3-c9e0e117251c"
		now := time.Now()
		active := false

		// First: getCompanyByID query
		mock.ExpectQuery("SELECT id, name, slug").
			WithArgs(companyID).
			WillReturnRows(sqlmock.NewRows(companyColumns).
				AddRow(companyID, "Test Company", "test-company", "employer", nil, nil, nil, nil,
					nil, "test@company.com", nil, nil, nil, true, false, now, now))

		// Then: UPDATE query
		mock.ExpectExec("UPDATE companies").
			WithArgs(false, false, sqlmock.AnyArg(), companyID).
			WillReturnResult(sqlmock.NewResult(0, 1))

		company, err := service.UpdateCompanyStatus(ctx, companyID, &active, nil)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}
		if company == nil {
			t.Fatal("Expected company, got nil")
		}
		if company.Active != false {
			t.Errorf("Expected active=false, got %v", company.Active)
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})

	t.Run("updates verified status successfully", func(t *testing.T) {
		companyID := "019b5290-9680-7c06-9ee3-c9e0e117251d"
		now := time.Now()
		verified := true

		mock.ExpectQuery("SELECT id, name, slug").
			WithArgs(companyID).
			WillReturnRows(sqlmock.NewRows(companyColumns).
				AddRow(companyID, "Pending Company", "pending-company", "employer", nil, nil, nil, nil,
					nil, "pending@company.com", nil, nil, nil, true, false, now, now))

		mock.ExpectExec("UPDATE companies").
			WithArgs(true, true, sqlmock.AnyArg(), companyID).
			WillReturnResult(sqlmock.NewResult(0, 1))

		company, err := service.UpdateCompanyStatus(ctx, companyID, nil, &verified)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}
		if company == nil {
			t.Fatal("Expected company, got nil")
		}
		if company.Verified != true {
			t.Errorf("Expected verified=true, got %v", company.Verified)
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})

	t.Run("returns error when company not found", func(t *testing.T) {
		companyID := "non-existent-id"
		active := false

		mock.ExpectQuery("SELECT id, name, slug").
			WithArgs(companyID).
			WillReturnError(err)

		_, updateErr := service.UpdateCompanyStatus(ctx, companyID, &active, nil)
		if updateErr == nil {
			t.Error("Expected error for non-existent company")
		}

		if err := mock.ExpectationsWereMet(); err != nil {
			t.Errorf("Unmet expectations: %v", err)
		}
	})
}