2021-05-06 14:54:10 -07:00
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
2023-02-02 17:15:17 -08:00
2021-05-06 14:54:10 -07:00
package job
import (
"context"
"sort"
"testing"
"time"
"github.com/hashicorp/boundary/internal/db"
"github.com/hashicorp/boundary/internal/errors"
"github.com/hashicorp/boundary/internal/iam"
"github.com/hashicorp/boundary/internal/kms"
"github.com/hashicorp/boundary/internal/scheduler/job/store"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRepository_RunJobs ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kms := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
server := testController ( t , conn , wrapper )
2022-06-22 13:20:27 -07:00
shortName := testController ( t , conn , wrapper , withControllerId ( "not_10" ))
2021-05-06 14:54:10 -07:00
tests := [] struct {
2022-05-18 17:03:24 -07:00
name string
ControllerId string
job * Job
wantRun bool
wantErr bool
wantErrCode errors . Code
wantErrMsg string
2021-05-06 14:54:10 -07:00
}{
{
2022-05-18 17:03:24 -07:00
name : "missing-server-id" ,
ControllerId : "" ,
wantErr : true ,
wantErrCode : errors . InvalidParameter ,
wantErrMsg : "job.(Repository).RunJobs: missing server id: parameter violation: error #100" ,
2021-05-06 14:54:10 -07:00
},
{
2022-05-18 17:03:24 -07:00
name : "no-work" ,
ControllerId : server . PrivateId ,
wantRun : false ,
wantErr : false ,
2021-05-06 14:54:10 -07:00
},
{
2022-05-18 17:03:24 -07:00
name : "valid" ,
ControllerId : server . PrivateId ,
2021-05-06 14:54:10 -07:00
job : & Job {
Job : & store . Job {
Name : "valid-test" ,
Description : "description" ,
},
},
wantRun : true ,
},
2022-06-22 13:20:27 -07:00
{
name : "valid-short" ,
ControllerId : shortName . PrivateId ,
job : & Job {
Job : & store . Job {
Name : "valid-short-controller-name" ,
Description : "description" ,
},
},
wantRun : true ,
},
2021-05-06 14:54:10 -07:00
{
2022-05-18 17:03:24 -07:00
name : "fake-server-id" ,
ControllerId : "fake-server-id" ,
2021-05-06 14:54:10 -07:00
job : & Job {
Job : & store . Job {
Name : "fake-server-id-test" ,
Description : "description" ,
},
},
wantErr : true ,
wantErrCode : errors . NotSpecificIntegrity ,
2022-05-05 12:15:40 -04:00
wantErrMsg : "job.(Repository).RunJobs: db.DoTx: job.(Repository).RunJobs: db.Query: insert or update on table \"job_run\" violates foreign key constraint \"server_controller_fkey\": integrity violation: error #1003" ,
2021-05-06 14:54:10 -07:00
},
}
for _ , tt := range tests {
t . Run ( tt . name , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
if tt . job != nil {
testJob ( t , conn , tt . job . Name , tt . job . Description , wrapper )
}
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kms )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( repo )
2023-06-06 17:09:08 -04:00
got , err := repo . RunJobs ( ctx , tt . ControllerId )
2021-05-06 14:54:10 -07:00
if tt . wantErr {
require . Error ( err )
assert . Truef ( errors . Match ( errors . T ( tt . wantErrCode ), err ), "Unexpected error %s" , err )
assert . Equal ( tt . wantErrMsg , err . Error ())
return
}
require . NoError ( err )
if ! tt . wantRun {
assert . Nil ( got )
return
}
require . Len ( got , 1 )
assert . Equal ( tt . job . Name , got [ 0 ]. JobName )
})
}
}
func TestRepository_RunJobsOrder ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kms := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
server := testController ( t , conn , wrapper )
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kms )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
require . NotNil ( repo )
// Regardless of order of adding jobs, fetching work should be based on order of earliest scheduled time
lastJob := testJob ( t , conn , "future" , "description" , wrapper , WithNextRunIn ( - 1 * time . Hour ))
firstJob := testJob ( t , conn , "past" , "description" , wrapper , WithNextRunIn ( - 24 * time . Hour ))
middleJob := testJob ( t , conn , "current" , "description" , wrapper , WithNextRunIn ( - 12 * time . Hour ))
2023-06-06 17:09:08 -04:00
runs , err := repo . RunJobs ( ctx , server . PrivateId )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
2024-11-06 16:15:49 +00:00
require . Len ( runs , 3 )
2021-05-06 14:54:10 -07:00
2024-11-06 16:15:49 +00:00
// We should see the job runs ordered by scheduled time.
// firstJob > middleJob > lastJob
assert . Equal ( firstJob . Name , runs [ 0 ]. JobName )
assert . Equal ( firstJob . PluginId , runs [ 0 ]. JobPluginId )
2021-05-06 14:54:10 -07:00
2024-11-06 16:15:49 +00:00
assert . Equal ( middleJob . Name , runs [ 1 ]. JobName )
assert . Equal ( middleJob . PluginId , runs [ 1 ]. JobPluginId )
2021-05-06 14:54:10 -07:00
2024-11-06 16:15:49 +00:00
assert . Equal ( lastJob . Name , runs [ 2 ]. JobName )
assert . Equal ( lastJob . PluginId , runs [ 2 ]. JobPluginId )
2021-05-06 14:54:10 -07:00
}
func TestRepository_UpdateProgress ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kmsCache := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
server := testController ( t , conn , wrapper )
job := testJob ( t , conn , "name" , "description" , wrapper )
type args struct {
2024-09-24 09:27:24 -04:00
completed , total , retries int
2021-05-06 14:54:10 -07:00
}
tests := [] struct {
name string
orig * Run
args args
want args
wantErr bool
wantErrCode errors . Code
wantErrMsg string
}{
{
name : "no-run-id" ,
wantErr : true ,
wantErrCode : errors . InvalidParameter ,
wantErrMsg : "job.(Repository).UpdateProgress: missing run id: parameter violation: error #100" ,
},
{
name : "status-already-interrupted" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Interrupted . string (),
2021-05-06 14:54:10 -07:00
},
},
wantErr : true ,
wantErrCode : errors . InvalidJobRunState ,
wantErrMsg : "job.(Repository).UpdateProgress: db.DoTx: job.(Repository).UpdateProgress: job run was in a final run state: interrupted: integrity violation: error #115" ,
},
{
name : "status-already-failed" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Failed . string (),
2021-05-06 14:54:10 -07:00
},
},
wantErr : true ,
wantErrCode : errors . InvalidJobRunState ,
wantErrMsg : "job.(Repository).UpdateProgress: db.DoTx: job.(Repository).UpdateProgress: job run was in a final run state: failed: integrity violation: error #115" ,
},
{
name : "valid-no-changes" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-05-06 14:54:10 -07:00
},
},
},
{
name : "valid-update-total" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-05-06 14:54:10 -07:00
},
},
args : args {
2024-09-24 09:27:24 -04:00
total : 10 ,
retries : 1 ,
2021-05-06 14:54:10 -07:00
},
want : args {
2024-09-24 09:27:24 -04:00
total : 10 ,
retries : 1 ,
2021-05-06 14:54:10 -07:00
},
},
{
name : "valid-update-completed" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
TotalCount : 10 ,
2021-05-06 14:54:10 -07:00
},
},
args : args {
completed : 10 ,
total : 10 ,
},
want : args {
completed : 10 ,
total : 10 ,
},
},
{
name : "valid-update-completed-and-total" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-05-06 14:54:10 -07:00
},
},
args : args {
completed : 10 ,
total : 20 ,
2024-09-24 09:27:24 -04:00
retries : 1 ,
2021-05-06 14:54:10 -07:00
},
want : args {
completed : 10 ,
total : 20 ,
2024-09-24 09:27:24 -04:00
retries : 1 ,
2021-05-06 14:54:10 -07:00
},
},
{
name : "invalid-completed-greater-than-total" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-05-06 14:54:10 -07:00
},
},
args : args {
completed : 10 ,
},
wantErr : true ,
wantErrCode : errors . CheckConstraint ,
2022-01-05 14:38:38 -05:00
wantErrMsg : "job.(Repository).UpdateProgress: db.DoTx: job.(Repository).UpdateProgress: db.Query: job_run_completed_count_less_than_equal_to_total_count constraint failed: check constraint violated: integrity violation: error #1000" ,
2021-05-06 14:54:10 -07:00
},
}
for _ , tt := range tests {
tt := tt
t . Run ( tt . name , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( repo )
var privateId string
if tt . orig != nil {
2023-06-06 17:09:08 -04:00
err = rw . Create ( ctx , tt . orig )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
assert . Empty ( tt . orig . EndTime )
privateId = tt . orig . PrivateId
}
2024-09-24 09:27:24 -04:00
got , err := repo . UpdateProgress ( ctx , privateId , tt . args . completed , tt . args . total , tt . args . retries )
2021-05-06 14:54:10 -07:00
if tt . wantErr {
require . Error ( err )
assert . Truef ( errors . Match ( errors . T ( tt . wantErrCode ), err ), "Unexpected error %s" , err )
assert . Equal ( tt . wantErrMsg , err . Error ())
if tt . orig != nil {
// Delete job run so it does not clash with future runs
2023-06-06 17:09:08 -04:00
_ , err = repo . deleteRun ( ctx , privateId )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
}
return
}
assert . NoError ( err )
require . NotNil ( got )
assert . Nil ( got . EndTime )
assert . Equal ( Running . string (), got . Status )
assert . Equal ( uint32 ( tt . want . completed ), got . CompletedCount )
assert . Equal ( uint32 ( tt . want . total ), got . TotalCount )
// Delete job run so it does not clash with future runs
_ , err = repo . deleteRun ( context . Background (), privateId )
assert . NoError ( err )
})
}
t . Run ( "job-run-not-found" , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
require . NotNil ( repo )
2024-09-24 09:27:24 -04:00
got , err := repo . UpdateProgress ( ctx , "fake-run-id" , 0 , 0 , 0 )
2021-05-06 14:54:10 -07:00
require . Error ( err )
require . Nil ( got )
assert . Truef ( errors . Match ( errors . T ( errors . RecordNotFound ), err ), "Unexpected error %s" , err )
2022-01-05 14:38:38 -05:00
assert . Equal ( "job.(Repository).UpdateProgress: db.DoTx: job.(Repository).UpdateProgress: job run \"fake-run-id\" does not exist: db.LookupById: record not found, search issue: error #1100: dbw.LookupById: record not found" , err . Error ())
2021-05-06 14:54:10 -07:00
})
}
func TestRepository_CompleteRun ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kmsCache := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
server := testController ( t , conn , wrapper )
job := testJob ( t , conn , "name" , "description" , wrapper )
tests := [] struct {
name string
orig * Run
nextRunIn time . Duration
wantErr bool
wantErrCode errors . Code
wantErrMsg string
}{
{
name : "no-run-id" ,
wantErr : true ,
wantErrCode : errors . InvalidParameter ,
wantErrMsg : "job.(Repository).CompleteRun: missing run id: parameter violation: error #100" ,
},
{
name : "status-already-interrupted" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Interrupted . string (),
2021-05-06 14:54:10 -07:00
},
},
wantErr : true ,
wantErrCode : errors . InvalidJobRunState ,
wantErrMsg : "job.(Repository).CompleteRun: db.DoTx: job.(Repository).CompleteRun: job run was in a final run state: interrupted: integrity violation: error #115" ,
},
{
name : "status-already-failed" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Failed . string (),
2021-05-06 14:54:10 -07:00
},
},
wantErr : true ,
wantErrCode : errors . InvalidJobRunState ,
wantErrMsg : "job.(Repository).CompleteRun: db.DoTx: job.(Repository).CompleteRun: job run was in a final run state: failed: integrity violation: error #115" ,
},
{
name : "valid" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-05-06 14:54:10 -07:00
},
},
nextRunIn : time . Hour ,
},
2021-07-16 18:39:43 -04:00
{
name : "valid-with-progress" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-07-16 18:39:43 -04:00
},
},
},
2021-05-06 14:54:10 -07:00
}
for _ , tt := range tests {
tt := tt
t . Run ( tt . name , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( repo )
var privateId string
if tt . orig != nil {
2023-06-06 17:09:08 -04:00
err = rw . Create ( ctx , tt . orig )
2021-09-30 08:47:34 -04:00
require . NoError ( err )
2021-05-06 14:54:10 -07:00
assert . Empty ( tt . orig . EndTime )
privateId = tt . orig . PrivateId
2024-10-25 14:21:26 +01:00
r , err := repo . LookupRun ( ctx , privateId )
require . NoError ( err )
require . NotNil ( r )
2021-05-06 14:54:10 -07:00
}
2024-10-25 14:21:26 +01:00
err = repo . CompleteRun ( ctx , privateId , tt . nextRunIn )
2021-05-06 14:54:10 -07:00
if tt . wantErr {
require . Error ( err )
assert . Truef ( errors . Match ( errors . T ( tt . wantErrCode ), err ), "Unexpected error %s" , err )
assert . Equal ( tt . wantErrMsg , err . Error ())
if tt . orig != nil {
// Delete job run so it does not clash with future runs
2023-06-06 17:09:08 -04:00
_ , err = repo . deleteRun ( ctx , privateId )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
}
return
}
assert . NoError ( err )
2023-06-06 17:09:08 -04:00
updatedJob , err := repo . LookupJob ( ctx , tt . orig . JobName )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( updatedJob )
2024-10-25 14:21:26 +01:00
// The next run is expected to be ~ now + whatever duration was
// passed into CompleteRun.
expectedNextRunIn := time . Now (). Add ( tt . nextRunIn ). Round ( time . Minute ). UTC ()
actualNextRunIn := updatedJob . NextScheduledRun . AsTime (). Round ( time . Minute ). UTC ()
require . EqualValues ( expectedNextRunIn , actualNextRunIn )
2021-05-06 14:54:10 -07:00
2024-10-25 14:21:26 +01:00
// If we can't find the run, it means it was complete.
r , err := repo . LookupRun ( ctx , privateId )
require . NoError ( err )
require . Nil ( r )
2021-05-06 14:54:10 -07:00
})
}
t . Run ( "job-run-not-found" , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
require . NotNil ( repo )
2024-10-25 14:21:26 +01:00
err = repo . CompleteRun ( ctx , "fake-run-id" , time . Hour )
2021-05-06 14:54:10 -07:00
require . Error ( err )
assert . Truef ( errors . Match ( errors . T ( errors . RecordNotFound ), err ), "Unexpected error %s" , err )
2022-01-05 14:38:38 -05:00
assert . Equal ( "job.(Repository).CompleteRun: db.DoTx: job.(Repository).CompleteRun: job run \"fake-run-id\" does not exist: db.LookupById: record not found, search issue: error #1100: dbw.LookupById: record not found" , err . Error ())
2021-05-06 14:54:10 -07:00
})
}
func TestRepository_FailRun ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kmsCache := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
server := testController ( t , conn , wrapper )
job := testJob ( t , conn , "name" , "description" , wrapper )
2021-07-16 18:39:43 -04:00
type args struct {
2024-09-24 09:27:24 -04:00
completed , total , retries int
2021-07-16 18:39:43 -04:00
}
2021-05-06 14:54:10 -07:00
tests := [] struct {
name string
orig * Run
2021-07-16 18:39:43 -04:00
args args
2021-05-06 14:54:10 -07:00
wantErr bool
wantErrCode errors . Code
wantErrMsg string
}{
{
name : "no-run-id" ,
wantErr : true ,
wantErrCode : errors . InvalidParameter ,
wantErrMsg : "job.(Repository).FailRun: missing run id: parameter violation: error #100" ,
},
{
name : "status-already-interrupted" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Interrupted . string (),
2021-05-06 14:54:10 -07:00
},
},
wantErr : true ,
wantErrCode : errors . InvalidJobRunState ,
wantErrMsg : "job.(Repository).FailRun: db.DoTx: job.(Repository).FailRun: job run was in a final run state: interrupted: integrity violation: error #115" ,
},
{
name : "status-already-failed" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Failed . string (),
2021-05-06 14:54:10 -07:00
},
},
wantErr : true ,
wantErrCode : errors . InvalidJobRunState ,
wantErrMsg : "job.(Repository).FailRun: db.DoTx: job.(Repository).FailRun: job run was in a final run state: failed: integrity violation: error #115" ,
},
{
name : "valid" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-05-06 14:54:10 -07:00
},
},
},
2021-07-16 18:39:43 -04:00
{
name : "valid-with-progress" ,
orig : & Run {
JobRun : & store . JobRun {
2022-05-18 17:03:24 -07:00
JobName : job . Name ,
JobPluginId : job . PluginId ,
ControllerId : server . PrivateId ,
Status : Running . string (),
2021-07-16 18:39:43 -04:00
},
},
2024-09-24 09:27:24 -04:00
args : args { completed : 10 , total : 20 , retries : 5 },
2021-07-16 18:39:43 -04:00
},
2021-05-06 14:54:10 -07:00
}
for _ , tt := range tests {
tt := tt
t . Run ( tt . name , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( repo )
var privateId string
if tt . orig != nil {
2023-06-06 17:09:08 -04:00
err = rw . Create ( ctx , tt . orig )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
assert . Empty ( tt . orig . EndTime )
privateId = tt . orig . PrivateId
}
2024-09-24 09:27:24 -04:00
got , err := repo . FailRun ( ctx , privateId , tt . args . completed , tt . args . total , tt . args . retries )
2021-05-06 14:54:10 -07:00
if tt . wantErr {
require . Error ( err )
assert . Truef ( errors . Match ( errors . T ( tt . wantErrCode ), err ), "Unexpected error %s" , err )
assert . Equal ( tt . wantErrMsg , err . Error ())
if tt . orig != nil {
// Delete job run so it does not clash with future runs
2023-06-06 17:09:08 -04:00
_ , err = repo . deleteRun ( ctx , privateId )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
}
return
}
assert . NoError ( err )
require . NotNil ( got )
assert . NotEmpty ( got . EndTime )
assert . Equal ( Failed . string (), got . Status )
2021-07-16 18:39:43 -04:00
assert . Equal ( tt . args . completed , int ( got . CompletedCount ))
assert . Equal ( tt . args . total , int ( got . TotalCount ))
2024-09-24 09:27:24 -04:00
assert . Equal ( tt . args . retries , int ( got . RetriesCount ))
2021-05-06 14:54:10 -07:00
// Delete job run so it does not clash with future runs
_ , err = repo . deleteRun ( context . Background (), privateId )
assert . NoError ( err )
})
}
t . Run ( "job-run-not-found" , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
require . NotNil ( repo )
2024-09-24 09:27:24 -04:00
got , err := repo . FailRun ( ctx , "fake-run-id" , 0 , 0 , 0 )
2021-05-06 14:54:10 -07:00
require . Error ( err )
require . Nil ( got )
assert . Truef ( errors . Match ( errors . T ( errors . RecordNotFound ), err ), "Unexpected error %s" , err )
2022-01-05 14:38:38 -05:00
assert . Equal ( "job.(Repository).FailRun: db.DoTx: job.(Repository).FailRun: job run \"fake-run-id\" does not exist: db.LookupById: record not found, search issue: error #1100: dbw.LookupById: record not found" , err . Error ())
2021-05-06 14:54:10 -07:00
})
}
func TestRepository_InterruptRuns ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kmsCache := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
server := testController ( t , conn , wrapper )
job1 := testJob ( t , conn , "job1" , "description" , wrapper )
job2 := testJob ( t , conn , "job2" , "description" , wrapper )
job3 := testJob ( t , conn , "job3" , "description" , wrapper )
job4 := testJob ( t , conn , "job4" , "description" , wrapper )
// Each test creates 4 runs with update_times of 1, 3, 5 and 7 hours in the past
tests := [] struct {
name string
threshold time . Duration
expectedInterrupts [] * Job
}{
{
name : "with-0-threshold" ,
threshold : 0 ,
expectedInterrupts : [] * Job { job1 , job2 , job3 , job4 },
},
{
name : "threshold-longer-than-all-runs" ,
threshold : 24 * time . Hour ,
expectedInterrupts : [] * Job {},
},
{
name : "with-6-hour-threshold" ,
threshold : 6 * time . Hour ,
expectedInterrupts : [] * Job { job4 },
},
{
name : "with-4-hour-threshold" ,
threshold : 4 * time . Hour ,
expectedInterrupts : [] * Job { job3 , job4 },
},
{
name : "with-2-hour-threshold" ,
threshold : 2 * time . Hour ,
expectedInterrupts : [] * Job { job2 , job3 , job4 },
},
{
name : "with-30-minute-threshold" ,
threshold : 30 * time . Minute ,
expectedInterrupts : [] * Job { job1 , job2 , job3 , job4 },
},
}
for _ , tt := range tests {
tt := tt
t . Run ( tt . name , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( repo )
// Insert test runs with a forced update time
_ , err = testRunWithUpdateTime ( conn , job1 . PluginId , job1 . Name , server . PrivateId , time . Now (). Add ( - 1 * time . Hour ))
require . NoError ( err )
_ , err = testRunWithUpdateTime ( conn , job2 . PluginId , job2 . Name , server . PrivateId , time . Now (). Add ( - 3 * time . Hour ))
require . NoError ( err )
_ , err = testRunWithUpdateTime ( conn , job3 . PluginId , job3 . Name , server . PrivateId , time . Now (). Add ( - 5 * time . Hour ))
require . NoError ( err )
_ , err = testRunWithUpdateTime ( conn , job4 . PluginId , job4 . Name , server . PrivateId , time . Now (). Add ( - 7 * time . Hour ))
require . NoError ( err )
2023-06-06 17:09:08 -04:00
runs , err := repo . InterruptRuns ( ctx , tt . threshold )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
assert . Equal ( len ( runs ), len ( tt . expectedInterrupts ))
for _ , eJob := range tt . expectedInterrupts {
var gotRun bool
for _ , run := range runs {
if run . JobName == eJob . Name && run . JobPluginId == eJob . PluginId {
gotRun = true
break
}
}
assert . True ( gotRun )
}
// Interrupt all runs for next test
2023-06-06 17:09:08 -04:00
_ , err = repo . InterruptRuns ( ctx , 0 )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
})
}
}
func TestRepository_InterruptServerRuns ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
assert , require := assert . New ( t ), require . New ( t )
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kmsCache := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
server1 := testController ( t , conn , wrapper )
server2 := testController ( t , conn , wrapper )
server3 := testController ( t , conn , wrapper )
job1 := testJob ( t , conn , "job1" , "description" , wrapper )
job2 := testJob ( t , conn , "job2" , "description" , wrapper )
job3 := testJob ( t , conn , "job3" , "description" , wrapper )
type args struct {
2022-05-18 17:03:24 -07:00
ControllerId string
2021-05-06 14:54:10 -07:00
opts [] Option
expectedJobs [] * Job
}
tests := [] struct {
name string
runs [] args
interrupts [] args
}{
{
name : "all-runs" ,
runs : [] args {
{
2022-05-18 17:03:24 -07:00
ControllerId : server1 . PrivateId ,
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job { job1 , job2 , job3 },
},
},
interrupts : [] args {
{
expectedJobs : [] * Job { job1 , job2 , job3 },
},
},
},
{
name : "all-runs-on-single-server-with-server-id" ,
runs : [] args {
{
2022-05-18 17:03:24 -07:00
ControllerId : server2 . PrivateId ,
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job { job1 , job2 , job3 },
},
},
interrupts : [] args {
{
2022-05-18 17:03:24 -07:00
opts : [] Option { WithControllerId ( server1 . PrivateId )},
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job {},
},
{
2022-05-18 17:03:24 -07:00
opts : [] Option { WithControllerId ( server2 . PrivateId )},
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job { job1 , job2 , job3 },
},
{
2022-05-18 17:03:24 -07:00
opts : [] Option { WithControllerId ( server3 . PrivateId )},
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job {},
},
},
},
{
name : "no-runs" ,
runs : [] args {},
interrupts : [] args {
{
expectedJobs : [] * Job {},
},
},
},
{
name : "no-runs-with-server-ids" ,
runs : [] args {},
interrupts : [] args {
{
2022-05-18 17:03:24 -07:00
opts : [] Option { WithControllerId ( server1 . PrivateId )},
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job {},
},
{
2022-05-18 17:03:24 -07:00
opts : [] Option { WithControllerId ( server2 . PrivateId )},
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job {},
},
{
2022-05-18 17:03:24 -07:00
opts : [] Option { WithControllerId ( server3 . PrivateId )},
2021-05-06 14:54:10 -07:00
expectedJobs : [] * Job {},
},
},
},
}
for _ , tt := range tests {
tt := tt
t . Run ( tt . name , func ( t * testing . T ) {
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kmsCache )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
for _ , r := range tt . runs {
2024-11-06 16:15:49 +00:00
runs , err := repo . RunJobs ( ctx , r . ControllerId )
2021-05-06 14:54:10 -07:00
require . NoError ( err )
assert . Len ( runs , len ( r . expectedJobs ))
sort . Slice ( runs , func ( i , j int ) bool { return runs [ i ]. JobName < runs [ j ]. JobName })
sort . Slice ( r . expectedJobs , func ( i , j int ) bool { return r . expectedJobs [ i ]. Name < r . expectedJobs [ j ]. Name })
for i := range runs {
assert . Equal ( runs [ i ]. JobName , r . expectedJobs [ i ]. Name )
assert . Equal ( runs [ i ]. JobPluginId , r . expectedJobs [ i ]. PluginId )
assert . Equal ( Running . string (), runs [ i ]. Status )
}
}
for _ , interrupt := range tt . interrupts {
runs , err := repo . InterruptRuns ( context . Background (), 0 , interrupt . opts ... )
require . NoError ( err )
require . Len ( runs , len ( interrupt . expectedJobs ))
sort . Slice ( runs , func ( i , j int ) bool { return runs [ i ]. JobName < runs [ j ]. JobName })
sort . Slice ( interrupt . expectedJobs , func ( i , j int ) bool { return interrupt . expectedJobs [ i ]. Name < interrupt . expectedJobs [ j ]. Name })
for i := range runs {
assert . Equal ( runs [ i ]. JobName , interrupt . expectedJobs [ i ]. Name )
assert . Equal ( runs [ i ]. JobPluginId , interrupt . expectedJobs [ i ]. PluginId )
assert . Equal ( Interrupted . string (), runs [ i ]. Status )
}
}
// Interrupt any remaining runs for next test
_ , err = repo . InterruptRuns ( context . Background (), 0 )
assert . NoError ( err )
})
}
}
func TestRepository_DuplicateJobRun ( t * testing . T ) {
t . Parallel ()
2022-03-11 15:11:14 -08:00
require := require . New ( t )
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
wrapper := db . TestWrapper ( t )
iam . TestRepo ( t , conn , wrapper )
server := testController ( t , conn , wrapper )
job1 := testJob ( t , conn , "job1" , "description" , wrapper )
require . NotNil ( job1 )
run , err := testRun ( conn , job1 . PluginId , job1 . Name , server . PrivateId )
require . NoError ( err )
require . NotNil ( run )
2022-03-11 15:11:14 -08:00
// Inserting the same job run should conflict on job name and not create a run
2021-05-06 14:54:10 -07:00
run , err = testRun ( conn , job1 . PluginId , job1 . Name , server . PrivateId )
2022-03-11 15:11:14 -08:00
require . Nil ( err )
2021-05-06 14:54:10 -07:00
require . Nil ( run )
// Creating a new job with a different name, the associated run should not conflict with the previous run
job2 := testJob ( t , conn , "job2" , "description" , wrapper )
require . NotNil ( job1 )
run , err = testRun ( conn , job2 . PluginId , job2 . Name , server . PrivateId )
require . NoError ( err )
require . NotNil ( run )
}
func TestRepository_LookupJobRun ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kms := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
job := testJob ( t , conn , "name" , "description" , wrapper )
server := testController ( t , conn , wrapper )
run , err := testRun ( conn , job . PluginId , job . Name , server . PrivateId )
require . NoError ( t , err )
2022-03-11 15:11:14 -08:00
require . NotNil ( t , run )
2021-05-06 14:54:10 -07:00
tests := [] struct {
name string
in string
want * Run
wantErr bool
wantErrCode errors . Code
wantErrMsg string
}{
{
name : "with-no-id" ,
wantErr : true ,
wantErrCode : errors . InvalidParameter ,
wantErrMsg : "job.(Repository).LookupRun: missing run id: parameter violation: error #100" ,
},
{
name : "with-non-existing-id" ,
in : "fake-run-id" ,
},
{
name : "with-existing-id" ,
in : run . PrivateId ,
want : run ,
},
}
for _ , tt := range tests {
tt := tt
t . Run ( tt . name , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kms )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( repo )
2023-06-06 17:09:08 -04:00
got , err := repo . LookupRun ( ctx , tt . in )
2021-05-06 14:54:10 -07:00
if tt . wantErr {
require . Error ( err )
assert . Truef ( errors . Match ( errors . T ( tt . wantErrCode ), err ), "Unexpected error %s" , err )
assert . Equal ( tt . wantErrMsg , err . Error ())
assert . Nil ( got )
return
}
require . NoError ( err )
assert . EqualValues ( tt . want , got )
})
}
}
func TestRepository_deleteJobRun ( t * testing . T ) {
t . Parallel ()
2023-06-06 17:09:08 -04:00
ctx := context . Background ()
2021-05-06 14:54:10 -07:00
conn , _ := db . TestSetup ( t , "postgres" )
rw := db . New ( conn )
wrapper := db . TestWrapper ( t )
kms := kms . TestKms ( t , conn , wrapper )
iam . TestRepo ( t , conn , wrapper )
job := testJob ( t , conn , "name" , "description" , wrapper )
server := testController ( t , conn , wrapper )
run , err := testRun ( conn , job . PluginId , job . Name , server . PrivateId )
require . NoError ( t , err )
2022-03-11 15:11:14 -08:00
require . NotNil ( t , run )
2021-05-06 14:54:10 -07:00
tests := [] struct {
name string
in string
want int
wantErr bool
wantErrCode errors . Code
wantErrMsg string
}{
{
name : "With no run id" ,
wantErr : true ,
wantErrCode : errors . InvalidParameter ,
wantErrMsg : "job.(Repository).deleteRun: missing run id: parameter violation: error #100" ,
},
{
name : "With non existing job id" ,
in : "fake-run-id" ,
want : 0 ,
},
{
name : "With existing job id" ,
in : run . PrivateId ,
want : 1 ,
},
}
for _ , tt := range tests {
tt := tt
t . Run ( tt . name , func ( t * testing . T ) {
assert , require := assert . New ( t ), require . New ( t )
2023-06-06 17:09:08 -04:00
repo , err := NewRepository ( ctx , rw , rw , kms )
2021-05-06 14:54:10 -07:00
assert . NoError ( err )
require . NotNil ( repo )
2023-06-06 17:09:08 -04:00
got , err := repo . deleteRun ( ctx , tt . in )
2021-05-06 14:54:10 -07:00
if tt . wantErr {
require . Error ( err )
assert . Truef ( errors . Match ( errors . T ( tt . wantErrCode ), err ), "Unexpected error %s" , err )
assert . Equal ( tt . wantErrMsg , err . Error ())
assert . Zero ( got )
return
}
require . NoError ( err )
assert . EqualValues ( tt . want , got )
})
}
}