Fix gitops check

cmd/gitops/check/cmd.go

@@ -4,35 +4,51 @@ import (
 	"fmt"
 
 	"github.com/weaveworks/weave-gitops/cmd/gitops/check/oidcconfig"
+	"github.com/weaveworks/weave-gitops/cmd/gitops/cmderrors"
 	"github.com/weaveworks/weave-gitops/cmd/gitops/config"
+	"github.com/weaveworks/weave-gitops/pkg/run"
 	"github.com/weaveworks/weave-gitops/pkg/services/check"
+	"k8s.io/cli-runtime/pkg/genericclioptions"
+	"k8s.io/client-go/discovery"
 
 	"github.com/spf13/cobra"
 )
 
 func GetCommand(opts *config.Options) *cobra.Command {
+	var kubeConfigArgs *genericclioptions.ConfigFlags
+
 	cmd := &cobra.Command{
 		Use:   "check",
 		Short: "Validates flux compatibility",
 		Example: `
 # Validate flux and kubernetes compatibility
 gitops check
 `,
-		RunE: runCmd,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			kubeConfigArgs = run.GetKubeConfigArgs()
+			kubeConfigArgs.AddFlags(cmd.Flags())
+
+			cfg, err := kubeConfigArgs.ToRESTConfig()
+			if err != nil {
+				return err
+			}
+
+			c, err := discovery.NewDiscoveryClientForConfig(cfg)
+			if err != nil {
+				return cmderrors.ErrGetKubeClient
+			}
+			output, err := check.KubernetesVersion(c)
+			if err != nil {
+				return err
+			}
+
+			fmt.Println(output)
+
+			return nil
+		},
 	}
 
 	cmd.AddCommand(oidcconfig.OIDCConfigCommand(opts))
 
 	return cmd
 }
-
-func runCmd(_ *cobra.Command, _ []string) error {
-	output, err := check.Pre()
-	if err != nil {
-		return err
-	}
-
-	fmt.Println(output)
-
-	return nil
-}

pkg/services/check/check.go

@@ -2,71 +2,33 @@ package check
 
 import (
 	"fmt"
-	"os/exec"
-	"strings"
 
 	"github.com/Masterminds/semver/v3"
+	"k8s.io/client-go/discovery"
 )
 
 const (
-	kubernetesConstraints = ">=1.20.6-0"
+	kubernetesConstraints = ">=1.26"
 )
 
-// Pre runs pre-install checks
-func Pre() (string, error) {
-	k8sOutput, err := runKubernetesCheck()
+// KubernetesVersion checks if the Kubernetes version of the client is recent enough and
+// returns a proper string explaining the result of the check. An error is returned
+// if the check could not be performed (e.g. the cluster is not reachable).
+func KubernetesVersion(c discovery.DiscoveryInterface) (string, error) {
+	v, err := c.ServerVersion()
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed getting server version: %w", err)
 	}
 
-	return k8sOutput, nil
-}
-
-func runKubernetesCheck() (string, error) {
-	versionOutput, err := exec.Command("kubectl", "version", "--short").CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("unable to get kubernetes version: %w", err)
-	}
-
-	v, err := parseVersion(string(versionOutput))
+	sv, err := semver.NewVersion(v.GitVersion)
 	if err != nil {
-		return "", fmt.Errorf("kubernetes version can't be determined: %w", err)
-	}
-
-	return checkKubernetesVersion(v)
-}
-
-func checkKubernetesVersion(version *semver.Version) (string, error) {
-	var valid bool
-
-	var vrange string
-
-	c, _ := semver.NewConstraint(kubernetesConstraints)
-	if c.Check(version) {
-		valid = true
-		vrange = kubernetesConstraints
-	}
-
-	if !valid {
-		return "", fmt.Errorf("✗ kubernetes version %s does not match %s", version.Original(), kubernetesConstraints)
-	}
-
-	return fmt.Sprintf("✔ Kubernetes %s %s", version.String(), vrange), nil
-}
-
-func parseVersion(text string) (*semver.Version, error) {
-	version := ""
-	lines := strings.Split(text, "\n")
-
-	for _, line := range lines {
-		if strings.Contains(line, "Server") {
-			version = strings.Replace(line, "Server Version: v", "", 1)
-		}
+		return "", fmt.Errorf("failed parsing server version %q: %w", v.GitVersion, err)
 	}
 
-	if _, err := semver.StrictNewVersion(version); err != nil {
-		return nil, err
+	cons, _ := semver.NewConstraint(kubernetesConstraints)
+	if !cons.Check(sv) {
+		return "", fmt.Errorf("✗ kubernetes version %s does not match %s", sv.Original(), kubernetesConstraints)
 	}
 
-	return semver.NewVersion(version)
+	return fmt.Sprintf("✔ Kubernetes %s %s", sv, kubernetesConstraints), nil
 }

pkg/services/check/check_test.go

@@ -1,40 +1,78 @@
-package check
+package check_test
 
 import (
-	"github.com/Masterminds/semver/v3"
+	"errors"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/version"
+	fakediscovery "k8s.io/client-go/discovery/fake"
+	fakeclientset "k8s.io/client-go/kubernetes/fake"
+	kubetesting "k8s.io/client-go/testing"
 
-	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"github.com/weaveworks/weave-gitops/pkg/services/check"
 )
 
-var _ = Describe("Check kubernetes version", func() {
-	It("should show kuberetes is a valid version", func() {
-		version, err := semver.NewVersion("1.21.1")
-		Expect(err).ShouldNot(HaveOccurred())
-
-		output, err := checkKubernetesVersion(version)
-		Expect(err).ShouldNot(HaveOccurred())
+func TestKubernetesVersionWithError(t *testing.T) {
+	g := NewWithT(t)
 
-		Expect(output).To(Equal("✔ Kubernetes 1.21.1 >=1.20.6-0"))
+	expectedError := errors.New("an error occurred")
+	fakeClient := fakeclientset.NewSimpleClientset()
+	fakeClient.Discovery().(*fakediscovery.FakeDiscovery).PrependReactor("*", "*", func(action kubetesting.Action) (handled bool, ret runtime.Object, err error) {
+		return true, nil, expectedError
 	})
 
-	It("should fail with version does not match", func() {
-		version, err := semver.NewVersion("1.19.1")
-		Expect(err).ShouldNot(HaveOccurred())
+	res, err := check.KubernetesVersion(fakeClient.Discovery())
 
-		_, err = checkKubernetesVersion(version)
-		Expect(err.Error()).Should(Equal("✗ kubernetes version 1.19.1 does not match >=1.20.6-0"))
-	})
-})
+	g.Expect(err).To(MatchError(ContainSubstring(expectedError.Error())))
+	g.Expect(res).To(BeEmpty())
+}
 
-var _ = Describe("parse version", func() {
-	It("should parse version", func() {
-		expectedVersion, err := semver.NewVersion("1.21.1")
-		Expect(err).ShouldNot(HaveOccurred())
+func TestKubernetesVersion(t *testing.T) {
+	tests := []struct {
+		name          string
+		serverVersion string
+		expectedErr   string
+		expectedRes   string
+	}{
+		{
+			name:          "server version satisfies constraint",
+			serverVersion: "v1.28.4",
+			expectedRes:   `^✔ Kubernetes 1.28.4 >=1.`,
+		},
+		{
+			name:          "server version too low",
+			serverVersion: "v1.20.5",
+			expectedErr:   `✗ kubernetes version v1\.20\.5 does not match >=1\.`,
+		},
+		{
+			name:          "server version not semver compliant",
+			serverVersion: "1.x",
+			expectedErr:   `"1.x".*Invalid Semantic Version`,
+		},
+	}
 
-		output, err := parseVersion("Server Version: v1.21.1")
-		Expect(err).ShouldNot(HaveOccurred())
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewWithT(t)
+			client := fakeclientset.NewSimpleClientset()
+			fakeDiscovery, ok := client.Discovery().(*fakediscovery.FakeDiscovery)
+			if !ok {
+				t.Fatalf("couldn't convert Discovery() to *FakeDiscovery")
+			}
 
-		Expect(output).To(Equal(expectedVersion))
-	})
-})
+			fakeDiscovery.FakedServerVersion = &version.Info{
+				GitVersion: tt.serverVersion,
+			}
+
+			res, err := check.KubernetesVersion(client.Discovery())
+
+			if tt.expectedErr != "" {
+				g.Expect(err).To(MatchError(MatchRegexp(tt.expectedErr)))
+			}
+
+			g.Expect(res).To(MatchRegexp(tt.expectedRes))
+		})
+	}
+}