Add WithTime method for scheduling tasks. WithStartTime is deprecated. (#10)

* Add WithTime method for scheduling tasks. WithStartTime is deprecated.

* Add new go versions for travis

Author: burakkoken

.travis.yml

@@ -4,6 +4,9 @@ go:
   - 1.13.x
   - 1.14.x
   - 1.15.x
+  - 1.16.x
+  - 1.17.x
+  - 1.18.x
 
 before_install:
   - go get -t -v ./...

README.md

@@ -7,8 +7,24 @@
 Chrono is a scheduler library that lets you run your tasks and code periodically. It provides different scheduling functionalities to make it easier to create a scheduling task.
 
 ## Scheduling a One-Shot Task
-The Schedule method helps us schedule the task to run once at the specified time. In the following example, the task will first be executed 1 second after the current time. 
-**WithStartTime** option is used to specify the execution time.
+The Schedule method helps us schedule the task to run once at the specified time. In the following example, the task will first be executed 1 second after the current time.
+**WithTime** option is used to specify the execution time.
+
+```go
+taskScheduler := chrono.NewDefaultTaskScheduler()
+now := time.Now()
+startTime := now.Add(time.Second * 1)
+
+task, err := taskScheduler.Schedule(func(ctx context.Context) {
+	log.Print("One-Shot Task")
+}, WithTime(startTime))
+
+if err == nil {
+	log.Print("Task has been scheduled successfully.")
+}
+```
+
+Also, **WithStartTime** option can be used to specify the execution time. **But It's deprecated.**
 
 ```go
 taskScheduler := chrono.NewDefaultTaskScheduler()

scheduler_test.go

@@ -26,6 +26,25 @@ func TestDefaultTaskScheduler(t *testing.T) {
 		"number of scheduled task execution must be 1, actual: %d", counter)
 }
 
+func TestDefaultTaskSchedulerWithTimeOption(t *testing.T) {
+	scheduler := NewDefaultTaskScheduler()
+
+	var counter int32
+	now := time.Now()
+	starTime := now.Add(time.Second * 1)
+
+	task, err := scheduler.Schedule(func(ctx context.Context) {
+		atomic.AddInt32(&counter, 1)
+	}, WithTime(starTime))
+
+	assert.Nil(t, err)
+
+	<-time.After(2 * time.Second)
+	assert.True(t, task.IsCancelled(), "scheduled task must have been cancelled")
+	assert.True(t, counter == 1,
+		"number of scheduled task execution must be 1, actual: %d", counter)
+}
+
 func TestSimpleTaskScheduler_ScheduleWithoutTask(t *testing.T) {
 	scheduler := NewDefaultTaskScheduler()
 	task, err := scheduler.Schedule(nil)
@@ -81,7 +100,26 @@ func TestSimpleTaskScheduler_WithoutScheduledExecutor(t *testing.T) {
 		"number of scheduled task execution must be 1, actual: %d", counter)
 }
 
-func TestSimpleTaskScheduler_Schedule_OneShotTask(t *testing.T) {
+func TestSimpleTaskScheduler_WithoutScheduledExecutorWithTimeOption(t *testing.T) {
+	scheduler := NewSimpleTaskScheduler(nil)
+
+	var counter int32
+	now := time.Now()
+	startTime := now.Add(time.Second * 1)
+
+	task, err := scheduler.Schedule(func(ctx context.Context) {
+		atomic.AddInt32(&counter, 1)
+	}, WithTime(startTime))
+
+	assert.Nil(t, err)
+
+	<-time.After(2 * time.Second)
+	assert.True(t, task.IsCancelled(), "scheduled task must have been cancelled")
+	assert.True(t, counter == 1,
+		"number of scheduled task execution must be 1, actual: %d", counter)
+}
+
+func TestSimpleTaskScheduler_ScheduleOneShotTaskWithStartTimeOption(t *testing.T) {
 	scheduler := NewSimpleTaskScheduler(NewDefaultTaskExecutor())
 
 	var counter int32
@@ -99,6 +137,25 @@ func TestSimpleTaskScheduler_Schedule_OneShotTask(t *testing.T) {
 		"number of scheduled task execution must be 1, actual: %d", counter)
 }
 
+func TestSimpleTaskScheduler_ScheduleOneShotTaskWithTimeOption(t *testing.T) {
+	scheduler := NewSimpleTaskScheduler(NewDefaultTaskExecutor())
+
+	var counter int32
+	now := time.Now()
+	startTime := now.Add(time.Second * 1)
+
+	task, err := scheduler.Schedule(func(ctx context.Context) {
+		atomic.AddInt32(&counter, 1)
+	}, WithTime(startTime))
+
+	assert.Nil(t, err)
+
+	<-time.After(2 * time.Second)
+	assert.True(t, task.IsCancelled(), "scheduled task must have been cancelled")
+	assert.True(t, counter == 1,
+		"number of scheduled task execution must be 1, actual: %d", counter)
+}
+
 func TestSimpleTaskScheduler_ScheduleWithFixedDelay(t *testing.T) {
 	scheduler := NewSimpleTaskScheduler(NewDefaultTaskExecutor())
 
@@ -136,6 +193,26 @@ func TestSimpleTaskScheduler_ScheduleWithFixedDelayWithStartTimeOption(t *testin
 		"number of scheduled task execution must be between 1 and 3, actual: %d", counter)
 }
 
+func TestSimpleTaskScheduler_ScheduleWithFixedDelayWithTimeOption(t *testing.T) {
+	scheduler := NewSimpleTaskScheduler(NewDefaultTaskExecutor())
+
+	var counter int32
+	now := time.Now()
+	startTime := now.Add(time.Second * 1)
+
+	task, err := scheduler.ScheduleWithFixedDelay(func(ctx context.Context) {
+		atomic.AddInt32(&counter, 1)
+		<-time.After(500 * time.Millisecond)
+	}, 200*time.Millisecond, WithTime(startTime))
+
+	assert.Nil(t, err)
+
+	<-time.After(2*time.Second + 500*time.Millisecond)
+	task.Cancel()
+	assert.True(t, counter >= 1 && counter <= 3,
+		"number of scheduled task execution must be between 1 and 3, actual: %d", counter)
+}
+
 func TestSimpleTaskScheduler_ScheduleAtFixedRate(t *testing.T) {
 	scheduler := NewSimpleTaskScheduler(NewDefaultTaskExecutor())
 
@@ -172,6 +249,26 @@ func TestSimpleTaskScheduler_ScheduleAtFixedRateWithStartTimeOption(t *testing.T
 		"number of scheduled task execution must be between 5 and 10, actual: %d", counter)
 }
 
+func TestSimpleTaskScheduler_ScheduleAtFixedRateWithTimeOption(t *testing.T) {
+	scheduler := NewSimpleTaskScheduler(NewDefaultTaskExecutor())
+
+	var counter int32
+	now := time.Now()
+	startTime := now.Add(time.Second * 1)
+
+	task, err := scheduler.ScheduleAtFixedRate(func(ctx context.Context) {
+		atomic.AddInt32(&counter, 1)
+		<-time.After(500 * time.Millisecond)
+	}, 200*time.Millisecond, WithTime(startTime))
+
+	assert.Nil(t, err)
+
+	<-time.After(3*time.Second - 50*time.Millisecond)
+	task.Cancel()
+	assert.True(t, counter >= 5 && counter <= 10,
+		"number of scheduled task execution must be between 5 and 10, actual: %d", counter)
+}
+
 func TestSimpleTaskScheduler_ScheduleWithCron(t *testing.T) {
 	scheduler := NewSimpleTaskScheduler(NewDefaultTaskExecutor())
 

task.go

@@ -57,6 +57,19 @@ func (task *SchedulerTask) GetInitialDelay() time.Duration {
 
 type Option func(task *SchedulerTask) error
 
+func WithTime(t time.Time) Option {
+	return func(task *SchedulerTask) error {
+		task.startTime = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), 0, time.Local)
+
+		if t.Location() != nil && t.Location() != time.Local {
+			task.location = t.Location()
+		}
+
+		return nil
+	}
+}
+
+// Deprecated: Use WithTime instead.
 func WithStartTime(year int, month time.Month, day, hour, min, sec int) Option {
 	return func(task *SchedulerTask) error {
 		task.startTime = time.Date(year, month, day, hour, min, sec, 0, time.Local)