wip

coder · jawnsy · Aug 16, 2021 · Aug 7, 2021 · Aug 7, 2021 · Aug 11, 2021
commit 84882af66d24f0caf2477fb9d85af0eefa33b78d
diff --git a/internal/api/error.go b/internal/api/error.go
@@ -0,0 +1,13 @@
+package api
+
+// ErrorResult returns a CheckResult when an error occurs.
+func ErrorResult(name string, summary string, err error) *CheckResult {
+	return &CheckResult{
+		Name:    name,
+		State:   StateFailed,
+		Summary: summary,
+		Details: map[string]interface{}{
+			"error": err,
+		},
+	}
+}
diff --git a/internal/api/error_test.go b/internal/api/error_test.go
@@ -0,0 +1,21 @@
+package api_test
+
+import (
+	"errors"
+	"testing"
+
+	"cdr.dev/slog/sloggers/slogtest/assert"
+	"github.com/cdr/coder-doctor/internal/api"
+)
+
+func TestErrorResult(t *testing.T) {
+	t.Parallel()
+
+	err := errors.New("failed to connect to database")
+	res := api.ErrorResult("check-name", "check failed", err)
+
+	assert.Equal(t, "name matches", "check-name", res.Name)
+	assert.Equal(t, "state matches", api.StateFailed, res.State)
+	assert.Equal(t, "summary matches", "check failed", res.Summary)
+	assert.Equal(t, "error matches", err, res.Details["error"])
+}
diff --git a/internal/api/types.go b/internal/api/types.go
@@ -2,6 +2,9 @@ package api
 
 import (
 	"context"
+	"fmt"
+
+	"golang.org/x/xerrors"
 )
 
 type Checker interface {
@@ -19,6 +22,8 @@ type Checker interface {
 	Run(context.Context) CheckResults
 }
 
+var _ = fmt.Stringer(StatePassed)
+
 type CheckState int
 
 const (
@@ -41,6 +46,73 @@ const (
 	StateSkipped
 )
 
+func (s CheckState) MustEmoji() string {
+	emoji, err := s.Emoji()
+	if err != nil {
+		panic(err.Error())
+	}
+	return emoji
+}
+
+func (s CheckState) Emoji() (string, error) {
+	switch s {
+	case StatePassed:
+		return "✅", nil
+	case StateWarning:
+		return "⚠️", nil
+	case StateFailed:
+		return "❌", nil
+	case StateInfo:
+		return "ℹ️", nil
+	case StateSkipped:
+		return "🤔", nil
+	}
+
+	return "", xerrors.Errorf("unknown state: %d", s)
+}
+
+func (s CheckState) MustText() string {
+	text, err := s.Text()
+	if err != nil {
+		panic(err.Error())
+	}
+	return text
+}
+
+func (s CheckState) Text() (string, error) {
+	switch s {
+	case StatePassed:
+		return "PASS", nil
+	case StateWarning:
+		return "WARN", nil
+	case StateFailed:
+		return "FAIL", nil
+	case StateInfo:
+		return "INFO", nil
+	case StateSkipped:
+		return "SKIP", nil
+	}
+
+	return "", xerrors.Errorf("unknown state: %d", s)
+}
+
+func (s CheckState) String() string {
+	switch s {
+	case StatePassed:
+		return "StatePassed"
+	case StateWarning:
+		return "StateWarning"
+	case StateFailed:
+		return "StateFailed"
+	case StateInfo:
+		return "StateInfo"
+	case StateSkipped:
+		return "StateSkipped"
+	}
+
+	panic(fmt.Sprintf("unknown state: %d", s))
+}
+
 type CheckResult struct {
 	Name    string
 	State   CheckState

diff --git a/internal/api/types_test.go b/internal/api/types_test.go
@@ -0,0 +1,35 @@
+package api_test
+
+import (
+	"testing"
+
+	"cdr.dev/slog/sloggers/slogtest/assert"
+	"github.com/cdr/coder-doctor/internal/api"
+)
+
+func TestKnownStates(t *testing.T) {
+	t.Parallel()
+
+	states := []api.CheckState{
+		api.StatePassed,
+		api.StateWarning,
+		api.StateFailed,
+		api.StateInfo,
+		api.StateSkipped,
+	}
+
+	for _, state := range states {
+		t.Run(state.String(), func(t *testing.T) {
+			emoji, err := state.Emoji()
+			assert.Success(t, "state.Emoji() error non-nil", err)
+			assert.True(t, "state.Emoji() is non-empty", len(emoji) > 0)
+
+			text, err := state.Text()
+			assert.Success(t, "state.Text() error non-nil", err)
+			assert.True(t, "state.Text() is non-empty", len(text) > 0)
+
+			str := state.String()
+			assert.True(t, "state.String() is non-empty", len(str) > 0)
+		})
+	}
+}
diff --git a/internal/api/util.go b/internal/api/util.go
diff --git a/internal/api/writer.go b/internal/api/writer.go
@@ -0,0 +1,14 @@
+package api
+
+// ResultWriter writes the given result to a configured output.
+type ResultWriter interface {
+	WriteResult(result *CheckResult) error
+}
+
+// DiscardWriter is a writer that discards all results.
+type DiscardWriter struct {
+}
+
+func (*DiscardWriter) WriteResult(result *CheckResult) error {
+	return nil
+}
diff --git a/internal/api/writer_test.go b/internal/api/writer_test.go
@@ -0,0 +1,26 @@
+package api_test
+
+import (
+	"testing"
+
+	"cdr.dev/slog/sloggers/slogtest/assert"
+	"github.com/cdr/coder-doctor/internal/api"
+)
+
+var _ = api.ResultWriter(&api.DiscardWriter{})
+
+func TestDiscardWriter(t *testing.T) {
+	t.Parallel()
+
+	w := &api.DiscardWriter{}
+	err := w.WriteResult(nil)
+
+	assert.Success(t, "discard with nil result", err)
+
+	err = w.WriteResult(&api.CheckResult{
+		Name:    "test-check",
+		State:   api.StatePassed,
+		Summary: "check successful",
+	})
+	assert.Success(t, "discard with success result", err)
+}
diff --git a/internal/cmd/check/kube/kubernetes.go b/internal/cmd/check/kube/kubernetes.go
diff --git a/internal/cmd/check/kubernetes/kubernetes.go b/internal/cmd/check/kubernetes/kubernetes.go
@@ -8,7 +8,7 @@ import (
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/sloghuman"
 
-	kclient "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/kubernetes"
 	// Kubernetes authentication plugins
 	_ "k8s.io/client-go/plugin/pkg/client/auth/azure"
 	_ "k8s.io/client-go/plugin/pkg/client/auth/exec"
@@ -17,8 +17,8 @@ import (
 	_ "k8s.io/client-go/plugin/pkg/client/auth/openstack"
 	"k8s.io/client-go/tools/clientcmd"
 
-	"github.com/cdr/coder-doctor/internal/api"
 	"github.com/cdr/coder-doctor/internal/checks/kube"
+	"github.com/cdr/coder-doctor/internal/humanwriter"
 )
 
 func NewCommand() *cobra.Command {
@@ -78,7 +78,7 @@ func run(cmd *cobra.Command, _ []string) error {
 		return err
 	}
 
-	clientset, err := kclient.NewForConfig(config)
+	clientset, err := kubernetes.NewForConfig(config)
 	if err != nil {
 		return err
 	}
@@ -99,6 +99,8 @@ func run(cmd *cobra.Command, _ []string) error {
 		return err
 	}
 
+	// TODO: this is pretty arbitrary, use a defined verbosity similar to
+	// kubectl
 	if verbosity > 5 {
 		log = log.Leveled(slog.LevelDebug)
 	}
@@ -109,10 +111,15 @@ func run(cmd *cobra.Command, _ []string) error {
 		kube.WithLogger(log),
 	)
 
+	writer := humanwriter.New()
+
 	results := checker.Run(cmd.Context())
-	err = api.WriteResults(cmd.OutOrStdout(), results)
-	if err != nil {
-		return xerrors.Errorf("failed to write results to stdout: %w", err)
+	for _, result := range results {
+		err = writer.WriteResult(result)
+		if err != nil {
+			return xerrors.Errorf("failed to write results to stdout: %w", err)
+		}
+
 	}
 
 	return nil