arp/graph/resolver_test.go

package graph

import (
	"context"
	"strconv"
	"testing"

	"github.com/stretchr/testify/assert"
	"gogs.dmsc.dev/arp/models"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func setupTestDB() (*gorm.DB, error) {
	// Use in-memory SQLite database for testing
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	if err != nil {
		return nil, err
	}

	// Run auto-migration for all models
	err = db.AutoMigrate(&models.User{}, &models.Role{}, &models.Permission{}, &models.Service{}, &models.Task{}, &models.TaskStatus{}, &models.Channel{}, &models.Message{}, &models.Note{})
	if err != nil {
		return nil, err
	}

	return db, nil
}

func TestResolver_UserQueries(t *testing.T) {
	// Setup test database
	db, err := setupTestDB()
	assert.NoError(t, err)

	// Create resolver with test DB
	resolver := &Resolver{DB: db}
	queryResolver := &queryResolver{resolver}

	// Test creating a user
	ctx := context.Background()

	// Create a user directly without complex relationships for now
	user := models.User{
		Email:    "test@example.com",
		Password: "hashed-password",
	}
	err = db.Create(&user).Error
	assert.NoError(t, err)

	// Test querying users
	users, err := queryResolver.Users(ctx)
	assert.NoError(t, err)
	assert.NotNil(t, users)
	assert.Len(t, users, 1)

	// Test querying a single user by ID
	userResult, err := queryResolver.User(ctx, strconv.FormatUint(uint64(user.ID), 10))
	assert.NoError(t, err)
	assert.NotNil(t, userResult)
	assert.Equal(t, user.Email, userResult.Email)
}

func TestResolver_RoleQueries(t *testing.T) {
	// Setup test database
	db, err := setupTestDB()
	assert.NoError(t, err)

	// Create resolver with test DB
	resolver := &Resolver{DB: db}
	queryResolver := &queryResolver{resolver}

	// Test creating a role
	ctx := context.Background()

	role := models.Role{
		Name:        "admin",
		Description: "Administrator role",
	}
	err = db.Create(&role).Error
	assert.NoError(t, err)

	// Test querying roles
	roles, err := queryResolver.Roles(ctx)
	assert.NoError(t, err)
	assert.NotNil(t, roles)
	assert.Len(t, roles, 1)

	// Test querying a single role by ID
	roleResult, err := queryResolver.Role(ctx, strconv.FormatUint(uint64(role.ID), 10))
	assert.NoError(t, err)
	assert.NotNil(t, roleResult)
	assert.Equal(t, role.Name, roleResult.Name)
}

func TestResolver_ServiceQueries(t *testing.T) {
	// Setup test database
	db, err := setupTestDB()
	assert.NoError(t, err)

	// Create resolver with test DB
	resolver := &Resolver{DB: db}
	queryResolver := &queryResolver{resolver}

	// Test creating a service
	ctx := context.Background()

	service := models.Service{
		Name:        "Test Service",
		Description: "A test service",
	}
	err = db.Create(&service).Error
	assert.NoError(t, err)

	// Test querying services
	services, err := queryResolver.Services(ctx)
	assert.NoError(t, err)
	assert.NotNil(t, services)
	assert.Len(t, services, 1)

	// Test querying a single service by ID
	serviceResult, err := queryResolver.Service(ctx, strconv.FormatUint(uint64(service.ID), 10))
	assert.NoError(t, err)
	assert.NotNil(t, serviceResult)
	assert.Equal(t, service.Name, serviceResult.Name)
}