refactor!: module package structure (#87)

README.md

@@ -118,7 +118,7 @@ The argument must implement the `logger.Logger` interface.
 The following example shows how to disable library logs.
 
 ```go
-import "github.com/reugn/go-quartz/quartz/logger"
+import "github.com/reugn/go-quartz/logger"
 
 logger.SetDefault(logger.NewSimpleLogger(nil, logger.LevelOff))
 ```
@@ -133,6 +133,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/reugn/go-quartz/job"
 	"github.com/reugn/go-quartz/quartz"
 )
 
@@ -148,12 +149,12 @@ func main() {
 
 	// create jobs
 	cronTrigger, _ := quartz.NewCronTrigger("1/5 * * * * *")
-	shellJob := quartz.NewShellJob("ls -la")
+	shellJob := job.NewShellJob("ls -la")
 
 	request, _ := http.NewRequest(http.MethodGet, "https://worldtimeapi.org/api/timezone/utc", nil)
-	curlJob := quartz.NewCurlJob(request)
+	curlJob := job.NewCurlJob(request)
 
-	functionJob := quartz.NewFunctionJob(func(_ context.Context) (int, error) { return 42, nil })
+	functionJob := job.NewFunctionJob(func(_ context.Context) (int, error) { return 42, nil })
 
 	// register jobs to scheduler
 	sched.ScheduleJob(quartz.NewJobDetail(shellJob, quartz.NewJobKey("shellJob")),

examples/main.go

@@ -10,6 +10,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/reugn/go-quartz/job"
 	"github.com/reugn/go-quartz/quartz"
 )
 
@@ -84,14 +85,14 @@ func sampleJobs(ctx context.Context, wg *sync.WaitGroup) {
 		return
 	}
 
-	shellJob := quartz.NewShellJob("ls -la")
+	shellJob := job.NewShellJob("ls -la")
 	request, err := http.NewRequest(http.MethodGet, "https://worldtimeapi.org/api/timezone/utc", nil)
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
-	curlJob := quartz.NewCurlJob(request)
-	functionJob := quartz.NewFunctionJobWithDesc("42", func(_ context.Context) (int, error) { return 42, nil })
+	curlJob := job.NewCurlJob(request)
+	functionJob := job.NewFunctionJobWithDesc("42", func(_ context.Context) (int, error) { return 42, nil })
 
 	shellJobDetail := quartz.NewJobDetail(shellJob, quartz.NewJobKey("shellJob"))
 	curlJobDetail := quartz.NewJobDetail(curlJob, quartz.NewJobKey("curlJob"))

examples/readme/main.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/reugn/go-quartz/job"
 	"github.com/reugn/go-quartz/quartz"
 )
 
@@ -20,12 +21,12 @@ func main() {
 
 	// create jobs
 	cronTrigger, _ := quartz.NewCronTrigger("1/5 * * * * *")
-	shellJob := quartz.NewShellJob("ls -la")
+	shellJob := job.NewShellJob("ls -la")
 
 	request, _ := http.NewRequest(http.MethodGet, "https://worldtimeapi.org/api/timezone/utc", nil)
-	curlJob := quartz.NewCurlJob(request)
+	curlJob := job.NewCurlJob(request)
 
-	functionJob := quartz.NewFunctionJob(func(_ context.Context) (int, error) { return 42, nil })
+	functionJob := job.NewFunctionJob(func(_ context.Context) (int, error) { return 42, nil })
 
 	// register jobs to scheduler
 	sched.ScheduleJob(quartz.NewJobDetail(shellJob, quartz.NewJobKey("shellJob")),

internal/assert/assert.go

@@ -0,0 +1,18 @@
+package assert
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Equal[T any](t *testing.T, a T, b T) {
+	if !reflect.DeepEqual(a, b) {
+		t.Fatalf("%v != %v", a, b)
+	}
+}
+
+func NotEqual[T any](t *testing.T, a T, b T) {
+	if reflect.DeepEqual(a, b) {
+		t.Fatalf("%v == %v", a, b)
+	}
+}

internal/mock/http_handler.go

@@ -0,0 +1,40 @@
+package mock
+
+import (
+	"net/http"
+
+	"github.com/reugn/go-quartz/job"
+)
+
+type HTTPHandlerMock struct {
+	DoFunc func(req *http.Request) (*http.Response, error)
+}
+
+func (m HTTPHandlerMock) Do(req *http.Request) (*http.Response, error) {
+	return m.DoFunc(req)
+}
+
+var (
+	HTTPHandlerOk  job.HTTPHandler
+	HTTPHandlerErr job.HTTPHandler
+)
+
+func init() {
+	HTTPHandlerMockOk := struct{ HTTPHandlerMock }{}
+	HTTPHandlerMockOk.DoFunc = func(request *http.Request) (*http.Response, error) {
+		return &http.Response{
+			StatusCode: 200,
+			Request:    request,
+		}, nil
+	}
+	HTTPHandlerOk = job.HTTPHandler(HTTPHandlerMockOk)
+
+	HTTPHandlerMockErr := struct{ HTTPHandlerMock }{}
+	HTTPHandlerMockErr.DoFunc = func(request *http.Request) (*http.Response, error) {
+		return &http.Response{
+			StatusCode: 500,
+			Request:    request,
+		}, nil
+	}
+	HTTPHandlerErr = job.HTTPHandler(HTTPHandlerMockErr)
+}

job/curl_job.go

@@ -0,0 +1,115 @@
+package job
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+	"strings"
+	"sync"
+
+	"github.com/reugn/go-quartz/quartz"
+)
+
+// CurlJob represents a cURL command Job, implements the quartz.Job interface.
+// cURL is a command-line tool for getting or sending data including files
+// using URL syntax.
+type CurlJob struct {
+	sync.Mutex
+	httpClient  HTTPHandler
+	request     *http.Request
+	response    *http.Response
+	jobStatus   Status
+	description string
+	callback    func(context.Context, *CurlJob)
+}
+
+var _ quartz.Job = (*CurlJob)(nil)
+
+// HTTPHandler sends an HTTP request and returns an HTTP response,
+// following policy (such as redirects, cookies, auth) as configured
+// on the implementing HTTP client.
+type HTTPHandler interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+// CurlJobOptions represents optional parameters for constructing a CurlJob.
+type CurlJobOptions struct {
+	HTTPClient HTTPHandler
+	Callback   func(context.Context, *CurlJob)
+}
+
+// NewCurlJob returns a new CurlJob using the default HTTP client.
+func NewCurlJob(request *http.Request) *CurlJob {
+	return NewCurlJobWithOptions(request, CurlJobOptions{HTTPClient: http.DefaultClient})
+}
+
+// NewCurlJobWithOptions returns a new CurlJob configured with CurlJobOptions.
+func NewCurlJobWithOptions(request *http.Request, opts CurlJobOptions) *CurlJob {
+	if opts.HTTPClient == nil {
+		opts.HTTPClient = http.DefaultClient
+	}
+	return &CurlJob{
+		httpClient:  opts.HTTPClient,
+		request:     request,
+		jobStatus:   StatusNA,
+		description: formatRequest(request),
+		callback:    opts.Callback,
+	}
+}
+
+// Description returns the description of the CurlJob.
+func (cu *CurlJob) Description() string {
+	return fmt.Sprintf("CurlJob:\n%s", cu.description)
+}
+
+// DumpResponse returns the response of the job in its HTTP/1.x wire
+// representation.
+// If body is true, DumpResponse also returns the body.
+func (cu *CurlJob) DumpResponse(body bool) ([]byte, error) {
+	cu.Lock()
+	defer cu.Unlock()
+	return httputil.DumpResponse(cu.response, body)
+}
+
+// JobStatus returns the status of the CurlJob.
+func (cu *CurlJob) JobStatus() Status {
+	cu.Lock()
+	defer cu.Unlock()
+	return cu.jobStatus
+}
+
+func formatRequest(r *http.Request) string {
+	var request []string
+	url := fmt.Sprintf("%v %v %v", r.Method, r.URL, r.Proto)
+	request = append(request, url)
+	for name, headers := range r.Header {
+		for _, h := range headers {
+			request = append(request, fmt.Sprintf("%v: %v", name, h))
+		}
+	}
+	if r.ContentLength > 0 {
+		request = append(request, fmt.Sprintf("Content Length: %d", r.ContentLength))
+	}
+	return strings.Join(request, "\n")
+}
+
+// Execute is called by a Scheduler when the Trigger associated with this job fires.
+func (cu *CurlJob) Execute(ctx context.Context) error {
+	cu.Lock()
+	cu.request = cu.request.WithContext(ctx)
+	var err error
+	cu.response, err = cu.httpClient.Do(cu.request)
+
+	if err == nil && cu.response.StatusCode >= 200 && cu.response.StatusCode < 400 {
+		cu.jobStatus = StatusOK
+	} else {
+		cu.jobStatus = StatusFailure
+	}
+	cu.Unlock()
+
+	if cu.callback != nil {
+		cu.callback(ctx, cu)
+	}
+	return nil
+}

job/doc.go

@@ -0,0 +1,2 @@
+// Package job contains implementations of the quartz.Job interface.
+package job

quartz/function_job.go → job/function_job.go

@@ -1,9 +1,11 @@
-package quartz
+package job
 
 import (
 	"context"
 	"fmt"
 	"sync"
+
+	"github.com/reugn/go-quartz/quartz"
 )
 
 // Function represents an argument-less function which returns
@@ -18,17 +20,17 @@ type FunctionJob[R any] struct {
 	desc      string
 	result    *R
 	err       error
-	jobStatus JobStatus
+	jobStatus Status
 }
 
-var _ Job = (*FunctionJob[any])(nil)
+var _ quartz.Job = (*FunctionJob[any])(nil)
 
 // NewFunctionJob returns a new FunctionJob without an explicit description.
 func NewFunctionJob[R any](function Function[R]) *FunctionJob[R] {
 	return &FunctionJob[R]{
 		function:  &function,
 		desc:      fmt.Sprintf("FunctionJob:%p", &function),
-		jobStatus: NA,
+		jobStatus: StatusNA,
 	}
 }
 
@@ -37,7 +39,7 @@ func NewFunctionJobWithDesc[R any](desc string, function Function[R]) *FunctionJ
 	return &FunctionJob[R]{
 		function:  &function,
 		desc:      desc,
-		jobStatus: NA,
+		jobStatus: StatusNA,
 	}
 }
 
@@ -52,11 +54,11 @@ func (f *FunctionJob[R]) Execute(ctx context.Context) error {
 	result, err := (*f.function)(ctx)
 	f.Lock()
 	if err != nil {
-		f.jobStatus = FAILURE
+		f.jobStatus = StatusFailure
 		f.result = nil
 		f.err = err
 	} else {
-		f.jobStatus = OK
+		f.jobStatus = StatusOK
 		f.result = &result
 		f.err = nil
 	}
@@ -79,7 +81,7 @@ func (f *FunctionJob[R]) Error() error {
 }
 
 // JobStatus returns the status of the FunctionJob.
-func (f *FunctionJob[R]) JobStatus() JobStatus {
+func (f *FunctionJob[R]) JobStatus() Status {
 	f.RLock()
 	defer f.RUnlock()
 	return f.jobStatus