feat: add more unittests

cmd/cmd.go

@@ -33,7 +33,7 @@ func InitBackendContext(cmd *cobra.Command, _ []string) error {
 	ctx = db.WithContext(ctx, dbx)
 	dbstore := database.New(ctx, dbx)
 	ctx = store.WithContext(ctx, dbstore)
-	be := backend.New(ctx, cfg, dbx)
+	be := backend.New(ctx, cfg, dbx, dbstore)
 	ctx = backend.WithContext(ctx, be)
 
 	cmd.SetContext(ctx)

pkg/access/context_test.go

@@ -0,0 +1,20 @@
+package access
+
+import (
+	"context"
+	"testing"
+)
+
+func TestGoodFromContext(t *testing.T) {
+	ctx := WithContext(context.TODO(), AdminAccess)
+	if ac := FromContext(ctx); ac != AdminAccess {
+		t.Errorf("FromContext(ctx) => %d, want %d", ac, AdminAccess)
+	}
+}
+
+func TestBadFromContext(t *testing.T) {
+	ctx := context.TODO()
+	if ac := FromContext(ctx); ac != -1 {
+		t.Errorf("FromContext(ctx) => %d, want %d", ac, -1)
+	}
+}

pkg/backend/backend.go

@@ -23,14 +23,13 @@ type Backend struct {
 }
 
 // New returns a new Soft Serve backend.
-func New(ctx context.Context, cfg *config.Config, db *db.DB) *Backend {
-	dbstore := store.FromContext(ctx)
+func New(ctx context.Context, cfg *config.Config, db *db.DB, st store.Store) *Backend {
 	logger := log.FromContext(ctx).WithPrefix("backend")
 	b := &Backend{
 		ctx:     ctx,
 		cfg:     cfg,
 		db:      db,
-		store:   dbstore,
+		store:   st,
 		logger:  logger,
 		manager: task.NewManager(ctx),
 	}

pkg/config/context_test.go

@@ -0,0 +1,29 @@
+package config
+
+import (
+	"context"
+	"reflect"
+	"testing"
+)
+
+func TestBadFromContext(t *testing.T) {
+	ctx := context.TODO()
+	if c := FromContext(ctx); c != nil {
+		t.Errorf("FromContext(ctx) => %v, want %v", c, nil)
+	}
+}
+
+func TestGoodFromContext(t *testing.T) {
+	ctx := WithContext(context.TODO(), &Config{})
+	if c := FromContext(ctx); c == nil {
+		t.Errorf("FromContext(ctx) => %v, want %v", c, &Config{})
+	}
+}
+
+func TestGoodFromContextWithDefaultConfig(t *testing.T) {
+	cfg := DefaultConfig()
+	ctx := WithContext(context.TODO(), cfg)
+	if c := FromContext(ctx); c == nil || !reflect.DeepEqual(c, cfg) {
+		t.Errorf("FromContext(ctx) => %v, want %v", c, cfg)
+	}
+}

pkg/config/file_test.go

@@ -0,0 +1,15 @@
+package config
+
+import "testing"
+
+func TestNewConfigFile(t *testing.T) {
+	for _, cfg := range []*Config{
+		nil,
+		DefaultConfig(),
+		&Config{},
+	} {
+		if s := newConfigFile(cfg); s == "" {
+			t.Errorf("newConfigFile(nil) => %q, want non-empty string", s)
+		}
+	}
+}

pkg/config/ssh.go

@@ -1,8 +1,33 @@
 package config
 
-import "github.com/charmbracelet/keygen"
+import (
+	"errors"
+
+	"github.com/charmbracelet/keygen"
+)
+
+var (
+	// ErrNilConfig is returned when a nil config is passed to a function.
+	ErrNilConfig = errors.New("nil config")
+
+	// ErrEmptySSHKeyPath is returned when the SSH key path is empty.
+	ErrEmptySSHKeyPath = errors.New("empty SSH key path")
+)
 
 // KeyPair returns the server's SSH key pair.
 func (c SSHConfig) KeyPair() (*keygen.SSHKeyPair, error) {
 	return keygen.New(c.KeyPath, keygen.WithKeyType(keygen.Ed25519))
 }
+
+// KeyPair returns the server's SSH key pair.
+func KeyPair(cfg *Config) (*keygen.SSHKeyPair, error) {
+	if cfg == nil {
+		return nil, ErrNilConfig
+	}
+
+	if cfg.SSH.KeyPath == "" {
+		return nil, ErrEmptySSHKeyPath
+	}
+
+	return keygen.New(cfg.SSH.KeyPath, keygen.WithKeyType(keygen.Ed25519))
+}

pkg/config/ssh_test.go

@@ -0,0 +1,26 @@
+package config
+
+import "testing"
+
+func TestBadSSHKeyPair(t *testing.T) {
+	for _, cfg := range []*Config{
+		nil,
+		{},
+	} {
+		if _, err := KeyPair(cfg); err == nil {
+			t.Errorf("cfg.SSH.KeyPair() => _, nil, want non-nil error")
+		}
+	}
+}
+
+func TestGoodSSHKeyPair(t *testing.T) {
+	cfg := &Config{
+		SSH: SSHConfig{
+			KeyPath: "testdata/ssh_host_ed25519_key",
+		},
+	}
+
+	if _, err := KeyPair(cfg); err != nil {
+		t.Errorf("cfg.SSH.KeyPair() => _, %v, want nil error", err)
+	}
+}

pkg/cron/cron_test.go

@@ -0,0 +1,31 @@
+package cron
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/charmbracelet/log"
+)
+
+func TestCronLogger(t *testing.T) {
+	var buf bytes.Buffer
+	logger := log.New(&buf)
+	logger.SetLevel(log.DebugLevel)
+	clogger := cronLogger{logger}
+	clogger.Info("foo")
+	clogger.Error(fmt.Errorf("bar"), "test")
+	if buf.String() != "DEBU foo\nERRO test err=bar\n" {
+		t.Errorf("unexpected log output: %s", buf.String())
+	}
+}
+
+func TestSchedularAddRemove(t *testing.T) {
+	s := NewScheduler(context.TODO())
+	id, err := s.AddFunc("* * * * *", func() {})
+	if err != nil {
+		t.Fatal(err)
+	}
+	s.Remove(id)
+}

pkg/daemon/daemon_test.go

@@ -50,7 +50,7 @@ func TestMain(m *testing.M) {
 	}
 	datastore := database.New(ctx, dbx)
 	ctx = store.WithContext(ctx, datastore)
-	be := backend.New(ctx, cfg, dbx)
+	be := backend.New(ctx, cfg, dbx, datastore)
 	ctx = backend.WithContext(ctx, be)
 	d, err := NewGitDaemon(ctx)
 	if err != nil {

pkg/db/context_test.go

@@ -0,0 +1,25 @@
+package db
+
+import (
+	"context"
+	"testing"
+)
+
+func TestBadFromContext(t *testing.T) {
+	ctx := context.TODO()
+	if c := FromContext(ctx); c != nil {
+		t.Errorf("FromContext(ctx) => %v, want %v", c, nil)
+	}
+}
+
+func TestGoodFromContext(t *testing.T) {
+	ctx := context.TODO()
+	dbx, err := testOpenSqlite(t, ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx = WithContext(ctx, dbx)
+	if c := FromContext(ctx); c == nil {
+		t.Errorf("FromContext(ctx) => %v, want %v", c, dbx)
+	}
+}

pkg/db/db_test.go

@@ -0,0 +1,38 @@
+package db
+
+import (
+	"context"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// testOpenSqlite opens a new temp SQLite database for testing.
+// It removes the database file when the test is done using tb.Cleanup.
+// If ctx is nil, context.TODO() is used.
+func testOpenSqlite(tb testing.TB, ctx context.Context) (*DB, error) {
+	if ctx == nil {
+		ctx = context.TODO()
+	}
+	dbpath := filepath.Join(tb.TempDir(), "test.db")
+	dbx, err := Open(ctx, "sqlite", dbpath)
+	if err != nil {
+		return nil, err
+	}
+	tb.Cleanup(func() {
+		if err := dbx.Close(); err != nil {
+			tb.Error(err)
+		}
+	})
+	return dbx, nil
+}
+
+func TestOpenUnknownDriver(t *testing.T) {
+	_, err := Open(context.TODO(), "invalid", "")
+	if err == nil {
+		t.Error("Open(invalid) => nil, want error")
+	}
+	if !strings.Contains(err.Error(), "unknown driver") {
+		t.Errorf("Open(invalid) => %v, want error containing 'unknown driver'", err)
+	}
+}

pkg/db/errors_test.go

@@ -0,0 +1,25 @@
+package db
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestWrapErrorBadNoRows(t *testing.T) {
+	for _, e := range []error{
+		fmt.Errorf("foo"),
+		errors.New("bar"),
+	} {
+		if err := WrapError(e); err != e {
+			t.Errorf("WrapError(%v) => %v, want %v", e, err, e)
+		}
+	}
+}
+
+func TestWrapErrorGoodNoRows(t *testing.T) {
+	if err := WrapError(sql.ErrNoRows); err != ErrRecordNotFound {
+		t.Errorf("WrapError(sql.ErrNoRows) => %v, want %v", err, ErrRecordNotFound)
+	}
+}

pkg/git/git.go

@@ -2,6 +2,7 @@ package git
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"path/filepath"
@@ -13,6 +14,11 @@ import (
 	"github.com/go-git/go-git/v5/plumbing/format/pktline"
 )
 
+var (
+	// ErrNoBranches is returned when a repo has no branches.
+	ErrNoBranches = errors.New("no branches found")
+)
+
 // WritePktline encodes and writes a pktline to the given writer.
 func WritePktline(w io.Writer, v ...interface{}) error {
 	msg := fmt.Sprintln(v...)
@@ -57,18 +63,18 @@ func EnsureWithin(reposDir string, repo string) error {
 
 // EnsureDefaultBranch ensures the repo has a default branch.
 // It will prefer choosing "main" or "master" if available.
-func EnsureDefaultBranch(ctx context.Context, scmd ServiceCommand) error {
-	r, err := git.Open(scmd.Dir)
+func EnsureDefaultBranch(ctx context.Context, repoPath string) error {
+	r, err := git.Open(repoPath)
 	if err != nil {
 		return err
 	}
 	brs, err := r.Branches()
+	if len(brs) == 0 {
+		return ErrNoBranches
+	}
 	if err != nil {
 		return err
 	}
-	if len(brs) == 0 {
-		return fmt.Errorf("no branches found")
-	}
 	// Rename the default branch to the first branch available
 	_, err = r.HEAD()
 	if err == git.ErrReferenceNotExist {

pkg/git/git_test.go

@@ -2,8 +2,12 @@ package git
 
 import (
 	"bytes"
+	"context"
+	"errors"
 	"fmt"
 	"testing"
+
+	"github.com/charmbracelet/soft-serve/git"
 )
 
 func TestPktline(t *testing.T) {
@@ -54,3 +58,40 @@ func TestPktline(t *testing.T) {
 		})
 	}
 }
+
+func TestEnsureWithinBad(t *testing.T) {
+	tmp := t.TempDir()
+	for _, f := range []string{
+		"..",
+		"../../../",
+	} {
+		if err := EnsureWithin(tmp, f); err == nil {
+			t.Errorf("EnsureWithin(%q, %q) => nil, want non-nil error", tmp, f)
+		}
+	}
+}
+
+func TestEnsureWithinGood(t *testing.T) {
+	tmp := t.TempDir()
+	for _, f := range []string{
+		tmp,
+		tmp + "/foo",
+		tmp + "/foo/bar",
+	} {
+		if err := EnsureWithin(tmp, f); err != nil {
+			t.Errorf("EnsureWithin(%q, %q) => %v, want nil error", tmp, f, err)
+		}
+	}
+}
+
+func TestEnsureDefaultBranchEmpty(t *testing.T) {
+	tmp := t.TempDir()
+	r, err := git.Init(tmp, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := EnsureDefaultBranch(context.TODO(), r.Path); !errors.Is(err, ErrNoBranches) {
+		t.Errorf("EnsureDefaultBranch(%q) => %v, want ErrNoBranches", tmp, err)
+	}
+}