coder · johnstcn · Aug 24, 2021 · Aug 18, 2021 · Aug 18, 2021 · Aug 18, 2021
diff --git a/internal/api/skip.go b/internal/api/skip.go
@@ -0,0 +1,11 @@
+package api
+
+// SkippedResult returns a CheckResult indicating the check was skipped.
+func SkippedResult(name string, summary string) *CheckResult {
+	return &CheckResult{
+		Name:    name,
+		State:   StateSkipped,
+		Summary: summary,
+		Details: map[string]interface{}{},
+	}
+}
diff --git a/internal/api/skip_test.go b/internal/api/skip_test.go
@@ -0,0 +1,19 @@
+package api_test
+
+import (
+	"testing"
+
+	"cdr.dev/slog/sloggers/slogtest/assert"
+	"github.com/cdr/coder-doctor/internal/api"
+)
+
+func TestSkippedResult(t *testing.T) {
+	t.Parallel()
+
+	checkName := "don't wanna"
+	checkSummary := "just because"
+	res := api.SkippedResult(checkName, checkSummary)
+	assert.Equal(t, "name matches", checkName, res.Name)
+	assert.Equal(t, "state matches", api.StateSkipped, res.State)
+	assert.Equal(t, "summary matches", checkSummary, res.Summary)
+}
diff --git a/internal/api/types.go b/internal/api/types.go
@@ -119,3 +119,17 @@ type CheckResult struct {
 	Summary string                 `json:"summary"`
 	Details map[string]interface{} `json:"details,omitempty"`
 }
+
+// CheckTarget indicates the subject of a Checker
+type CheckTarget string
+
+const (
+	// CheckTargetUndefined indicates that a Checker does not run against any specific target.
+	CheckTargetUndefined CheckTarget = ""
+
+	// CheckTargetLocal indicates that a Checker runs against the local machine.
+	CheckTargetLocal CheckTarget = "local"
+
+	// CheckTargetKubernetes indicates that a Checker runs against a Kubernetes cluster.
+	CheckTargetKubernetes = "kubernetes"
+)
diff --git a/internal/api/version.go b/internal/api/version.go
@@ -0,0 +1,15 @@
+package api
+
+import (
+	"github.com/Masterminds/semver/v3"
+	"golang.org/x/xerrors"
+)
+
+func MustConstraint(s string) *semver.Constraints {
+	c, err := semver.NewConstraint(s)
+	if err != nil {
+		panic(xerrors.Errorf("parse constraint: %w", err))
+	}
+
+	return c
+}
diff --git a/internal/checks/kube/kubernetes.go b/internal/checks/kube/kubernetes.go
@@ -5,8 +5,8 @@ import (
 	"io"
 
 	"github.com/Masterminds/semver/v3"
-	"k8s.io/client-go/kubernetes"
 	"golang.org/x/xerrors"
+	"k8s.io/client-go/kubernetes"
 
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/sloghuman"

diff --git a/internal/checks/local/helm.go b/internal/checks/local/helm.go
@@ -0,0 +1,101 @@
+package local
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/Masterminds/semver/v3"
+
+	"cdr.dev/slog"
+	"github.com/cdr/coder-doctor/internal/api"
+)
+
+const LocalHelmVersionCheck = "local-helm-version"
+
+type VersionRequirement struct {
+	Coder          *semver.Version
+	HelmConstraint *semver.Constraints
+}
+
+var versionRequirements = []VersionRequirement{
+	{
+		Coder:          semver.MustParse("1.21.0"),
+		HelmConstraint: api.MustConstraint(">= 3.6.0"),
+	},
+	{
+		Coder:          semver.MustParse("1.20.0"),
+		HelmConstraint: api.MustConstraint(">= 3.6.0"),
+	},
+}
+
+func (l *Checker) CheckLocalHelmVersion(ctx context.Context) *api.CheckResult {
+	if l.target != api.CheckTargetKubernetes {
+		return api.SkippedResult(LocalHelmVersionCheck, "not applicable for target "+string(l.target))
+	}
+
+	helmBin, err := l.lookPathF("helm")
+	if err != nil {
+		return api.ErrorResult(LocalHelmVersionCheck, "could not find helm binary in $PATH", err)
+	}
+
+	helmVersionRaw, err := l.execF(ctx, helmBin, "version", "--short")
+	if err != nil {
+		return api.ErrorResult(LocalHelmVersionCheck, "failed to determine helm version", err)
+	}
+
+	helmVersion, err := semver.NewVersion(string(bytes.TrimSpace(helmVersionRaw)))
+	if err != nil {
+		return api.ErrorResult(LocalHelmVersionCheck, "failed to parse helm version", err)
+	}
+
+	selectedVersion := findNearestHelmVersion(l.coderVersion)
+	if selectedVersion == nil {
+		return api.ErrorResult(LocalHelmVersionCheck, fmt.Sprintf("checking coder version %s not supported", l.coderVersion.String()), nil)
+	}
+	l.log.Debug(ctx, "selected coder version", slog.F("requested", l.coderVersion), slog.F("selected", selectedVersion.Coder))
+
+	result := &api.CheckResult{
+		Name: LocalHelmVersionCheck,
+		Details: map[string]interface{}{
+			"helm-bin":                 helmBin,
+			"helm-version":             helmVersion.String(),
+			"helm-version-constraints": selectedVersion.HelmConstraint.String(),
+		},
+	}
+
+	if ok, cerrs := selectedVersion.HelmConstraint.Validate(helmVersion); !ok {
+		result.State = api.StateFailed
+		var b strings.Builder
+		_, err := fmt.Fprintf(&b, "Coder %s requires Helm version %s (installed: %s)\n", selectedVersion.Coder, selectedVersion.HelmConstraint, helmVersion)
+		if err != nil {
+			return api.ErrorResult(LocalHelmVersionCheck, "failed to write error result", err)
+		}
+		for _, cerr := range cerrs {
+			if _, err := fmt.Fprintf(&b, "constraint failed: %s\n", cerr); err != nil {
+				return api.ErrorResult(LocalHelmVersionCheck, "failed to write constraint error", err)
+			}
+		}
+		result.Summary = b.String()
+	} else {
+		result.State = api.StatePassed
+		result.Summary = fmt.Sprintf("Coder %s supports Helm %s", selectedVersion.Coder, selectedVersion.HelmConstraint)
+	}
+
+	return result
+}
+
+func findNearestHelmVersion(target *semver.Version) *VersionRequirement {
+	var selected *VersionRequirement
+
+	for _, v := range versionRequirements {
+		v := v
+		if !v.Coder.GreaterThan(target) {
+			selected = &v
+			break
+		}
+	}
+
+	return selected
+}
diff --git a/internal/checks/local/helm_test.go b/internal/checks/local/helm_test.go
@@ -0,0 +1,144 @@
+package local
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/Masterminds/semver/v3"
+
+	"cdr.dev/slog/sloggers/slogtest/assert"
+	"github.com/cdr/coder-doctor/internal/api"
+)
+
+func Test_CheckLocalHelmVersion(t *testing.T) {
+	t.Parallel()
+
+	type params struct {
+		W    *api.CaptureWriter
+		EX   *fakeExecer
+		LP   *fakeLookPather
+		Opts []Option
+		Ctx  context.Context
+	}
+
+	run := func(t *testing.T, name string, fn func(t *testing.T, p *params)) {
+		t.Run(name, func(t *testing.T) {
+			ctx := context.Background()
+			cw := &api.CaptureWriter{}
+			ex := newFakeExecer(t)
+			lp := newFakeLookPather(t)
+			opts := []Option{
+				WithWriter(cw),
+				WithExecF(ex.ExecContext),
+				WithLookPathF(lp.LookPath),
+				WithTarget(api.CheckTargetKubernetes), // default
+			}
+			p := &params{
+				W:    cw,
+				EX:   ex,
+				LP:   lp,
+				Opts: opts,
+				Ctx:  ctx,
+			}
+			fn(t, p)
+		})
+	}
+
+	run(t, "helm: when not running against kubernetes", func(t *testing.T, p *params) {
+		p.Opts = append(p.Opts, WithTarget(api.CheckTargetUndefined))
+		lc := NewChecker(p.Opts...)
+		err := lc.Run(p.Ctx)
+		assert.Success(t, "run local checker", err)
+		assert.False(t, "results should not be empty", p.W.Empty())
+		for _, res := range p.W.Get() {
+			if res.Name == LocalHelmVersionCheck {
+				assert.Equal(t, "should skip helm check if not running against kubernetes", api.StateSkipped, res.State)
+			}
+		}
+	})
+
+	run(t, "helm: with version 3.6", func(t *testing.T, p *params) {
+		p.LP.Handle("helm", "/usr/local/bin/helm", nil)
+		p.EX.Handle("/usr/local/bin/helm version --short", []byte("v3.6.0+g7f2df64"), nil)
+		lc := NewChecker(p.Opts...)
+		err := lc.Run(p.Ctx)
+		assert.Success(t, "run local checker", err)
+		assert.False(t, "results should not be empty", p.W.Empty())
+		for _, res := range p.W.Get() {
+			if res.Name == LocalHelmVersionCheck {
+				assert.Equal(t, "should pass", api.StatePassed, res.State)
+			}
+		}
+	})
+
+	run(t, "helm: with version 2", func(t *testing.T, p *params) {
+		p.LP.Handle("helm", "/usr/local/bin/helm", nil)
+		p.EX.Handle("/usr/local/bin/helm version --short", []byte("v2.0.0"), nil)
+		lc := NewChecker(p.Opts...)
+		err := lc.Run(p.Ctx)
+		assert.Success(t, "run local checker", err)
+		assert.False(t, "results should not be empty", p.W.Empty())
+		for _, res := range p.W.Get() {
+			if res.Name == LocalHelmVersionCheck {
+				assert.Equal(t, "should fail", api.StateFailed, res.State)
+			}
+		}
+	})
+
+	run(t, "helm: not in path", func(t *testing.T, p *params) {
+		p.LP.Handle("helm", "", os.ErrNotExist)
+		lc := NewChecker(p.Opts...)
+		err := lc.Run(p.Ctx)
+		assert.Success(t, "run local checker", err)
+		assert.False(t, "results should not be empty", p.W.Empty())
+		for _, res := range p.W.Get() {
+			if res.Name == LocalHelmVersionCheck {
+				assert.Equal(t, "should fail", api.StateFailed, res.State)
+			}
+		}
+	})
+
+	run(t, "helm: cannot be executed", func(t *testing.T, p *params) {
+		p.LP.Handle("helm", "/usr/local/bin/helm", nil)
+		p.EX.Handle("/usr/local/bin/helm version --short", []byte(""), os.ErrPermission)
+		lc := NewChecker(p.Opts...)
+		err := lc.Run(p.Ctx)
+		assert.Success(t, "run local checker", err)
+		assert.False(t, "results should not be empty", p.W.Empty())
+		for _, res := range p.W.Get() {
+			if res.Name == LocalHelmVersionCheck {
+				assert.Equal(t, "should fail", api.StateFailed, res.State)
+			}
+		}
+	})
+
+	run(t, "helm: returns garbage version", func(t *testing.T, p *params) {
+		p.LP.Handle("helm", "/usr/local/bin/helm", nil)
+		p.EX.Handle("/usr/local/bin/helm version --short", []byte(""), nil)
+		lc := NewChecker(p.Opts...)
+		err := lc.Run(p.Ctx)
+		assert.Success(t, "run local checker", err)
+		assert.False(t, "results should not be empty", p.W.Empty())
+		for _, res := range p.W.Get() {
+			if res.Name == LocalHelmVersionCheck {
+				assert.Equal(t, "should fail", api.StateFailed, res.State)
+			}
+		}
+	})
+
+	run(t, "helm: coder version is unsupported", func(t *testing.T, p *params) {
+		p.Opts = append(p.Opts, WithCoderVersion(semver.MustParse("v1.19")))
+		p.LP.Handle("helm", "/usr/local/bin/helm", nil)
+		p.EX.Handle("/usr/local/bin/helm version --short", []byte("v3.6.0+g7f2df64"), nil)
+		lc := NewChecker(p.Opts...)
+		err := lc.Run(p.Ctx)
+		assert.Success(t, "run local checker", err)
+		assert.False(t, "results should not be empty", p.W.Empty())
+		for _, res := range p.W.Get() {
+			if res.Name == LocalHelmVersionCheck {
+				assert.Equal(t, "should fail", api.StateFailed, res.State)
+			}
+		}
+	})
+}