Removed all panics. Instead error will be returned in case any error is run into. In addition to this, some methods used to create instances have been renamed with Create prefix.

burakkoken · burakkoken · commit e0badeb6fa7d · 2021-05-30T01:12:04.000+02:00
diff --git a/executor.go b/executor.go
@@ -66,9 +66,13 @@ func (executor *SimpleTaskExecutor) Schedule(task Task, delay time.Duration) (Sc
 	}
 
 	executor.nextSequence++
-	scheduledTask := NewScheduledRunnableTask(executor.nextSequence, task, executor.calculateTriggerTime(delay), 0, false)
+	scheduledTask, err := CreateScheduledRunnableTask(executor.nextSequence, task, executor.calculateTriggerTime(delay), 0, false)
 	executor.executorMu.Unlock()
 
+	if err != nil {
+		return nil, err
+	}
+
 	executor.addNewTask(scheduledTask)
 
 	return scheduledTask, nil
@@ -87,9 +91,13 @@ func (executor *SimpleTaskExecutor) ScheduleWithFixedDelay(task Task, initialDel
 	}
 
 	executor.nextSequence++
-	scheduledTask := NewScheduledRunnableTask(executor.nextSequence, task, executor.calculateTriggerTime(initialDelay), delay, false)
+	scheduledTask, err := CreateScheduledRunnableTask(executor.nextSequence, task, executor.calculateTriggerTime(initialDelay), delay, false)
 	executor.executorMu.Unlock()
 
+	if err != nil {
+		return nil, err
+	}
+
 	executor.addNewTask(scheduledTask)
 
 	return scheduledTask, nil
@@ -108,9 +116,13 @@ func (executor *SimpleTaskExecutor) ScheduleAtFixedRate(task Task, initialDelay
 	}
 
 	executor.nextSequence++
-	scheduledTask := NewScheduledRunnableTask(executor.nextSequence, task, executor.calculateTriggerTime(initialDelay), period, true)
+	scheduledTask, err := CreateScheduledRunnableTask(executor.nextSequence, task, executor.calculateTriggerTime(initialDelay), period, true)
 	executor.executorMu.Unlock()
 
+	if err != nil {
+		return nil, err
+	}
+
 	executor.addNewTask(scheduledTask)
 
 	return scheduledTask, nil
diff --git a/scheduler.go b/scheduler.go
@@ -35,23 +35,59 @@ func NewDefaultTaskScheduler() TaskScheduler {
 }
 
 func (scheduler *SimpleTaskScheduler) Schedule(task Task, options ...Option) (ScheduledTask, error) {
-	schedulerTask := NewSchedulerTask(task, options...)
+	schedulerTask, err := CreateSchedulerTask(task, options...)
+
+	if err != nil {
+		return nil, err
+	}
+
 	return scheduler.taskExecutor.Schedule(task, schedulerTask.GetInitialDelay())
 }
 
 func (scheduler *SimpleTaskScheduler) ScheduleWithCron(task Task, expression string, options ...Option) (ScheduledTask, error) {
-	schedulerTask := NewSchedulerTask(task, options...)
-	triggerTask := NewTriggerTask(schedulerTask.task, scheduler.taskExecutor, NewCronTrigger(expression, schedulerTask.location))
+	var schedulerTask *SchedulerTask
+	var err error
+
+	schedulerTask, err = CreateSchedulerTask(task, options...)
+
+	if err != nil {
+		return nil, err
+	}
+
+	var cronTrigger *CronTrigger
+	cronTrigger, err = CreateCronTrigger(expression, schedulerTask.location)
+
+	if err != nil {
+		return nil, err
+	}
+
+	var triggerTask *TriggerTask
+	triggerTask, err = CreateTriggerTask(schedulerTask.task, scheduler.taskExecutor, cronTrigger)
+
+	if err != nil {
+		return nil, err
+	}
+
 	return triggerTask.Schedule()
 }
 
 func (scheduler *SimpleTaskScheduler) ScheduleWithFixedDelay(task Task, delay time.Duration, options ...Option) (ScheduledTask, error) {
-	schedulerTask := NewSchedulerTask(task, options...)
+	schedulerTask, err := CreateSchedulerTask(task, options...)
+
+	if err != nil {
+		return nil, err
+	}
+
 	return scheduler.taskExecutor.ScheduleWithFixedDelay(schedulerTask.task, schedulerTask.GetInitialDelay(), delay)
 }
 
 func (scheduler *SimpleTaskScheduler) ScheduleAtFixedRate(task Task, period time.Duration, options ...Option) (ScheduledTask, error) {
-	schedulerTask := NewSchedulerTask(task, options...)
+	schedulerTask, err := CreateSchedulerTask(task, options...)
+
+	if err != nil {
+		return nil, err
+	}
+
 	return scheduler.taskExecutor.ScheduleAtFixedRate(schedulerTask.task, schedulerTask.GetInitialDelay(), period)
 }
 
diff --git a/task.go b/task.go
@@ -3,6 +3,7 @@ package chrono
 import (
 	"context"
 	"errors"
+	"fmt"
 	"sort"
 	"sync"
 	"time"
@@ -16,9 +17,9 @@ type SchedulerTask struct {
 	location  *time.Location
 }
 
-func NewSchedulerTask(task Task, options ...Option) *SchedulerTask {
+func CreateSchedulerTask(task Task, options ...Option) (*SchedulerTask, error) {
 	if task == nil {
-		panic("task cannot be nil")
+		return nil, errors.New("task cannot be nil")
 	}
 
 	runnableTask := &SchedulerTask{
@@ -28,10 +29,14 @@ func NewSchedulerTask(task Task, options ...Option) *SchedulerTask {
 	}
 
 	for _, option := range options {
-		option(runnableTask)
+		err := option(runnableTask)
+
+		if err != nil {
+			return nil, err
+		}
 	}
 
-	return runnableTask
+	return runnableTask, nil
 }
 
 func (task *SchedulerTask) GetInitialDelay() time.Duration {
@@ -50,23 +55,25 @@ func (task *SchedulerTask) GetInitialDelay() time.Duration {
 	return diff
 }
 
-type Option func(task *SchedulerTask)
+type Option func(task *SchedulerTask) error
 
 func WithStartTime(year int, month time.Month, day, hour, min, sec int) Option {
-	return func(task *SchedulerTask) {
+	return func(task *SchedulerTask) error {
 		task.startTime = time.Date(year, month, day, hour, min, sec, 0, time.Local)
+		return nil
 	}
 }
 
 func WithLocation(location string) Option {
-	return func(task *SchedulerTask) {
+	return func(task *SchedulerTask) error {
 		loadedLocation, err := time.LoadLocation(location)
 
 		if err != nil {
-			panic(err)
+			return fmt.Errorf("location not loaded : %s", location)
 		}
 
 		task.location = loadedLocation
+		return nil
 	}
 }
 
@@ -85,9 +92,9 @@ type ScheduledRunnableTask struct {
 	cancelled   bool
 }
 
-func NewScheduledRunnableTask(id int, task Task, triggerTime time.Time, period time.Duration, fixedRate bool) *ScheduledRunnableTask {
+func CreateScheduledRunnableTask(id int, task Task, triggerTime time.Time, period time.Duration, fixedRate bool) (*ScheduledRunnableTask, error) {
 	if task == nil {
-		panic("task cannot be nil")
+		return nil, errors.New("task cannot be nil")
 	}
 
 	if period < 0 {
@@ -100,7 +107,7 @@ func NewScheduledRunnableTask(id int, task Task, triggerTime time.Time, period t
 		triggerTime: triggerTime,
 		period:      period,
 		fixedRate:   fixedRate,
-	}
+	}, nil
 }
 
 func (scheduledRunnableTask *ScheduledRunnableTask) Cancel() {
@@ -155,25 +162,25 @@ type TriggerTask struct {
 	nextTriggerTime      time.Time
 }
 
-func NewTriggerTask(task Task, executor TaskExecutor, trigger Trigger) *TriggerTask {
+func CreateTriggerTask(task Task, executor TaskExecutor, trigger Trigger) (*TriggerTask, error) {
 	if task == nil {
-		panic("task cannot be nil")
+		return nil, errors.New("task cannot be nil")
 	}
 
 	if executor == nil {
-		panic("executor cannot be nil")
+		return nil, errors.New("executor cannot be nil")
 	}
 
 	if trigger == nil {
-		panic("trigger cannot be nil")
+		return nil, errors.New("trigger cannot be nil")
 	}
 
 	return &TriggerTask{
 		task:           task,
 		executor:       executor,
 		triggerContext: NewSimpleTriggerContext(),
 		trigger:        trigger,
-	}
+	}, nil
 }
 
 func (task *TriggerTask) Cancel() {
diff --git a/task_test.go b/task_test.go
@@ -10,55 +10,50 @@ import (
 )
 
 func TestNewSchedulerTask(t *testing.T) {
-	assert.Panics(t, func() {
-		NewSchedulerTask(nil)
-	})
+	_, err := CreateSchedulerTask(nil)
+	assert.Error(t, err)
 }
 
 func TestNewSchedulerTask_WithLocation(t *testing.T) {
-	assert.NotPanics(t, func() {
-		NewSchedulerTask(func(ctx context.Context) {
+	_, err := CreateSchedulerTask(func(ctx context.Context) {
 
-		}, WithLocation("Europe/Istanbul"))
-	})
+	}, WithLocation("Europe/Istanbul"))
+	assert.Nil(t, err)
 }
 
 func TestNewSchedulerTask_WithInvalidLocation(t *testing.T) {
-	assert.Panics(t, func() {
-		NewSchedulerTask(func(ctx context.Context) {
+	_, err := CreateSchedulerTask(func(ctx context.Context) {
 
-		}, WithLocation("Europe"))
-	})
+	}, WithLocation("Europe"))
+	assert.Error(t, err)
 }
 
 func TestNewScheduledRunnableTask(t *testing.T) {
-	task := NewScheduledRunnableTask(0, func(ctx context.Context) {
+	task, _ := CreateScheduledRunnableTask(0, func(ctx context.Context) {
 
 	}, time.Now(), -1, true)
 
 	assert.Equal(t, task.period, 0*time.Second)
 
-	assert.Panics(t, func() {
-		NewScheduledRunnableTask(0, nil, time.Now(), -1, true)
-	})
+	_, err := CreateScheduledRunnableTask(0, nil, time.Now(), -1, true)
+	assert.Error(t, err)
 }
 
 func TestNewTriggerTask(t *testing.T) {
-	assert.Panics(t, func() {
-		NewTriggerTask(nil, NewDefaultTaskExecutor(), NewCronTrigger("* * * * * *", time.Local))
-	})
+	trigger, err := CreateCronTrigger("* * * * * *", time.Local)
+	assert.Nil(t, err)
 
-	assert.Panics(t, func() {
-		NewTriggerTask(func(ctx context.Context) {
+	_, err = CreateTriggerTask(nil, NewDefaultTaskExecutor(), trigger)
+	assert.Error(t, err)
 
-		}, nil, NewCronTrigger("* * * * * *", time.Local))
-	})
+	_, err = CreateTriggerTask(func(ctx context.Context) {
 
-	assert.Panics(t, func() {
-		NewTriggerTask(func(ctx context.Context) {
+	}, nil, trigger)
+	assert.Error(t, err)
 
-		}, NewDefaultTaskExecutor(), nil)
-	})
+	_, err = CreateTriggerTask(func(ctx context.Context) {
+
+	}, NewDefaultTaskExecutor(), nil)
 }
 
 type zeroTrigger struct {
@@ -69,7 +64,7 @@ func (trigger *zeroTrigger) NextExecutionTime(ctx TriggerContext) time.Time {
 }
 
 func TestTriggerTask_Schedule(t *testing.T) {
-	task := NewTriggerTask(func(ctx context.Context) {}, NewDefaultTaskExecutor(), &zeroTrigger{})
+	task, _ := CreateTriggerTask(func(ctx context.Context) {}, NewDefaultTaskExecutor(), &zeroTrigger{})
 	_, err := task.Schedule()
 	assert.NotNil(t, err)
 }
@@ -109,8 +104,11 @@ func TestTriggerTask_ScheduleWithError(t *testing.T) {
 	scheduledExecutorMock.On("Schedule", mock.AnythingOfType("Task"), mock.AnythingOfType("time.Duration")).
 		Return((*ScheduledRunnableTask)(nil), errors.New("test error"))
 
-	task := NewTriggerTask(func(ctx context.Context) {}, scheduledExecutorMock, NewCronTrigger("* * * * * * ", time.Local))
-	_, err := task.Schedule()
+	trigger, err := CreateCronTrigger("* * * * * *", time.Local)
+	assert.Nil(t, err)
+
+	task, _ := CreateTriggerTask(func(ctx context.Context) {}, scheduledExecutorMock, trigger)
+	_, err = task.Schedule()
 
 	assert.NotNil(t, err)
 }
diff --git a/trigger.go b/trigger.go
@@ -45,11 +45,11 @@ type CronTrigger struct {
 	location       *time.Location
 }
 
-func NewCronTrigger(expression string, location *time.Location) *CronTrigger {
+func CreateCronTrigger(expression string, location *time.Location) (*CronTrigger, error) {
 	cron, err := ParseCronExpression(expression)
 
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
 
 	trigger := &CronTrigger{
@@ -61,7 +61,7 @@ func NewCronTrigger(expression string, location *time.Location) *CronTrigger {
 		trigger.location = location
 	}
 
-	return trigger
+	return trigger, nil
 }
 
 func (trigger *CronTrigger) NextExecutionTime(ctx TriggerContext) time.Time {
diff --git a/trigger_test.go b/trigger_test.go
@@ -19,7 +19,7 @@ func TestSimpleTriggerContext(t *testing.T) {
 }
 
 func TestNewCronTrigger(t *testing.T) {
-	assert.Panics(t, func() {
-		NewCronTrigger("", time.Local)
-	})
+	trigger, err := CreateCronTrigger("", time.Local)
+	assert.Error(t, err)
+	assert.Nil(t, trigger)
 }

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ package chrono`
`3`	`3`	`import (`
`4`	`4`	`"context"`
`5`	`5`	`"errors"`
	`6`	`+ "fmt"`
`6`	`7`	`"sort"`
`7`	`8`	`"sync"`
`8`	`9`	`"time"`
`@@ -16,9 +17,9 @@ type SchedulerTask struct {`
`16`	`17`	`location *time.Location`
`17`	`18`	`}`
`18`	`19`
`19`		`-func NewSchedulerTask(task Task, options ...Option) *SchedulerTask {`
	`20`	`+func CreateSchedulerTask(task Task, options ...Option) (*SchedulerTask, error) {`
`20`	`21`	`if task == nil {`
`21`		`- panic("task cannot be nil")`
	`22`	`+ return nil, errors.New("task cannot be nil")`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`runnableTask := &SchedulerTask{`
`@@ -28,10 +29,14 @@ func NewSchedulerTask(task Task, options ...Option) *SchedulerTask {`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`for _, option := range options {`
`31`		`- option(runnableTask)`
	`32`	`+ err := option(runnableTask)`
	`33`	`+`
	`34`	`+ if err != nil {`
	`35`	`+ return nil, err`
	`36`	`+ }`
`32`	`37`	`}`
`33`	`38`
`34`		`- return runnableTask`
	`39`	`+ return runnableTask, nil`
`35`	`40`	`}`
`36`	`41`
`37`	`42`	`func (task *SchedulerTask) GetInitialDelay() time.Duration {`
`@@ -50,23 +55,25 @@ func (task *SchedulerTask) GetInitialDelay() time.Duration {`
`50`	`55`	`return diff`
`51`	`56`	`}`
`52`	`57`
`53`		`-type Option func(task *SchedulerTask)`
	`58`	`+type Option func(task *SchedulerTask) error`
`54`	`59`
`55`	`60`	`func WithStartTime(year int, month time.Month, day, hour, min, sec int) Option {`
`56`		`- return func(task *SchedulerTask) {`
	`61`	`+ return func(task *SchedulerTask) error {`
`57`	`62`	`task.startTime = time.Date(year, month, day, hour, min, sec, 0, time.Local)`
	`63`	`+ return nil`
`58`	`64`	`}`
`59`	`65`	`}`
`60`	`66`
`61`	`67`	`func WithLocation(location string) Option {`
`62`		`- return func(task *SchedulerTask) {`
	`68`	`+ return func(task *SchedulerTask) error {`
`63`	`69`	`loadedLocation, err := time.LoadLocation(location)`
`64`	`70`
`65`	`71`	`if err != nil {`
`66`		`- panic(err)`
	`72`	`+ return fmt.Errorf("location not loaded : %s", location)`
`67`	`73`	`}`
`68`	`74`
`69`	`75`	`task.location = loadedLocation`
	`76`	`+ return nil`
`70`	`77`	`}`
`71`	`78`	`}`
`72`	`79`
`@@ -85,9 +92,9 @@ type ScheduledRunnableTask struct {`
`85`	`92`	`cancelled bool`
`86`	`93`	`}`
`87`	`94`
`88`		`-func NewScheduledRunnableTask(id int, task Task, triggerTime time.Time, period time.Duration, fixedRate bool) *ScheduledRunnableTask {`
	`95`	`+func CreateScheduledRunnableTask(id int, task Task, triggerTime time.Time, period time.Duration, fixedRate bool) (*ScheduledRunnableTask, error) {`
`89`	`96`	`if task == nil {`
`90`		`- panic("task cannot be nil")`
	`97`	`+ return nil, errors.New("task cannot be nil")`
`91`	`98`	`}`
`92`	`99`
`93`	`100`	`if period < 0 {`
`@@ -100,7 +107,7 @@ func NewScheduledRunnableTask(id int, task Task, triggerTime time.Time, period t`
`100`	`107`	`triggerTime: triggerTime,`
`101`	`108`	`period: period,`
`102`	`109`	`fixedRate: fixedRate,`
`103`		`- }`
	`110`	`+ }, nil`
`104`	`111`	`}`
`105`	`112`
`106`	`113`	`func (scheduledRunnableTask *ScheduledRunnableTask) Cancel() {`
`@@ -155,25 +162,25 @@ type TriggerTask struct {`
`155`	`162`	`nextTriggerTime time.Time`
`156`	`163`	`}`
`157`	`164`
`158`		`-func NewTriggerTask(task Task, executor TaskExecutor, trigger Trigger) *TriggerTask {`
	`165`	`+func CreateTriggerTask(task Task, executor TaskExecutor, trigger Trigger) (*TriggerTask, error) {`
`159`	`166`	`if task == nil {`
`160`		`- panic("task cannot be nil")`
	`167`	`+ return nil, errors.New("task cannot be nil")`
`161`	`168`	`}`
`162`	`169`
`163`	`170`	`if executor == nil {`
`164`		`- panic("executor cannot be nil")`
	`171`	`+ return nil, errors.New("executor cannot be nil")`
`165`	`172`	`}`
`166`	`173`
`167`	`174`	`if trigger == nil {`
`168`		`- panic("trigger cannot be nil")`
	`175`	`+ return nil, errors.New("trigger cannot be nil")`
`169`	`176`	`}`
`170`	`177`
`171`	`178`	`return &TriggerTask{`
`172`	`179`	`task: task,`
`173`	`180`	`executor: executor,`
`174`	`181`	`triggerContext: NewSimpleTriggerContext(),`
`175`	`182`	`trigger: trigger,`
`176`		`- }`
	`183`	`+ }, nil`
`177`	`184`	`}`
`178`	`185`
`179`	`186`	`func (task *TriggerTask) Cancel() {`
Original file line number	Diff line number	Diff line change
`@@ -45,11 +45,11 @@ type CronTrigger struct {`
`45`	`45`	`location *time.Location`
`46`	`46`	`}`
`47`	`47`
`48`		`-func NewCronTrigger(expression string, location time.Location) CronTrigger {`
	`48`	`+func CreateCronTrigger(expression string, location time.Location) (CronTrigger, error) {`
`49`	`49`	`cron, err := ParseCronExpression(expression)`
`50`	`50`
`51`	`51`	`if err != nil {`
`52`		`- panic(err)`
	`52`	`+ return nil, err`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`trigger := &CronTrigger{`
`@@ -61,7 +61,7 @@ func NewCronTrigger(expression string, location time.Location) CronTrigger {`
`61`	`61`	`trigger.location = location`
`62`	`62`	`}`
`63`	`63`
`64`		`- return trigger`
	`64`	`+ return trigger, nil`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`func (trigger *CronTrigger) NextExecutionTime(ctx TriggerContext) time.Time {`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ func TestSimpleTriggerContext(t *testing.T) {`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`func TestNewCronTrigger(t *testing.T) {`
`22`		`- assert.Panics(t, func() {`
`23`		`- NewCronTrigger("", time.Local)`
`24`		`- })`
	`22`	`+ trigger, err := CreateCronTrigger("", time.Local)`
	`23`	`+ assert.Error(t, err)`
	`24`	`+ assert.Nil(t, trigger)`
`25`	`25`	`}`