tests: Add tests (#75)

* tests: Add tests

* fix: Vet

* tests: Add more tests

* fix: Sonar code smells

* tests: improve coverage

* tests: Increase test coverage

* tests: Increase coverage

* bypass nilcontext

* fix: io.Reader scanner bugs

Author: obalunenko

cmd/aoc-cli/handlers.go

@@ -68,7 +68,7 @@ func notFound(ctx context.Context) cli.CommandNotFoundFunc {
 }
 func menu(ctx context.Context) cli.ActionFunc {
 	return func(c *cli.Context) error {
-		ctx = command.ContextWithOptions(ctx, optionsFromCli(c))
+		ctx = command.ContextWithOptions(ctx, optionsFromCli(c)...)
 		ctx = command.ContextWithSession(ctx, sessionFromCli(c))
 
 		years := puzzles.GetYears()

internal/command/command_test.go

@@ -0,0 +1,124 @@
+package command_test
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/obalunenko/advent-of-code/internal/command"
+	"github.com/obalunenko/advent-of-code/internal/puzzles"
+	"github.com/obalunenko/advent-of-code/internal/puzzles/input"
+)
+
+// Custom type that allows setting the func that our Mock Do func will run instead
+type dofunc func(req *http.Request) (*http.Response, error)
+
+// MockClient is the mock client
+type mockHTTPClient struct {
+	MockDo dofunc
+}
+
+// Overriding what the Do function should "do" in our MockClient
+func (m *mockHTTPClient) Do(req *http.Request) (*http.Response, error) {
+	return m.MockDo(req)
+}
+
+type mockSolver struct {
+	year string
+	name string
+}
+
+func (m mockSolver) Year() string {
+	return m.year
+}
+
+func (m mockSolver) Day() string {
+	return m.name
+}
+
+func (m mockSolver) Part1(in io.Reader) (string, error) {
+	split, err := read(in)
+	if err != nil {
+		return "", err
+	}
+
+	return split[1], nil
+}
+
+func (m mockSolver) Part2(in io.Reader) (string, error) {
+	split, err := read(in)
+	if err != nil {
+		return "", err
+	}
+
+	return split[2], nil
+}
+
+func read(in io.Reader) ([]string, error) {
+	all, err := io.ReadAll(in)
+	if err != nil {
+		return nil, err
+	}
+
+	split := strings.Split(string(all), ",")
+
+	if len(split) != 3 {
+		return nil, errors.New("wrong parts")
+	}
+
+	return split, nil
+}
+
+func TestRun(t *testing.T) {
+	ctx := context.Background()
+
+	year := "1992"
+	day := "31"
+
+	puzzles.Register(mockSolver{
+		year: year,
+		name: day,
+	})
+
+	t.Cleanup(func() {
+		puzzles.UnregisterAllSolvers(t)
+	})
+
+	r := io.NopCloser(strings.NewReader("1,2,3"))
+
+	input.Client = &mockHTTPClient{
+		MockDo: func(req *http.Request) (*http.Response, error) {
+			return &http.Response{
+				Status:           http.StatusText(http.StatusOK),
+				StatusCode:       http.StatusOK,
+				Proto:            "HTTP/1.0",
+				ProtoMajor:       1,
+				ProtoMinor:       0,
+				Header:           nil,
+				Body:             r,
+				ContentLength:    0,
+				TransferEncoding: nil,
+				Close:            false,
+				Uncompressed:     false,
+				Trailer:          nil,
+				Request:          nil,
+				TLS:              nil,
+			}, nil
+		},
+	}
+
+	got, err := command.Run(ctx, year, day)
+	assert.NoError(t, err)
+
+	assert.Equal(t, puzzles.Result{
+		Year:  "1992",
+		Name:  "31",
+		Part1: "2",
+		Part2: "3",
+	}, got)
+}

internal/command/context.go

@@ -36,7 +36,7 @@ func SessionFromContext(ctx context.Context) string {
 type optsCtxKey struct{}
 
 // ContextWithOptions adds options to context.
-func ContextWithOptions(ctx context.Context, opts []puzzles.RunOption) context.Context {
+func ContextWithOptions(ctx context.Context, opts ...puzzles.RunOption) context.Context {
 	if len(opts) == 0 {
 		return ctx
 	}

internal/command/context_test.go

@@ -0,0 +1,43 @@
+package command_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/obalunenko/advent-of-code/internal/command"
+	"github.com/obalunenko/advent-of-code/internal/puzzles"
+)
+
+func nilContext() context.Context {
+	return nil
+}
+
+func TestContext(t *testing.T) {
+	sess := "test_session"
+
+	ctx := command.ContextWithSession(context.Background(), sess)
+
+	got := command.SessionFromContext(ctx)
+	assert.Equal(t, sess, got)
+
+	got = command.SessionFromContext(nilContext())
+	assert.Equal(t, "", got)
+
+	got = command.SessionFromContext(context.Background())
+	assert.Equal(t, "", got)
+
+	opt := puzzles.WithElapsed()
+
+	ctx = command.ContextWithOptions(ctx, opt)
+
+	gotopts := command.OptionsFromContext(ctx)
+	assert.Equal(t, []puzzles.RunOption{opt}, gotopts)
+
+	gotopts = command.OptionsFromContext(nilContext())
+	assert.Equal(t, []puzzles.RunOption{}, gotopts)
+
+	gotopts = command.OptionsFromContext(context.Background())
+	assert.Equal(t, []puzzles.RunOption{}, gotopts)
+}

internal/puzzles/input/content.go

@@ -31,15 +31,21 @@ func (d Date) String() string {
 	return path.Join(d.Year, d.Day)
 }
 
+// ClientDo provides the interface for custom HTTP client implementations.
+type ClientDo interface {
+	Do(*http.Request) (*http.Response, error)
+}
+
+// Client is the default Client and is used by Get, Head, and Post.
+var Client ClientDo = http.DefaultClient
+
 // Get returns puzzle input.
 func Get(ctx context.Context, d Date, session string) ([]byte, error) {
 	req, err := createInputReq(ctx, d, session)
 	if err != nil {
 		return nil, fmt.Errorf("create input request: %w", err)
 	}
 
-	client := http.DefaultClient
-
 	const (
 		timeoutSecs = 5
 	)
@@ -49,7 +55,7 @@ func Get(ctx context.Context, d Date, session string) ([]byte, error) {
 
 	req = req.Clone(ctx)
 
-	resp, err := client.Do(req)
+	resp, err := Client.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("send request: %w", err)
 	}