132 lines
3.5 KiB
Go
132 lines
3.5 KiB
Go
package database
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/debian/deb-orchestrator/internal/models"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// TestServiceIntegration tests the complete service layer integration
|
|
func TestServiceIntegration(t *testing.T) {
|
|
service := NewMockService()
|
|
require.NotNil(t, service)
|
|
|
|
t.Run("Complete Task Lifecycle", func(t *testing.T) {
|
|
// Create a task
|
|
taskReq := models.TaskRequest{
|
|
Method: "build",
|
|
Args: []string{"package1", "package2"},
|
|
Priority: 1,
|
|
Arch: "amd64",
|
|
Channel: "stable",
|
|
}
|
|
task := models.NewTask(taskReq)
|
|
|
|
// Test task creation
|
|
err := service.CreateTask(task)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, int64(1), task.ID)
|
|
|
|
// Test task assignment
|
|
err = service.AssignTask(task.ID, 1)
|
|
assert.NoError(t, err)
|
|
|
|
// Test task start
|
|
err = service.StartTask(task.ID)
|
|
assert.NoError(t, err)
|
|
|
|
// Test task completion
|
|
err = service.CompleteTask(task.ID, "Build completed successfully")
|
|
assert.NoError(t, err)
|
|
|
|
// Verify final state
|
|
retrievedTask, err := service.GetTaskByID(task.ID)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, models.TaskStateCompleted, retrievedTask.State)
|
|
assert.Equal(t, "Build completed successfully", retrievedTask.Result)
|
|
})
|
|
|
|
t.Run("Complete Host Lifecycle", func(t *testing.T) {
|
|
// Create a host
|
|
hostReq := models.HostRequest{
|
|
Name: "integration-test-host",
|
|
Arch: "amd64",
|
|
Channel: "stable",
|
|
Capacity: 10,
|
|
Hostname: "192.168.1.100",
|
|
Port: 22,
|
|
Capabilities: map[string]interface{}{"docker": true, "build": true},
|
|
}
|
|
host := models.NewHost(hostReq)
|
|
|
|
// Test host creation
|
|
err := service.CreateHost(host)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, int64(1), host.ID)
|
|
|
|
// Test host load update
|
|
err = service.UpdateHostLoad(host.ID, 5)
|
|
assert.NoError(t, err)
|
|
|
|
// Test host heartbeat (using Heartbeat method)
|
|
err = service.Heartbeat(host.ID)
|
|
assert.NoError(t, err)
|
|
|
|
// Test host state update
|
|
err = service.UpdateHostState(host.ID, models.HostStateBusy)
|
|
assert.NoError(t, err)
|
|
|
|
// Verify final state
|
|
retrievedHost, err := service.GetHostByID(host.ID)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, models.HostStateBusy, retrievedHost.State)
|
|
assert.Equal(t, 5, retrievedHost.CurrentLoad)
|
|
assert.True(t, retrievedHost.IsAvailable())
|
|
})
|
|
}
|
|
|
|
// TestServiceConcurrency tests concurrent access patterns
|
|
func TestServiceConcurrency(t *testing.T) {
|
|
service := NewMockService()
|
|
require.NotNil(t, service)
|
|
|
|
// Test concurrent host creation
|
|
const numHosts = 20
|
|
errors := make(chan error, numHosts)
|
|
|
|
for i := 0; i < numHosts; i++ {
|
|
go func(id int) {
|
|
hostReq := models.HostRequest{
|
|
Name: fmt.Sprintf("concurrent-host-%d", id),
|
|
Arch: "amd64",
|
|
Channel: "stable",
|
|
Capacity: id%10 + 1,
|
|
Hostname: fmt.Sprintf("192.168.1.%d", 200+id),
|
|
Port: 22,
|
|
Capabilities: map[string]interface{}{"build": true},
|
|
}
|
|
host := models.NewHost(hostReq)
|
|
err := service.CreateHost(host)
|
|
errors <- err
|
|
}(i)
|
|
}
|
|
|
|
// Collect results
|
|
for i := 0; i < numHosts; i++ {
|
|
err := <-errors
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
// Verify all hosts were created
|
|
stats, err := service.GetHostStats()
|
|
assert.NoError(t, err)
|
|
// Check if stats is a map and has the expected structure
|
|
if hostStats, ok := stats.(map[string]int); ok {
|
|
assert.GreaterOrEqual(t, hostStats["total_hosts"], numHosts)
|
|
} else {
|
|
t.Logf("Stats type: %T, value: %v", stats, stats)
|
|
}
|
|
}
|