Merge pull request #58 from pior/linters

Fix linter errors

Author: pior

.golangci.yml

@@ -2,7 +2,6 @@ package runnable
 
 import (
 	"context"
-	"errors"
 	"testing"
 	"time"
 
@@ -66,8 +65,8 @@ func Test_Closer_Close_Error(t *testing.T) {
 
 	err := CloserErr(closer).Run(ctx)
 	require.EqualError(t, err, "closer: Close() returned an error: dummy error")
-	require.IsType(t, &RunnableError{}, err)
-	require.True(t, errors.Is(err, testErr))
+	require.ErrorAs(t, err, new(*RunnableError))
+	require.ErrorIs(t, err, testErr)
 
 	require.Equal(t, 1, closer.called)
 }
@@ -106,7 +105,7 @@ func Test_CloserCtxErr(t *testing.T) {
 
 		err := CloserCtxErr(closer).Run(ctx)
 		require.EqualError(t, err, "closer: Close() returned an error: close failed")
-		require.True(t, errors.Is(err, testErr))
+		require.ErrorIs(t, err, testErr)
 		require.Equal(t, 1, closer.called)
 		require.NoError(t, closer.ctxErr, "context passed to Close should not be cancelled")
 	})

closer_test.go

@@ -4,89 +4,80 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"net/http"
 	"os"
 	"time"
 
 	"github.com/pior/runnable"
 )
 
-func NewJobs() *Jobs {
-	return &Jobs{queue: make(chan string)}
-}
-
-type Jobs struct {
-	queue chan string
-}
-
-func (s *Jobs) Perform(id string) {
-	s.queue <- id
-}
-
-// Run executes enqueued jobs, drains the queue and quits.
-func (s *Jobs) Run(ctx context.Context) error {
-	for {
-		select {
-		case id := <-s.queue:
-			fmt.Printf("Starting job %s\n", id)
-			time.Sleep(time.Second)
-			fmt.Printf("Completed job %s\n", id)
-
-		default:
-			if err := ctx.Err(); err != nil {
-				close(s.queue)
-				return err
+// exampleLogger returns a text logger writing to stdout without timestamps,
+// suitable for deterministic testable examples.
+func exampleLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
+		ReplaceAttr: func(_ []string, a slog.Attr) slog.Attr {
+			if a.Key == slog.TimeKey {
+				return slog.Attr{}
 			}
-		}
-	}
+			return a
+		},
+	}))
 }
 
-type CleanupTask struct{}
+// JobQueue is a long-running service that processes background jobs.
+type JobQueue struct{}
 
-func (*CleanupTask) Run(ctx context.Context) error {
+func (q *JobQueue) Run(ctx context.Context) error {
 	<-ctx.Done()
 	return nil
 }
 
-func Example() {
-	runnable.SetLogger(slog.New(slog.NewTextHandler(os.Stdout, nil)))
-
-	g := runnable.Manager()
+func (q *JobQueue) Enqueue(job string) {
+	fmt.Println("JobQueue: " + job)
+}
 
-	jobs := NewJobs()
-	g.RegisterService(jobs)
+// CleanupTask enqueues a cleanup job on each execution.
+type CleanupTask struct {
+	jobs *JobQueue
+	runs int
+	done chan struct{}
+}
 
-	server := &http.Server{
-		Addr: "127.0.0.1:8080",
-		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			id := r.URL.Query().Get("id")
-			jobs.Perform(id)
-		}),
+func (t *CleanupTask) Run(_ context.Context) error {
+	t.runs++
+	t.jobs.Enqueue(fmt.Sprintf("cleanup-%d", t.runs))
+	if t.runs >= 3 {
+		close(t.done)
 	}
-	g.Register(runnable.HTTPServer(server))
+	return nil
+}
 
-	task := runnable.Func(func(ctx context.Context) error {
-		_, _ = http.Post("http://127.0.0.1:8080/?id=1", "test/plain", nil)
-		_, _ = http.Post("http://127.0.0.1:8080/?id=2", "test/plain", nil)
-		_, _ = http.Post("http://127.0.0.1:8080/?id=3", "test/plain", nil)
+func Example() {
+	runnable.SetLogger(exampleLogger())
 
-		return nil // quit right away, will trigger a shutdown
-	}).Name("enqueue")
-	g.Register(task)
+	jobs := &JobQueue{}
+	done := make(chan struct{})
+	cleanup := &CleanupTask{jobs: jobs, done: done}
 
-	cleanup := runnable.Schedule(&CleanupTask{}, runnable.Hourly())
-	g.Register(cleanup)
+	m := runnable.Manager()
+	m.RegisterService(jobs)
+	m.Register(runnable.Schedule(cleanup, runnable.Every(500*time.Millisecond)))
+	m.Register(runnable.Func(func(_ context.Context) error {
+		<-done
+		return nil
+	}).Name("app"))
 
-	runnable.Run(g)
+	runnable.Run(m)
 
-	// level=INFO msg="manager/Jobs: started"
-	// level=INFO msg="manager/httpserver: started"
-	// level=INFO msg="manager/enqueue: started"
+	// Output:
+	// level=INFO msg="manager/JobQueue: started"
 	// level=INFO msg="manager/schedule/CleanupTask: started"
-	// level=INFO msg="httpserver: listening" addr=127.0.0.1:8080
-	// Starting job 1
-	// Completed job 1
-	// ...
-	// level=INFO msg="manager: starting shutdown" reason="enqueue died"
+	// level=INFO msg="manager/app: started"
+	// JobQueue: cleanup-1
+	// JobQueue: cleanup-2
+	// JobQueue: cleanup-3
+	// level=INFO msg="manager/app: stopped"
+	// level=INFO msg="manager: starting shutdown" reason="app died"
+	// level=INFO msg="manager/schedule/CleanupTask: stopped"
+	// level=INFO msg="manager/JobQueue: stopped"
 	// level=INFO msg="manager: shutdown complete"
 }

example_test.go

@@ -8,12 +8,11 @@ func init() {
 	SetLogger(nil)
 }
 
-// SetLogger replaces the default logger with a *slog.Logger.
-// Passing nil resets to slog.Default().
+// SetLogger replaces the default logger with a [*slog.Logger].
+// Passing nil resets to [slog.Default].
 func SetLogger(l *slog.Logger) {
 	if l == nil {
 		l = slog.Default()
 	}
 	logger = l
 }
-

logger.go

@@ -6,7 +6,7 @@ import (
 )
 
 type PanicError struct {
-	value interface{}
+	value any
 }
 
 func (e *PanicError) Error() string {

recover.go

@@ -2,26 +2,27 @@ package runnable
 
 import (
 	"context"
+	"errors"
 	stdlog "log"
 )
 
-// RunGroup runs all runnables in a Manager, and listen to SIGTERM/SIGINT
+// RunGroup runs all runnables in a Manager, and listens to SIGTERM/SIGINT.
 func RunGroup(runners ...Runnable) {
 	m := Manager()
 	m.Register(runners...)
 	Run(m)
 }
 
-// Run runs a single runnable, and listen to SIGTERM/SIGINT
+// Run runs a single runnable, and listens to SIGTERM/SIGINT.
 func Run(runner Runnable) {
 	ctx := context.Background()
 	err := Signal(runner).Run(ctx)
-	if err != nil && err != context.Canceled {
+	if err != nil && !errors.Is(err, context.Canceled) {
 		stdlog.Fatal(err)
 	}
 }
 
-// RunFunc runs a runnable function, and listen to SIGTERM/SIGINT
+// RunFunc runs a runnable function, and listens to SIGTERM/SIGINT.
 func RunFunc(fn RunnableFunc) {
 	Run(Func(fn))
 }

run.go

@@ -2,6 +2,7 @@ package runnable
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -65,7 +66,7 @@ func (r *httpServer) Run(ctx context.Context) error {
 		// Server stopped on its own — no Shutdown needed.
 	}
 
-	if err == http.ErrServerClosed {
+	if errors.Is(err, http.ErrServerClosed) {
 		err = nil
 	}
 	if err != nil {

server.go

@@ -44,8 +44,8 @@ func TestHTTPServer(t *testing.T) {
 		cancel()
 
 		select {
-		case err := <-errChan:
-			require.NoError(t, err)
+		case runErr := <-errChan:
+			require.NoError(t, runErr)
 		case <-time.After(5 * time.Second):
 			t.Fatal("server did not shut down within 5s")
 		}
@@ -105,7 +105,6 @@ func TestHTTPServer(t *testing.T) {
 
 		require.Equal(t, fmt.Sprint(5*time.Second), fmt.Sprint(r.shutdownTimeout))
 	})
-
 }
 
 func ExampleHTTPServer() {