add first draft running queuer tests

Author: siherrmann

helper/database_test.go

@@ -11,12 +11,12 @@ import (
 	_ "github.com/lib/pq"
 )
 
-var port string
+var dbPort string
 
 func TestMain(m *testing.M) {
 	var teardown func(ctx context.Context, opts ...testcontainers.TerminateOption) error
 	var err error
-	teardown, port, err = MustStartPostgresContainer()
+	teardown, dbPort, err = MustStartPostgresContainer()
 	if err != nil {
 		log.Fatalf("error starting postgres container: %v", err)
 	}
@@ -29,14 +29,14 @@ func TestMain(m *testing.M) {
 }
 
 func TestNew(t *testing.T) {
-	dbConfig := NewTestDatabaseConfig(port)
+	dbConfig := NewTestDatabaseConfig(dbPort)
 	database := NewTestDatabase(dbConfig)
 
 	assert.NotNil(t, database, "expected NewDatabase to return a non-nil instance")
 }
 
 func TestHealth(t *testing.T) {
-	dbConfig := NewTestDatabaseConfig(port)
+	dbConfig := NewTestDatabaseConfig(dbPort)
 	database := NewTestDatabase(dbConfig)
 
 	stats := database.Health()
@@ -48,7 +48,7 @@ func TestHealth(t *testing.T) {
 }
 
 func TestClose(t *testing.T) {
-	dbConfig := NewTestDatabaseConfig(port)
+	dbConfig := NewTestDatabaseConfig(dbPort)
 	database := NewTestDatabase(dbConfig)
 
 	assert.NotNil(t, database, "expected NewDatabase to return a non-nil instance")

main_test.go

@@ -13,12 +13,12 @@ import (
 	"github.com/testcontainers/testcontainers-go"
 )
 
-var port string
+var dbPort string
 
 func TestMain(m *testing.M) {
 	var teardown func(ctx context.Context, opts ...testcontainers.TerminateOption) error
 	var err error
-	teardown, port, err = helper.MustStartPostgresContainer()
+	teardown, dbPort, err = helper.MustStartPostgresContainer()
 	if err != nil {
 		log.Fatalf("error starting postgres container: %v", err)
 	}
@@ -35,7 +35,7 @@ func newQueuerMock(name string, maxConcurrency int, options ...*model.OnError) *
 	logger := log.New(os.Stdout, "Queuer: ", log.Ltime)
 
 	// Database
-	dbConfig := helper.NewTestDatabaseConfig(port)
+	dbConfig := helper.NewTestDatabaseConfig(dbPort)
 	dbConnection := helper.NewTestDatabase(dbConfig)
 
 	// DBs

queuerJob.go

@@ -2,6 +2,7 @@ package queuer
 
 import (
 	"fmt"
+	"log"
 	"queuer/core"
 	"queuer/model"
 	"time"
@@ -191,6 +192,7 @@ func (q *Queuer) runJobInitial() error {
 			if err != nil {
 				return fmt.Errorf("error creating scheduler: %v", err)
 			}
+			log.Printf("Scheduling job with RID %v to run at %v", job.RID, job.Options.Schedule.Start)
 			go scheduler.Go(q.ctx)
 		} else {
 			go func() {

queuerJob_test.go

@@ -1,6 +1,7 @@
 package queuer
 
 import (
+	"context"
 	"queuer/model"
 	"strconv"
 	"testing"
@@ -11,28 +12,26 @@ import (
 )
 
 // Short running example task function
-func TaskMock(param1 int, param2 string) (int, error) {
+func TaskMock(duration int, param2 string) (int, error) {
 	// Simulate some work
-	time.Sleep(1 * time.Second)
+	time.Sleep(time.Duration(duration) * time.Second)
 
 	// Example for some error handling
 	param2Int, err := strconv.Atoi(param2)
 	if err != nil {
 		return 0, err
 	}
 
-	return param1 + param2Int, nil
+	return duration + param2Int, nil
 }
 
-// TestAddJob is a comprehensive test function for the AddJob method.
 func TestAddJob(t *testing.T) {
-	testQueuer := newQueuerMock("TestQueuer", 1)
+	testQueuer := newQueuerMock("TestQueuer", 100)
 
 	t.Run("Successfully adds a job with nil options", func(t *testing.T) {
 		expectedJob := &model.Job{
 			TaskName:   "queuer.TaskMock",
 			Parameters: model.Parameters{1.0, "2"},
-			Options:    nil,
 		}
 
 		params := []interface{}{1, "2"}
@@ -44,8 +43,35 @@ func TestAddJob(t *testing.T) {
 		assert.Equal(t, expectedJob.Options, job.Options, "AddJob should return the correct options")
 	})
 
+	t.Run("Successfully runs a job without options", func(t *testing.T) {
+		t.Parallel()
+		job, err := testQueuer.AddJob(TaskMock, 1, "2")
+		assert.NoError(t, err, "AddJob should not return an error on success")
+
+		queuedJob, err := testQueuer.GetJob(job.RID)
+		assert.NoError(t, err, "GetJob should not return an error")
+		assert.NotNil(t, queuedJob, "GetJob should return the job that is currently running")
+
+		// Initialize the queuer and start processing jobs
+		testQueuer.AddTask(TaskMock)
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		testQueuer.Start(ctx, cancel)
+
+		time.Sleep(2 * time.Second)
+
+		jobNotExisting, err := testQueuer.GetJob(job.RID)
+		assert.Error(t, err, "GetJob should return an error for cancelled job")
+		assert.Nil(t, jobNotExisting, "GetJob should return nil for cancelled job")
+
+		jobArchived, err := testQueuer.dbJob.SelectJobFromArchive(job.RID)
+		assert.NoError(t, err, "SelectJobFromArchive should not return an error for archived job")
+		assert.NotNil(t, jobArchived, "SelectJobFromArchive should return the archived job")
+		assert.Equal(t, jobArchived.Status, model.JobStatusSucceeded, "Archived job should have status Succeeded")
+	})
+
 	t.Run("Returns error for nil function", func(t *testing.T) {
-		var nilTask func() // A nil function is a common nil interface{} variant
+		var nilTask func() // Invalid nil function
 		job, err := testQueuer.AddJob(nilTask, "param1")
 
 		assert.Error(t, err, "AddJob should return an error for nil task (via addJobFn)")
@@ -54,7 +80,7 @@ func TestAddJob(t *testing.T) {
 	})
 
 	t.Run("Returns error for invalid task type", func(t *testing.T) {
-		invalidTask := 123 // An integer is not a valid task type
+		invalidTask := 123 // Invalid integer type instead of a function
 		job, err := testQueuer.AddJob(invalidTask, "param1")
 
 		assert.Error(t, err, "AddJob should return an error for invalid task type")
@@ -110,10 +136,57 @@ func TestAddJobWithOptions(t *testing.T) {
 		assert.EqualValues(t, expectedJob.Parameters, job.Parameters, "AddJobWithOptions should return the correct parameters")
 	})
 
+	t.Run("Successfully runs a job with options", func(t *testing.T) {
+		t.Parallel()
+		options := &model.Options{
+			OnError: &model.OnError{
+				Timeout:      5,
+				MaxRetries:   3,
+				RetryDelay:   1,
+				RetryBackoff: model.RETRY_BACKOFF_EXPONENTIAL,
+			},
+			Schedule: &model.Schedule{
+				Start:    time.Now().Add(1 * time.Second),
+				Interval: 15 * time.Minute,
+				MaxCount: 3,
+			},
+		}
+		job, err := testQueuer.AddJobWithOptions(options, TaskMock, 1, "2")
+		assert.NoError(t, err, "AddJob should not return an error on success")
+
+		queuedJob, err := testQueuer.GetJob(job.RID)
+		assert.NoError(t, err, "GetJob should not return an error")
+		assert.NotNil(t, queuedJob, "GetJob should return the job that is currently running")
+
+		// Initialize the queuer and start processing jobs
+		testQueuer.AddTask(TaskMock)
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		testQueuer.Start(ctx, cancel)
+
+		// Wait for the job to be running
+		time.Sleep(1500 * time.Millisecond)
+		jobScheduled, err := testQueuer.GetJob(job.RID)
+		assert.NoError(t, err, "GetJob should not return an error for running job")
+		assert.NotNil(t, jobScheduled, "GetJob should return the job that is currently running")
+		assert.Equal(t, model.JobStatusRunning, jobScheduled.Status, "Job should be in Scheduled status")
+
+		// Wait for schedule time and job execution
+		time.Sleep(2 * time.Second)
+		jobNotExisting, err := testQueuer.GetJob(job.RID)
+		assert.Error(t, err, "GetJob should return an error for cancelled job")
+		assert.Nil(t, jobNotExisting, "GetJob should return nil for cancelled job")
+
+		jobArchived, err := testQueuer.dbJob.SelectJobFromArchive(job.RID)
+		assert.NoError(t, err, "SelectJobFromArchive should not return an error for archived job")
+		assert.NotNil(t, jobArchived, "SelectJobFromArchive should return the archived job")
+		assert.Equal(t, jobArchived.Status, model.JobStatusSucceeded, "Archived job should have status Succeeded")
+	})
+
 	t.Run("Return error for invalid options", func(t *testing.T) {
 		options := &model.Options{
 			OnError: &model.OnError{
-				Timeout:      -5,
+				Timeout:      -5, // Invalid timeout
 				MaxRetries:   3,
 				RetryDelay:   1,
 				RetryBackoff: model.RETRY_BACKOFF_EXPONENTIAL,
@@ -161,7 +234,7 @@ func TestAddJobs(t *testing.T) {
 	t.Run("Returns error for invalid batch job", func(t *testing.T) {
 		batchJobs := []model.BatchJob{
 			{
-				Task:       nil, // Invalid task
+				Task:       nil, // Invalid nil function
 				Parameters: []interface{}{1, "2"},
 				Options:    nil,
 			},
@@ -175,7 +248,7 @@ func TestAddJobs(t *testing.T) {
 func TestCancelJob(t *testing.T) {
 	testQueuer := newQueuerMock("TestQueuer", 1)
 
-	t.Run("Successfully cancels a job", func(t *testing.T) {
+	t.Run("Successfully cancels a queued job", func(t *testing.T) {
 		job, err := testQueuer.AddJob(TaskMock, 1, "2")
 		assert.NoError(t, err, "AddJob should not return an error on success")
 
@@ -190,6 +263,37 @@ func TestCancelJob(t *testing.T) {
 		assert.NotContains(t, jobs, cancelledJob, "Cancelled job should not be in the job list")
 	})
 
+	t.Run("Successfully cancels a running job", func(t *testing.T) {
+		t.Parallel()
+		job, err := testQueuer.AddJob(TaskMock, 3, "2")
+		assert.NoError(t, err, "AddJob should not return an error on success")
+
+		queuedJob, err := testQueuer.GetJob(job.RID)
+		assert.NoError(t, err, "GetJob should not return an error")
+		assert.NotNil(t, queuedJob, "GetJob should return the job that is currently running")
+
+		// Initialize the queuer and start processing jobs
+		testQueuer.AddTask(TaskMock)
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		testQueuer.Start(ctx, cancel)
+
+		time.Sleep(1 * time.Second)
+
+		cancelledJob, err := testQueuer.CancelJob(job.RID)
+		assert.NoError(t, err, "CancelJob should not return an error on success")
+		assert.Equal(t, job.RID, cancelledJob.RID, "CancelJob should return the correct job RID")
+
+		jobNotExisting, err := testQueuer.GetJob(job.RID)
+		assert.Error(t, err, "GetJob should return an error for cancelled job")
+		assert.Nil(t, jobNotExisting, "GetJob should return nil for cancelled job")
+
+		jobArchived, err := testQueuer.dbJob.SelectJobFromArchive(job.RID)
+		assert.NoError(t, err, "SelectJobFromArchive should not return an error for archived job")
+		assert.NotNil(t, jobArchived, "SelectJobFromArchive should return the archived job")
+		assert.Equal(t, jobArchived.Status, model.JobStatusCancelled, "Archived job should have status Cancelled")
+	})
+
 	t.Run("Returns error for non-existent job", func(t *testing.T) {
 		cancelledJob, err := testQueuer.CancelJob(uuid.New())
 		assert.Error(t, err, "CancelJob should return an error for non-existent job")