Fix silent test failure due to panic on missing kubeconfig in CI

chatwork · Nov 21, 2023 · 57a721c · 57a721c
1 parent c4b8c43
commit 57a721c
Show file tree

Hide file tree

Showing 8 changed files with 121 additions and 33 deletions.
diff --git a/cmd/cert-manager/cert-manager.go b/cmd/cert-manager/cert-manager.go
@@ -28,7 +28,7 @@ type CertManager struct {
 	Client   client.Client
 }
 
-func NewCertManager(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) *CertManager {
+func NewCertManager(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) (*CertManager, error) {
 	t := time.Now()
 
 	namespace := fmt.Sprintf("cert-manager-test-%d%02d%02d-%s", t.Year(), t.Month(), t.Day(), util.GenerateRandomString(5))
@@ -43,11 +43,17 @@ func NewCertManager(debug bool, logger func() *logrus.Entry, chatwork *notify.Ch
 	scheme := runtime.NewScheme()
 	_ = cmapiv1.AddToScheme(scheme)
 
+	k8sclient, err := config.NewK8sClientset()
+	if err != nil {
+		logger().Errorf("NewK8sClientset: %s", err)
+		return nil, err
+	}
+
 	return &CertManager{
-		Checker:  cmd.NewChecker(namespace, config.NewK8sClientset(), debug, logger, chatwork),
+		Checker:  cmd.NewChecker(namespace, k8sclient, debug, logger, chatwork),
 		CertName: certName,
 		Client:   config.NewK8sClient(client.Options{Scheme: scheme}),
-	}
+	}, nil
 }
 
 func (c *CertManager) Check() error {

diff --git a/cmd/cluster-autoscaler/clusterAutoscalerCheck.go b/cmd/cluster-autoscaler/clusterAutoscalerCheck.go
@@ -24,7 +24,7 @@ type ClusterAutoscaler struct {
 	ReplicaCount   int
 }
 
-func NewClusterAutoscaler(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) *ClusterAutoscaler {
+func NewClusterAutoscaler(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) (*ClusterAutoscaler, error) {
 	t := time.Now()
 
 	namespace := fmt.Sprintf("cluster-autoscaler-test-%d%02d%02d-%s", t.Year(), t.Month(), t.Day(), util.GenerateRandomString(5))
@@ -38,10 +38,16 @@ func NewClusterAutoscaler(debug bool, logger func() *logrus.Entry, chatwork *not
 		deploymentName = v
 	}
 
+	k8sclient, err := config.NewK8sClientset()
+	if err != nil {
+		logger().Errorf("NewK8sClientset: %s", err)
+		return nil, err
+	}
+
 	return &ClusterAutoscaler{
-		Checker:        cmd.NewChecker(namespace, config.NewK8sClientset(), debug, logger, chatwork),
+		Checker:        cmd.NewChecker(namespace, k8sclient, debug, logger, chatwork),
 		DeploymentName: deploymentName,
-	}
+	}, nil
 }
 
 // Check is check cluster-autoscaler

diff --git a/cmd/datadog-agent/datadog-agent.go b/cmd/datadog-agent/datadog-agent.go
@@ -27,7 +27,7 @@ type DatadogAgent struct {
 	ClusterName string
 }
 
-func NewDatadogAgent(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) *DatadogAgent {
+func NewDatadogAgent(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) (*DatadogAgent, error) {
 	t := time.Now()
 
 	namespace := fmt.Sprintf("datadog-agent-test-%d%02d%02d-%s", t.Year(), t.Month(), t.Day(), util.GenerateRandomString(5))
@@ -48,12 +48,19 @@ func NewDatadogAgent(debug bool, logger func() *logrus.Entry, chatwork *notify.C
 	if v := os.Getenv("CLUSTER_NAME"); v != "" {
 		clusterName = v
 	}
+
+	k8sclient, err := config.NewK8sClientset()
+	if err != nil {
+		logger().Errorf("NewK8sClientset: %s", err)
+		return nil, err
+	}
+
 	return &DatadogAgent{
-		Checker:     cmd.NewChecker(namespace, config.NewK8sClientset(), debug, logger, chatwork),
+		Checker:     cmd.NewChecker(namespace, k8sclient, debug, logger, chatwork),
 		ApiKey:      apiKey,
 		AppKey:      appKey,
 		ClusterName: clusterName,
-	}
+	}, nil
 }
 
 func (d *DatadogAgent) Check() error {

diff --git a/cmd/datadog-agent/datadog-agent_test.go b/cmd/datadog-agent/datadog-agent_test.go
@@ -16,7 +16,10 @@ func TestNewDatadogAgent(t *testing.T) {
 		return logrus.NewEntry(logrus.New())
 	}
 	chatwork := &notify.Chatwork{}
-	datadogAgent := NewDatadogAgent(true, logger, chatwork)
+	datadogAgent, err := NewDatadogAgent(true, logger, chatwork)
+	if err != nil {
+		t.Fatalf("NewDatadogAgent: %s", err)
+	}
 
 	if datadogAgent == nil {
 		t.Error("Expected datadogAgent instance, got nil")
@@ -27,17 +30,23 @@ func TestCheck(t *testing.T) {
 	logger := func() *logrus.Entry {
 		return logrus.NewEntry(logrus.New())
 	}
+
+	k8sclient, err := config.NewK8sClientset()
+	if err != nil {
+		t.Fatalf("NewK8sClientset: %s", err)
+	}
+
 	chatwork := &notify.Chatwork{ApiToken: "token", RoomId: "test", Logger: logger}
 	datadogAgent := &DatadogAgent{
-		Checker:     cmd.NewChecker("test", config.NewK8sClientset(), true, logger, chatwork),
+		Checker:     cmd.NewChecker("test", k8sclient, true, logger, chatwork),
 		ApiKey:      "",
 		AppKey:      "",
 		ClusterName: "",
 	}
 
-	err := datadogAgent.Check()
+	err = datadogAgent.Check()
 	if err == nil {
-		t.Error("Expected error, got nil")
+		t.Fatal("Expected error, got nil")
 	}
 
 	expectedError := errors.New("DD_API_KEY or DD_APP_KEY is empty")
@@ -47,15 +56,22 @@ func TestCheck(t *testing.T) {
 
 	os.Setenv("DD_API_KEY", "test")
 	os.Setenv("DD_APP_KEY", "test")
-	datadogAgent = NewDatadogAgent(true, logger, chatwork)
+	datadogAgent, err = NewDatadogAgent(true, logger, chatwork)
+	if err != nil {
+		t.Fatalf("NewDatadogAgent: %s", err)
+	}
 	err = datadogAgent.Check()
 	expectedError = errors.New("CLUSTER_NAME is empty")
 	if err.Error() != expectedError.Error() {
 		t.Errorf("Expected '%s', got '%s'", expectedError.Error(), err.Error())
 	}
 
 	os.Setenv("CLUSTER_NAME", "test")
-	datadogAgent = NewDatadogAgent(true, logger, chatwork)
+	datadogAgent, err = NewDatadogAgent(true, logger, chatwork)
+	if err != nil {
+		t.Fatalf("NewDatadogAgent: %s", err)
+	}
+
 	err = datadogAgent.Check()
 	expectedError = errors.New("403 Forbidden")
 	if err.Error() != expectedError.Error() {

diff --git a/cmd/fluent/fluent.go b/cmd/fluent/fluent.go
@@ -30,7 +30,7 @@ type Fluent struct {
 	Awscfg         aws.Config
 }
 
-func NewFluent(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) *Fluent {
+func NewFluent(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) (*Fluent, error) {
 	t := time.Now()
 
 	namespace := fmt.Sprintf("fluent-test-%d%02d%02d-%s", t.Year(), t.Month(), t.Day(), util.GenerateRandomString(5))
@@ -53,13 +53,19 @@ func NewFluent(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwor
 		logBucketName = v
 	}
 
+	k8sclient, err := config.NewK8sClientset()
+	if err != nil {
+		logger().Errorf("NewK8sClientset: %s", err)
+		return nil, err
+	}
+
 	return &Fluent{
-		Checker:        cmd.NewChecker(namespace, config.NewK8sClientset(), debug, logger, chatwork),
+		Checker:        cmd.NewChecker(namespace, k8sclient, debug, logger, chatwork),
 		Env:            env,
 		DeploymentName: deploymentName,
 		LogBucketName:  logBucketName,
 		Awscfg:         config.NewAwsConfig(),
-	}
+	}, nil
 }
 
 func (f *Fluent) Check() error {

diff --git a/cmd/ingress/ingressCheck.go b/cmd/ingress/ingressCheck.go
@@ -28,7 +28,7 @@ type Ingress struct {
 	ExternalHostname string
 }
 
-func NewIngress(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) *Ingress {
+func NewIngress(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwork) (*Ingress, error) {
 	t := time.Now()
 
 	namespace := fmt.Sprintf("ingress-test-%d%02d%02d-%s", t.Year(), t.Month(), t.Day(), util.GenerateRandomString(5))
@@ -45,11 +45,17 @@ func NewIngress(debug bool, logger func() *logrus.Entry, chatwork *notify.Chatwo
 		externalHostName = v
 	}
 
+	k8sclient, err := config.NewK8sClientset()
+	if err != nil {
+		logger().Errorf("NewK8sClientset: %s", err)
+		return nil, err
+	}
+
 	return &Ingress{
-		Checker:          cmd.NewChecker(namespace, config.NewK8sClientset(), debug, logger, chatwork),
+		Checker:          cmd.NewChecker(namespace, k8sclient, debug, logger, chatwork),
 		ResourceName:     resourceName,
 		ExternalHostname: externalHostName,
-	}
+	}, nil
 }
 
 func (i *Ingress) Check() error {

diff --git a/config/config.go b/config/config.go
@@ -19,14 +19,14 @@ func NewAwsConfig() aws.Config {
 	return cfg
 }
 
-func NewK8sClientset() *kubernetes.Clientset {
+func NewK8sClientset() (*kubernetes.Clientset, error) {
 	config := ctrl.GetConfigOrDie()
 	clientset, err := kubernetes.NewForConfig(config)
 	if err != nil {
 		log.Fatal("error kubernetes NewForConfig: ", err)
-		panic(err)
+		return nil, err
 	}
-	return clientset
+	return clientset, nil
 }
 
 func NewK8sClient(options client.Options) client.Client {

diff --git a/main.go b/main.go
@@ -59,7 +59,11 @@ func main() {
 		Short: "test cluster-autoscaler",
 		Long:  "test cluster-autoscaler",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return clusterautoscaler.NewClusterAutoscaler(debug, logger, chatwork).Check()
+			ca, err := clusterautoscaler.NewClusterAutoscaler(debug, logger, chatwork)
+			if err != nil {
+				return err
+			}
+			return ca.Check()
 		},
 	}
 
@@ -68,7 +72,11 @@ func main() {
 		Short: "test ingress(aws-load-balancer-controller, external-dns)",
 		Long:  "test ingress(aws-load-balancer-controller, external-dns))",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return ingress.NewIngress(debug, logger, chatwork).Check()
+			i, err := ingress.NewIngress(debug, logger, chatwork)
+			if err != nil {
+				return err
+			}
+			return i.Check()
 		},
 	}
 
@@ -77,7 +85,11 @@ func main() {
 		Short: "test fluent(fluent-bit, fluentd)",
 		Long:  "test fluent(fluent-bit, fluentd)",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return fluent.NewFluent(debug, logger, chatwork).Check()
+			f, err := fluent.NewFluent(debug, logger, chatwork)
+			if err != nil {
+				return err
+			}
+			return f.Check()
 		},
 	}
 
@@ -86,7 +98,11 @@ func main() {
 		Short: "test datadog-agent",
 		Long:  "test datadog-agent",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return datadogagent.NewDatadogAgent(debug, logger, chatwork).Check()
+			da, err := datadogagent.NewDatadogAgent(debug, logger, chatwork)
+			if err != nil {
+				return err
+			}
+			return da.Check()
 		},
 	}
 
@@ -95,7 +111,11 @@ func main() {
 		Short: "test cert-manager",
 		Long:  "test cert-manager",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return certmanager.NewCertManager(debug, logger, chatwork).Check()
+			cm, err := certmanager.NewCertManager(debug, logger, chatwork)
+			if err != nil {
+				return err
+			}
+			return cm.Check()
 		},
 	}
 
@@ -105,21 +125,42 @@ func main() {
 		Long:  "test all application",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			logger().Info("test all application")
-			err := ingress.NewIngress(debug, logger, chatwork).Check()
+			i, err := ingress.NewIngress(debug, logger, chatwork)
+			if err != nil {
+				return err
+			}
+
+			err = i.Check()
+			if err != nil {
+				return err
+			}
+
+			ca, err := clusterautoscaler.NewClusterAutoscaler(debug, logger, chatwork)
+			if err != nil {
+				return err
+			}
+
+			err = ca.Check()
+			if err != nil {
+				return err
+			}
+
+			cm, err := certmanager.NewCertManager(debug, logger, chatwork)
 			if err != nil {
 				return err
 			}
-			err = clusterautoscaler.NewClusterAutoscaler(debug, logger, chatwork).Check()
+
+			err = cm.Check()
 			if err != nil {
 				return err
 			}
 
-			err = certmanager.NewCertManager(debug, logger, chatwork).Check()
+			f, err := fluent.NewFluent(debug, logger, chatwork)
 			if err != nil {
 				return err
 			}
 
-			err = fluent.NewFluent(debug, logger, chatwork).Check()
+			err = f.Check()
 			if err != nil {
 				return err
 			}