mirror of
https://github.com/hanzoai/porto.git
synced 2026-11-03 18:08:27 +00:00
345 lines
9.0 KiB
Go
345 lines
9.0 KiB
Go
package tasks
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func Test_parseTaskFormat(t *testing.T) {
|
|
tests := []struct {
|
|
format string
|
|
wantTask *task
|
|
wantErr bool
|
|
}{
|
|
{
|
|
format: "16:18",
|
|
wantTask: NewTaskDaily(16, 18).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every 1 second",
|
|
wantTask: NewTaskAtIntervals(1, Seconds).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every 59 seconds",
|
|
wantTask: NewTaskAtIntervals(59, Seconds).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every 1 minute",
|
|
wantTask: NewTaskAtIntervals(1, Minutes).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every 1 hour",
|
|
wantTask: NewTaskAtIntervals(1, Hours).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every 2 hours",
|
|
wantTask: NewTaskAtIntervals(2, Hours).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every 61 minutes",
|
|
wantTask: NewTaskAtIntervals(61, Minutes).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every day",
|
|
wantTask: NewTaskAtIntervals(1, Days).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every day 11:15",
|
|
wantTask: NewTaskDaily(11, 15).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every week",
|
|
wantTask: NewTaskAtIntervals(1, Weeks).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every week 22:11",
|
|
wantTask: NewTaskOnWeekday(time.Sunday, 22, 11).(*task),
|
|
wantErr: false,
|
|
},
|
|
|
|
{
|
|
format: "1 hour",
|
|
wantTask: NewTaskAtIntervals(1, Hours).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "Monday",
|
|
wantTask: NewTaskOnWeekday(time.Monday, 0, 0).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "every Tuesday 23:59",
|
|
wantTask: NewTaskOnWeekday(time.Tuesday, 23, 59).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "wednesday",
|
|
wantTask: NewTaskOnWeekday(time.Wednesday, 0, 0).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "thursday",
|
|
wantTask: NewTaskOnWeekday(time.Thursday, 0, 0).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "friday",
|
|
wantTask: NewTaskOnWeekday(time.Friday, 0, 0).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "Saturday 23:13",
|
|
wantTask: NewTaskOnWeekday(time.Saturday, 23, 13).(*task),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
format: "Sunday 12:00",
|
|
wantTask: NewTaskOnWeekday(time.Sunday, 12, 0).(*task),
|
|
wantErr: false,
|
|
},
|
|
//
|
|
// Error cases
|
|
//
|
|
{format: "1 second 16:18", wantErr: true},
|
|
{format: "24:00", wantErr: true},
|
|
{format: "Sunday 23:61", wantErr: true},
|
|
{format: "every", wantErr: true},
|
|
{format: "every every 1 second", wantErr: true},
|
|
{format: "every", wantErr: true},
|
|
{format: "2 monday", wantErr: true},
|
|
{format: "3 tuesday", wantErr: true},
|
|
{format: "3 wednesday", wantErr: true},
|
|
{format: "3 thursday", wantErr: true},
|
|
{format: "3 friday", wantErr: true},
|
|
{format: "3 saturday", wantErr: true},
|
|
{format: "3 sunday", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.format, func(t *testing.T) {
|
|
j, err := parseTaskFormat(tt.format)
|
|
if tt.wantErr {
|
|
assert.Error(t, err)
|
|
} else {
|
|
require.NoError(t, err)
|
|
require.NotNil(t, j)
|
|
assert.Equal(t, tt.wantTask.interval, j.interval)
|
|
assert.Equal(t, tt.wantTask.unit, j.unit)
|
|
assert.Equal(t, tt.wantTask.period, j.period)
|
|
assert.Equal(t, tt.wantTask.startDay, j.startDay)
|
|
assert.Equal(t, tt.wantTask.NextScheduledTime(), j.NextScheduledTime())
|
|
|
|
d := j.Duration()
|
|
assert.True(t, d > 0)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_parseTimeFormat(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
args string
|
|
wantHour int
|
|
wantMin int
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "normal",
|
|
args: "16:18",
|
|
wantHour: 16,
|
|
wantMin: 18,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "normal",
|
|
args: "6:18",
|
|
wantHour: 6,
|
|
wantMin: 18,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "notnumber",
|
|
args: "e:18",
|
|
wantHour: 0,
|
|
wantMin: 0,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "outofrange",
|
|
args: "25:18",
|
|
wantHour: 25,
|
|
wantMin: 18,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "wrongformat",
|
|
args: "19:18:17",
|
|
wantHour: 0,
|
|
wantMin: 0,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "wrongminute",
|
|
args: "19:1e",
|
|
wantHour: 19,
|
|
wantMin: 0,
|
|
wantErr: true,
|
|
},
|
|
}
|
|
for idx, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
gotHour, gotMin, err := parseTimeFormat(tt.args)
|
|
if tt.wantErr {
|
|
assert.Error(t, err, fmt.Sprintf("[%d] case failed", idx))
|
|
}
|
|
assert.Equal(t, tt.wantHour, gotHour, "[%d] case failed", idx)
|
|
assert.Equal(t, tt.wantMin, gotMin, "[%d] case failed", idx)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_TaskAtIntervalsMinute(t *testing.T) {
|
|
job1 := NewTaskAtIntervals(1, Minutes).Do("test", testTask).(*task)
|
|
executed := job1.Run()
|
|
assert.True(t, executed, "should be able to run")
|
|
t1 := job1.LastRunTime()
|
|
t2 := job1.NextScheduledTime()
|
|
t.Logf("job1 scheduled for %s, last run was at %s", t2.Format(time.RFC3339), t1.Format(time.RFC3339))
|
|
assert.True(t, t2.After(t1))
|
|
diff := int(t2.Sub(t1).Seconds())
|
|
assert.Equal(t, 60, diff)
|
|
}
|
|
|
|
func Test_TaskOnWeekday(t *testing.T) {
|
|
job1 := NewTaskOnWeekday(time.Monday, 13, 59).Do("test", testTask)
|
|
job2 := NewTaskOnWeekday(time.Wednesday, 13, 59).Do("test", testTask)
|
|
|
|
nextTime1 := job1.NextScheduledTime()
|
|
nextTime2 := job2.NextScheduledTime()
|
|
t.Logf("job1 scheduled for %s", nextTime1)
|
|
t.Logf("job2 scheduled for %s", nextTime2)
|
|
assert.Equal(t, time.Monday, nextTime1.Weekday())
|
|
assert.Equal(t, time.Wednesday, nextTime2.Weekday())
|
|
assert.NotEqual(t, nextTime1, nextTime2, "Two jobs scheduled at the same time on two different weekdays should never run at the same time")
|
|
assert.Equal(t, "[email protected]", job1.Name())
|
|
}
|
|
|
|
func Test_TaskDaily(t *testing.T) {
|
|
job1 := NewTaskDaily(00, 00).Do("test", testTask)
|
|
job2 := NewTaskDaily(23, 59).Do("test", testTask)
|
|
t.Logf("job1 scheduled for %s", job1.NextScheduledTime())
|
|
t.Logf("job2 scheduled for %s", job2.NextScheduledTime())
|
|
assert.NotEqual(t, job1.NextScheduledTime(), job2.NextScheduledTime())
|
|
}
|
|
|
|
func Test_TaskWeekls(t *testing.T) {
|
|
job1 := NewTaskAtIntervals(1, Weeks).Do("test", testTask)
|
|
job2 := NewTaskAtIntervals(2, Weeks).Do("test", testTask)
|
|
t.Logf("job1 scheduled for %s", job1.NextScheduledTime())
|
|
t.Logf("job2 scheduled for %s", job2.NextScheduledTime())
|
|
assert.NotEqual(t, job1.NextScheduledTime(), job2.NextScheduledTime())
|
|
}
|
|
|
|
// This ensures that if you schedule a task for today's weekday, but the time is already passed, it will be scheduled for
|
|
// next week at the requested time.
|
|
func Test_TaskWeekdaysTodayAfter(t *testing.T) {
|
|
now := time.Now()
|
|
month, day, hour, minute := now.Month(), now.Day(), now.Hour(), now.Minute()
|
|
timeToSchedule := time.Date(now.Year(), month, day, hour, minute, 0, 0, time.Local)
|
|
|
|
job1 := NewTaskOnWeekday(now.Weekday(), timeToSchedule.Hour(), timeToSchedule.Minute()).Do("test", testTask)
|
|
t.Logf("task is scheduled for %s", job1.NextScheduledTime())
|
|
assert.Equal(t, job1.NextScheduledTime().Weekday(), timeToSchedule.Weekday(), "Task scheduled for current weekday for earlier time, should still be scheduled for current weekday (but next week)")
|
|
//nextWeek := time.Date(now.Year(), month, day+7, hour, minute, 0, 0, time.Local)
|
|
//assert.Equal(t, nextWeek, job1.NextScheduledTime(), "Task should be scheduled for the correct time next week.")
|
|
}
|
|
|
|
// This is to ensure that if you schedule a task for today's weekday, and the time hasn't yet passed, the next run time
|
|
// will be scheduled for today.
|
|
func Test_TaskWeekdaysTodayBefore(t *testing.T) {
|
|
|
|
now := time.Now()
|
|
timeToSchedule := time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute()+1, 0, 0, time.Local)
|
|
|
|
job1 := NewTaskOnWeekday(now.Weekday(), timeToSchedule.Hour(), timeToSchedule.Minute()).Do("test", testTask)
|
|
t.Logf("task is scheduled for %s", job1.NextScheduledTime())
|
|
assert.Equal(t, timeToSchedule, job1.NextScheduledTime(), "Task should be run today, at the set time.")
|
|
}
|
|
|
|
func Test_NewTask_panic(t *testing.T) {
|
|
require.Panics(t, func() {
|
|
NewTaskOnWeekday(time.Wednesday, -1, 60)
|
|
})
|
|
require.Panics(t, func() {
|
|
NewTaskOnWeekday(time.Wednesday, 0, -1)
|
|
})
|
|
require.Panics(t, func() {
|
|
NewTaskDaily(0, -1)
|
|
})
|
|
}
|
|
|
|
func Test_TaskPanicCatch(t *testing.T) {
|
|
job1 := NewTaskAtIntervals(1, Minutes).Do("panicTask", panicTask).(*task)
|
|
executed := job1.Run()
|
|
assert.True(t, executed, "should be able to run")
|
|
assert.False(t, job1.running)
|
|
}
|
|
|
|
func panicTask() {
|
|
logger.Panic("TEST: something went wrong", errors.New("test panic"))
|
|
}
|
|
|
|
func Test_TaskLongTime(t *testing.T) {
|
|
job1 := NewTaskAtIntervals(1, Seconds).Do("longTask1", longTask).(*task)
|
|
job2 := NewTaskAtIntervals(1, Seconds).Do("longTask2", longTask).(*task)
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
executed := 0
|
|
skipped := 0
|
|
for i := 0; i < 3; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
if job1.Run() {
|
|
executed++
|
|
} else {
|
|
skipped++
|
|
}
|
|
}()
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
if job2.Run() {
|
|
executed++
|
|
} else {
|
|
skipped++
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
assert.Equal(t, 2, executed)
|
|
assert.Equal(t, 4, skipped)
|
|
}
|
|
|
|
func longTask() {
|
|
logger.Info("TEST: slow task started")
|
|
time.Sleep(3 * time.Second)
|
|
}
|