Merge pull request #213 from acekingke/fix_with_gofumpt

andyli029 · web-flow · commit 0c498e532915 · 2021-09-09T11:51:10.000+08:00
*: format the code with gofumpt #212
diff --git a/api/v1alpha1/cluster_types.go b/api/v1alpha1/cluster_types.go
@@ -236,7 +236,7 @@ type Persistence struct {
 	// +optional
 	StorageClass *string `json:"storageClass,omitempty"`
 
-	//Size of persistent volume claim.
+	// Size of persistent volume claim.
 	// +optional
 	// +kubebuilder:default:="10Gi"
 	Size string `json:"size,omitempty"`
diff --git a/cluster/cluster_test.go b/cluster/cluster_test.go
@@ -61,7 +61,7 @@ func TestUnwrap(t *testing.T) {
 }
 
 func TestGetLabel(t *testing.T) {
-	//when the instance label exist
+	// when the instance label exist.
 	{
 		testMysqlCluster := mysqlCluster
 		testMysqlCluster.Annotations = map[string]string{
@@ -80,7 +80,7 @@ func TestGetLabel(t *testing.T) {
 		}
 		assert.Equal(t, want, testCase.GetLabels())
 	}
-	//when the component label exist
+	// when the component label exist.
 	{
 		testMysqlCluster := mysqlCluster
 		testMysqlCluster.Annotations = map[string]string{
@@ -99,7 +99,7 @@ func TestGetLabel(t *testing.T) {
 		}
 		assert.Equal(t, want, testCase.GetLabels())
 	}
-	//when the part-of label exist
+	// when the part-of label exist.
 	{
 		testMysqlCluster := mysqlCluster
 		testMysqlCluster.Annotations = map[string]string{
@@ -131,7 +131,7 @@ func TestGetSelectorLabels(t *testing.T) {
 }
 
 func TestGetMySQLVersion(t *testing.T) {
-	//other 8.0 ->  5.7.33
+	// other 8.0 ->  5.7.33
 	{
 		testMysqlCluster := mysqlCluster
 		testMysqlCluster.Spec.MysqlVersion = "8.0"
@@ -141,7 +141,7 @@ func TestGetMySQLVersion(t *testing.T) {
 		want := "5.7.33"
 		assert.Equal(t, want, testCase.GetMySQLVersion())
 	}
-	//MySQLTagsToSemVer 5.7 -> 5.7.33
+	// MySQLTagsToSemVer 5.7 -> 5.7.33
 	{
 		testMysqlCluster := mysqlCluster
 		testMysqlCluster.Spec.MysqlVersion = "5.7"
@@ -151,7 +151,7 @@ func TestGetMySQLVersion(t *testing.T) {
 		want := "5.7.33"
 		assert.Equal(t, want, testCase.GetMySQLVersion())
 	}
-	//MysqlImageVersions 5.7.33 -> 5.7.33
+	// MysqlImageVersions 5.7.33 -> 5.7.33
 	{
 		testMysqlCluster := mysqlCluster
 		testMysqlCluster.Spec.MysqlVersion = "5.7.33"
@@ -284,7 +284,7 @@ func TestEnsureVolumes(t *testing.T) {
 			},
 		},
 	}
-	//when disable Persistence
+	// when disable Persistence
 	{
 		testMysql := mysqlCluster
 		testMysql.Spec.Persistence.Enabled = false
@@ -302,7 +302,7 @@ func TestEnsureVolumes(t *testing.T) {
 		want = append(want, volume...)
 		assert.Equal(t, want, testCase.EnsureVolumes())
 	}
-	//when enable tokudb
+	// when enable tokudb
 	{
 		testMysql := mysqlCluster
 		testMysql.Spec.Persistence.Enabled = true
@@ -323,7 +323,7 @@ func TestEnsureVolumes(t *testing.T) {
 		want = append(want, volume...)
 		assert.Equal(t, want, testCase.EnsureVolumes())
 	}
-	//default(Persistence is turned on by default)
+	// default(Persistence is turned on by default)
 	{
 		testMysql := mysqlCluster
 		testMysql.Spec.Persistence.Enabled = true
@@ -336,14 +336,14 @@ func TestEnsureVolumes(t *testing.T) {
 
 func TestEnsureVolumeClaimTemplates(t *testing.T) {
 	var scheme runtime.Scheme
-	//when disable persistence
+	// when disable persistence
 	{
 		result, err := testCluster.EnsureVolumeClaimTemplates(&scheme)
 		assert.Nil(t, result)
 		assert.Nil(t, err)
 	}
 
-	//when enable persistence
+	// when enable persistence
 	{
 		var cluster *Cluster
 		storageClass := "ssd"
@@ -400,7 +400,7 @@ func TestEnsureVolumeClaimTemplates(t *testing.T) {
 		assert.Nil(t, err)
 	}
 
-	//when the StorageClass is "-"
+	// when the StorageClass is "-"
 	{
 		storageClass := "-"
 		testMysql := mysqlCluster
@@ -420,7 +420,7 @@ func TestEnsureVolumeClaimTemplates(t *testing.T) {
 		assert.Nil(t, err)
 	}
 
-	//when SetControllerReference error
+	// when SetControllerReference error
 	{
 		testMysql := mysqlCluster
 		testMysql.Spec.Persistence.Enabled = true
@@ -440,29 +440,29 @@ func TestEnsureVolumeClaimTemplates(t *testing.T) {
 }
 
 func TestGetNameForResource(t *testing.T) {
-	//statefulset configMap headlessSvc
+	// statefulset configMap headlessSvc
 	{
 		want := "sample-mysql"
 		assert.Equal(t, want, testCluster.GetNameForResource(utils.StatefulSet))
 		assert.Equal(t, want, testCluster.GetNameForResource(utils.ConfigMap))
 		assert.Equal(t, want, testCluster.GetNameForResource(utils.HeadlessSVC))
 	}
-	//leaderSvc
+	// leaderSvc
 	{
 		want := "sample-leader"
 		assert.Equal(t, want, testCluster.GetNameForResource(utils.LeaderService))
 	}
-	//folloerSvc
+	// folloerSvc
 	{
 		want := "sample-follower"
 		assert.Equal(t, want, testCluster.GetNameForResource(utils.FollowerService))
 	}
-	//secret
+	// secret
 	{
 		want := "sample-secret"
 		assert.Equal(t, want, testCluster.GetNameForResource(utils.Secret))
 	}
-	//others
+	// others
 	{
 		want := "sample"
 		assert.Equal(t, want, testCluster.GetNameForResource("others"))
@@ -496,7 +496,7 @@ func TestEnsureMysqlConf(t *testing.T) {
 			},
 		},
 	}
-	//cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size not set
+	// cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size not set
 	{
 		testMysqlCase := testMysql
 		testCase := Cluster{
@@ -508,7 +508,7 @@ func TestEnsureMysqlConf(t *testing.T) {
 		assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])
 		assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])
 	}
-	//cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size 600 mb
+	// cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size 600 mb
 	{
 		guard := Patch(sizeToBytes, func(s string) (uint64, error) {
 			return uint64(600 * mb), nil
@@ -526,7 +526,7 @@ func TestEnsureMysqlConf(t *testing.T) {
 		assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])
 		assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])
 	}
-	//cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb
+	// cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb
 	{
 		guard := Patch(sizeToBytes, func(s string) (uint64, error) {
 			return uint64(1700 * mb), nil
@@ -546,7 +546,7 @@ func TestEnsureMysqlConf(t *testing.T) {
 		assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])
 		assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])
 	}
-	//cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb, sizeToBytes error
+	// cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb, sizeToBytes error
 	{
 		guard := Patch(sizeToBytes, func(s string) (uint64, error) {
 			return uint64(1700 * mb), fmt.Errorf("error")
@@ -565,7 +565,7 @@ func TestEnsureMysqlConf(t *testing.T) {
 		assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])
 		assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])
 	}
-	//cpu 8 corev1s,memory 16 gb,innodb_buffer_pool_size 2 gb
+	// cpu 8 corev1s,memory 16 gb,innodb_buffer_pool_size 2 gb
 	{
 		guard := Patch(sizeToBytes, func(s string) (uint64, error) {
 			return uint64(2 * gb), nil
@@ -594,31 +594,31 @@ func TestSizeToBytes(t *testing.T) {
 		mb int64 = 1 << 20
 		kb int64 = 1 << 10
 	)
-	//kb
+	// kb
 	{
 		testCase := "1000k"
 		want := uint64(1000 * kb)
 		result, err := sizeToBytes(testCase)
 		assert.Equal(t, want, result)
 		assert.Nil(t, err)
 	}
-	//mb
+	// mb
 	{
 		testCase := "1000m"
 		want := uint64(1000 * mb)
 		result, err := sizeToBytes(testCase)
 		assert.Equal(t, want, result)
 		assert.Nil(t, err)
 	}
-	//gb
+	// gb
 	{
 		testCase := "1000g"
 		want := uint64(1000 * gb)
 		result, err := sizeToBytes(testCase)
 		assert.Equal(t, want, result)
 		assert.Nil(t, err)
 	}
-	//others
+	// others
 	{
 		testCase := "1000a"
 		want := uint64(0)
@@ -627,7 +627,7 @@ func TestSizeToBytes(t *testing.T) {
 		assert.Equal(t, want, result)
 		assert.Equal(t, wantError, err)
 	}
-	//it will return the result of ParseUint() when the parameter without unit
+	// it will return the result of ParseUint() when the parameter without unit
 	{
 		guard := Patch(strconv.ParseUint, func(s string, base int, bitSize int) (uint64, error) {
 			return uint64(666), nil
@@ -640,7 +640,7 @@ func TestSizeToBytes(t *testing.T) {
 		assert.Equal(t, want, result)
 		assert.Nil(t, err)
 	}
-	//ParseUint error
+	// ParseUint error
 	{
 		guard := Patch(strconv.ParseUint, func(s string, base int, bitSize int) (uint64, error) {
 			return uint64(777), fmt.Errorf("error")
diff --git a/cluster/container/backup.go b/cluster/container/backup.go
@@ -63,7 +63,7 @@ func (c *backupSidecar) getEnvVars() []corev1.EnvVar {
 			Name:  "REPLICAS",
 			Value: fmt.Sprintf("%d", *c.Spec.Replicas),
 		},
-		//backup user password for sidecar http server
+		// backup user password for sidecar http server
 		getEnvVarFromSecret(sctName, "BACKUP_USER", "backup-user", true),
 		getEnvVarFromSecret(sctName, "BACKUP_PASSWORD", "backup-password", true),
 	}
@@ -142,5 +142,4 @@ func (c *backupSidecar) getVolumeMounts() []corev1.VolumeMount {
 			MountPath: utils.LogsVolumeMountPath,
 		},
 	}
-
 }
diff --git a/cluster/container/init_mysql_test.go b/cluster/container/init_mysql_test.go
@@ -113,11 +113,11 @@ func TestGetInitMysqlCommand(t *testing.T) {
 }
 
 func TestGetInitMysqlEnvVar(t *testing.T) {
-	//base env
+	// base env
 	{
 		assert.Equal(t, initMysqlEnvs, initMysqlCase.Env)
 	}
-	//initTokuDB
+	// initTokuDB
 	{
 		testToKuDBMysqlCluster := initMysqlMysqlCluster
 		testToKuDBMysqlCluster.Spec.MysqlOpts.InitTokuDB = true
diff --git a/cluster/container/init_sidecar.go b/cluster/container/init_sidecar.go
@@ -111,7 +111,7 @@ func (c *initSidecar) getEnvVars() []corev1.EnvVar {
 		getEnvVarFromSecret(sctName, "OPERATOR_USER", "operator-user", true),
 		getEnvVarFromSecret(sctName, "OPERATOR_PASSWORD", "operator-password", true),
 
-		//backup user password for sidecar http server
+		// backup user password for sidecar http server
 		getEnvVarFromSecret(sctName, "BACKUP_USER", "backup-user", true),
 		getEnvVarFromSecret(sctName, "BACKUP_PASSWORD", "backup-password", true),
 	}
diff --git a/cluster/container/init_sidecar_test.go b/cluster/container/init_sidecar_test.go
@@ -292,11 +292,11 @@ func TestGetInitSidecarCommand(t *testing.T) {
 }
 
 func TestGetInitSidecarEnvVar(t *testing.T) {
-	//default
+	// default
 	{
 		assert.Equal(t, defaultInitSidecarEnvs, initSidecarCase.Env)
 	}
-	//initTokuDB
+	// initTokuDB
 	{
 		testToKuDBMysqlCluster := initSidecarMysqlCluster
 		testToKuDBMysqlCluster.Spec.MysqlOpts.InitTokuDB = true
@@ -338,11 +338,11 @@ func TestGetInitSidecarReadinessProbe(t *testing.T) {
 }
 
 func TestGetInitSidecarVolumeMounts(t *testing.T) {
-	//default
+	// default
 	{
 		assert.Equal(t, defaultInitsidecarVolumeMounts, initSidecarCase.VolumeMounts)
 	}
-	//init tokudb
+	// init tokudb
 	{
 		testToKuDBMysqlCluster := initSidecarMysqlCluster
 		testToKuDBMysqlCluster.Spec.MysqlOpts.InitTokuDB = true
@@ -358,7 +358,7 @@ func TestGetInitSidecarVolumeMounts(t *testing.T) {
 		})
 		assert.Equal(t, tokuDBVolumeMounts, tokudbCase.VolumeMounts)
 	}
-	//enable persistence
+	// enable persistence
 	{
 		testPersistenceMysqlCluster := initSidecarMysqlCluster
 		testPersistenceMysqlCluster.Spec.Persistence.Enabled = true
diff --git a/cluster/container/mysql_test.go b/cluster/container/mysql_test.go
@@ -60,11 +60,11 @@ func TestGetMysqlCommand(t *testing.T) {
 }
 
 func TestGetMysqlEnvVar(t *testing.T) {
-	//base env
+	// base env
 	{
 		assert.Nil(t, mysqlCase.Env)
 	}
-	//initTokuDB
+	// initTokuDB
 	{
 		volumeMounts := []corev1.EnvVar{
 			{
diff --git a/cluster/syncer/metrics_service.go b/cluster/syncer/metrics_service.go
@@ -51,7 +51,6 @@ func NewMetricsSVCSyncer(cli client.Client, c *cluster.Cluster) syncer.Interface
 		service.Spec.Ports[0].Name = utils.MetricsPortName
 		service.Spec.Ports[0].Port = utils.MetricsPort
 		service.Spec.Ports[0].TargetPort = intstr.FromInt(utils.MetricsPort)
-
 		return nil
 	})
 }
diff --git a/cluster/syncer/secret.go b/cluster/syncer/secret.go
@@ -57,7 +57,7 @@ func NewSecretSyncer(cli client.Client, c *cluster.Cluster) syncer.Interface {
 			return err
 		}
 
-		//xtrabackup http server user and password
+		// xtrabackup http server user and password
 		secret.Data["backup-user"] = []byte(utils.BackupUser)
 		if err := addRandomPassword(secret.Data, "backup-password"); err != nil {
 			return err
diff --git a/cluster/syncer/statefulset.go b/cluster/syncer/statefulset.go
@@ -576,7 +576,7 @@ func xenonHttpRequest(host, method, url string, rootPasswd []byte, body io.Reade
 	return resp.Body, nil
 }
 
-//check the backup is exist and running
+// check the backup is exist and running
 func (s *StatefulSetSyncer) backupIsRunning(ctx context.Context) (bool, error) {
 	backuplist := apiv1alpha1.BackupList{}
 	if err := s.cli.List(ctx,
diff --git a/internal/sql_runner.go b/internal/sql_runner.go
@@ -29,16 +29,14 @@ import (
 	"github.com/radondb/radondb-mysql-kubernetes/utils"
 )
 
-var (
-	// errorConnectionStates contains the list of the Slave_IO_State message.
-	errorConnectionStates = []string{
-		"connecting to master",
-		"reconnecting after a failed binlog dump request",
-		"reconnecting after a failed master event read",
-		"waiting to reconnect after a failed binlog dump request",
-		"waiting to reconnect after a failed master event read",
-	}
-)
+// errorConnectionStates contains the list of the Slave_IO_State message.
+var errorConnectionStates = []string{
+	"connecting to master",
+	"reconnecting after a failed binlog dump request",
+	"reconnecting after a failed master event read",
+	"waiting to reconnect after a failed binlog dump request",
+	"waiting to reconnect after a failed master event read",
+}
 
 // SQLRunner is a runner for run the sql.
 type SQLRunner struct {
diff --git a/sidecar/config.go b/sidecar/config.go
diff --git a/utils/common.go b/utils/common.go
diff --git a/utils/constants.go b/utils/constants.go

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ func TestUnwrap(t *testing.T) {`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`func TestGetLabel(t *testing.T) {`
`64`		`- //when the instance label exist`
	`64`	`+ // when the instance label exist.`
`65`	`65`	`{`
`66`	`66`	`testMysqlCluster := mysqlCluster`
`67`	`67`	`testMysqlCluster.Annotations = map[string]string{`
`@@ -80,7 +80,7 @@ func TestGetLabel(t *testing.T) {`
`80`	`80`	`}`
`81`	`81`	`assert.Equal(t, want, testCase.GetLabels())`
`82`	`82`	`}`
`83`		`- //when the component label exist`
	`83`	`+ // when the component label exist.`
`84`	`84`	`{`
`85`	`85`	`testMysqlCluster := mysqlCluster`
`86`	`86`	`testMysqlCluster.Annotations = map[string]string{`
`@@ -99,7 +99,7 @@ func TestGetLabel(t *testing.T) {`
`99`	`99`	`}`
`100`	`100`	`assert.Equal(t, want, testCase.GetLabels())`
`101`	`101`	`}`
`102`		`- //when the part-of label exist`
	`102`	`+ // when the part-of label exist.`
`103`	`103`	`{`
`104`	`104`	`testMysqlCluster := mysqlCluster`
`105`	`105`	`testMysqlCluster.Annotations = map[string]string{`
`@@ -131,7 +131,7 @@ func TestGetSelectorLabels(t *testing.T) {`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`func TestGetMySQLVersion(t *testing.T) {`
`134`		`- //other 8.0 -> 5.7.33`
	`134`	`+ // other 8.0 -> 5.7.33`
`135`	`135`	`{`
`136`	`136`	`testMysqlCluster := mysqlCluster`
`137`	`137`	`testMysqlCluster.Spec.MysqlVersion = "8.0"`
`@@ -141,7 +141,7 @@ func TestGetMySQLVersion(t *testing.T) {`
`141`	`141`	`want := "5.7.33"`
`142`	`142`	`assert.Equal(t, want, testCase.GetMySQLVersion())`
`143`	`143`	`}`
`144`		`- //MySQLTagsToSemVer 5.7 -> 5.7.33`
	`144`	`+ // MySQLTagsToSemVer 5.7 -> 5.7.33`
`145`	`145`	`{`
`146`	`146`	`testMysqlCluster := mysqlCluster`
`147`	`147`	`testMysqlCluster.Spec.MysqlVersion = "5.7"`
`@@ -151,7 +151,7 @@ func TestGetMySQLVersion(t *testing.T) {`
`151`	`151`	`want := "5.7.33"`
`152`	`152`	`assert.Equal(t, want, testCase.GetMySQLVersion())`
`153`	`153`	`}`
`154`		`- //MysqlImageVersions 5.7.33 -> 5.7.33`
	`154`	`+ // MysqlImageVersions 5.7.33 -> 5.7.33`
`155`	`155`	`{`
`156`	`156`	`testMysqlCluster := mysqlCluster`
`157`	`157`	`testMysqlCluster.Spec.MysqlVersion = "5.7.33"`
`@@ -284,7 +284,7 @@ func TestEnsureVolumes(t *testing.T) {`
`284`	`284`	`},`
`285`	`285`	`},`
`286`	`286`	`}`
`287`		`- //when disable Persistence`
	`287`	`+ // when disable Persistence`
`288`	`288`	`{`
`289`	`289`	`testMysql := mysqlCluster`
`290`	`290`	`testMysql.Spec.Persistence.Enabled = false`
`@@ -302,7 +302,7 @@ func TestEnsureVolumes(t *testing.T) {`
`302`	`302`	`want = append(want, volume...)`
`303`	`303`	`assert.Equal(t, want, testCase.EnsureVolumes())`
`304`	`304`	`}`
`305`		`- //when enable tokudb`
	`305`	`+ // when enable tokudb`
`306`	`306`	`{`
`307`	`307`	`testMysql := mysqlCluster`
`308`	`308`	`testMysql.Spec.Persistence.Enabled = true`
`@@ -323,7 +323,7 @@ func TestEnsureVolumes(t *testing.T) {`
`323`	`323`	`want = append(want, volume...)`
`324`	`324`	`assert.Equal(t, want, testCase.EnsureVolumes())`
`325`	`325`	`}`
`326`		`- //default(Persistence is turned on by default)`
	`326`	`+ // default(Persistence is turned on by default)`
`327`	`327`	`{`
`328`	`328`	`testMysql := mysqlCluster`
`329`	`329`	`testMysql.Spec.Persistence.Enabled = true`
`@@ -336,14 +336,14 @@ func TestEnsureVolumes(t *testing.T) {`
`336`	`336`
`337`	`337`	`func TestEnsureVolumeClaimTemplates(t *testing.T) {`
`338`	`338`	`var scheme runtime.Scheme`
`339`		`- //when disable persistence`
	`339`	`+ // when disable persistence`
`340`	`340`	`{`
`341`	`341`	`result, err := testCluster.EnsureVolumeClaimTemplates(&scheme)`
`342`	`342`	`assert.Nil(t, result)`
`343`	`343`	`assert.Nil(t, err)`
`344`	`344`	`}`
`345`	`345`
`346`		`- //when enable persistence`
	`346`	`+ // when enable persistence`
`347`	`347`	`{`
`348`	`348`	`var cluster *Cluster`
`349`	`349`	`storageClass := "ssd"`
`@@ -400,7 +400,7 @@ func TestEnsureVolumeClaimTemplates(t *testing.T) {`
`400`	`400`	`assert.Nil(t, err)`
`401`	`401`	`}`
`402`	`402`
`403`		`- //when the StorageClass is "-"`
	`403`	`+ // when the StorageClass is "-"`
`404`	`404`	`{`
`405`	`405`	`storageClass := "-"`
`406`	`406`	`testMysql := mysqlCluster`
`@@ -420,7 +420,7 @@ func TestEnsureVolumeClaimTemplates(t *testing.T) {`
`420`	`420`	`assert.Nil(t, err)`
`421`	`421`	`}`
`422`	`422`
`423`		`- //when SetControllerReference error`
	`423`	`+ // when SetControllerReference error`
`424`	`424`	`{`
`425`	`425`	`testMysql := mysqlCluster`
`426`	`426`	`testMysql.Spec.Persistence.Enabled = true`
`@@ -440,29 +440,29 @@ func TestEnsureVolumeClaimTemplates(t *testing.T) {`
`440`	`440`	`}`
`441`	`441`
`442`	`442`	`func TestGetNameForResource(t *testing.T) {`
`443`		`- //statefulset configMap headlessSvc`
	`443`	`+ // statefulset configMap headlessSvc`
`444`	`444`	`{`
`445`	`445`	`want := "sample-mysql"`
`446`	`446`	`assert.Equal(t, want, testCluster.GetNameForResource(utils.StatefulSet))`
`447`	`447`	`assert.Equal(t, want, testCluster.GetNameForResource(utils.ConfigMap))`
`448`	`448`	`assert.Equal(t, want, testCluster.GetNameForResource(utils.HeadlessSVC))`
`449`	`449`	`}`
`450`		`- //leaderSvc`
	`450`	`+ // leaderSvc`
`451`	`451`	`{`
`452`	`452`	`want := "sample-leader"`
`453`	`453`	`assert.Equal(t, want, testCluster.GetNameForResource(utils.LeaderService))`
`454`	`454`	`}`
`455`		`- //folloerSvc`
	`455`	`+ // folloerSvc`
`456`	`456`	`{`
`457`	`457`	`want := "sample-follower"`
`458`	`458`	`assert.Equal(t, want, testCluster.GetNameForResource(utils.FollowerService))`
`459`	`459`	`}`
`460`		`- //secret`
	`460`	`+ // secret`
`461`	`461`	`{`
`462`	`462`	`want := "sample-secret"`
`463`	`463`	`assert.Equal(t, want, testCluster.GetNameForResource(utils.Secret))`
`464`	`464`	`}`
`465`		`- //others`
	`465`	`+ // others`
`466`	`466`	`{`
`467`	`467`	`want := "sample"`
`468`	`468`	`assert.Equal(t, want, testCluster.GetNameForResource("others"))`
`@@ -496,7 +496,7 @@ func TestEnsureMysqlConf(t *testing.T) {`
`496`	`496`	`},`
`497`	`497`	`},`
`498`	`498`	`}`
`499`		`- //cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size not set`
	`499`	`+ // cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size not set`
`500`	`500`	`{`
`501`	`501`	`testMysqlCase := testMysql`
`502`	`502`	`testCase := Cluster{`
`@@ -508,7 +508,7 @@ func TestEnsureMysqlConf(t *testing.T) {`
`508`	`508`	`assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])`
`509`	`509`	`assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])`
`510`	`510`	`}`
`511`		`- //cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size 600 mb`
	`511`	`+ // cpu 1 corev1s,memory 1 gb,innodb_buffer_pool_size 600 mb`
`512`	`512`	`{`
`513`	`513`	`guard := Patch(sizeToBytes, func(s string) (uint64, error) {`
`514`	`514`	`return uint64(600 * mb), nil`
`@@ -526,7 +526,7 @@ func TestEnsureMysqlConf(t *testing.T) {`
`526`	`526`	`assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])`
`527`	`527`	`assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])`
`528`	`528`	`}`
`529`		`- //cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb`
	`529`	`+ // cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb`
`530`	`530`	`{`
`531`	`531`	`guard := Patch(sizeToBytes, func(s string) (uint64, error) {`
`532`	`532`	`return uint64(1700 * mb), nil`
`@@ -546,7 +546,7 @@ func TestEnsureMysqlConf(t *testing.T) {`
`546`	`546`	`assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])`
`547`	`547`	`assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])`
`548`	`548`	`}`
`549`		`- //cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb, sizeToBytes error`
	`549`	`+ // cpu 1 corev1s,memory 2 gb,innodb_buffer_pool_size 1.7 gb, sizeToBytes error`
`550`	`550`	`{`
`551`	`551`	`guard := Patch(sizeToBytes, func(s string) (uint64, error) {`
`552`	`552`	`return uint64(1700 * mb), fmt.Errorf("error")`
`@@ -565,7 +565,7 @@ func TestEnsureMysqlConf(t *testing.T) {`
`565`	`565`	`assert.Equal(t, wantSize, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_size"])`
`566`	`566`	`assert.Equal(t, wantInstance, testCase.Spec.MysqlOpts.MysqlConf["innodb_buffer_pool_instances"])`
`567`	`567`	`}`
`568`		`- //cpu 8 corev1s,memory 16 gb,innodb_buffer_pool_size 2 gb`
	`568`	`+ // cpu 8 corev1s,memory 16 gb,innodb_buffer_pool_size 2 gb`
`569`	`569`	`{`
`570`	`570`	`guard := Patch(sizeToBytes, func(s string) (uint64, error) {`
`571`	`571`	`return uint64(2 * gb), nil`
`@@ -594,31 +594,31 @@ func TestSizeToBytes(t *testing.T) {`
`594`	`594`	`mb int64 = 1 << 20`
`595`	`595`	`kb int64 = 1 << 10`
`596`	`596`	`)`
`597`		`- //kb`
	`597`	`+ // kb`
`598`	`598`	`{`
`599`	`599`	`testCase := "1000k"`
`600`	`600`	`want := uint64(1000 * kb)`
`601`	`601`	`result, err := sizeToBytes(testCase)`
`602`	`602`	`assert.Equal(t, want, result)`
`603`	`603`	`assert.Nil(t, err)`
`604`	`604`	`}`
`605`		`- //mb`
	`605`	`+ // mb`
`606`	`606`	`{`
`607`	`607`	`testCase := "1000m"`
`608`	`608`	`want := uint64(1000 * mb)`
`609`	`609`	`result, err := sizeToBytes(testCase)`
`610`	`610`	`assert.Equal(t, want, result)`
`611`	`611`	`assert.Nil(t, err)`
`612`	`612`	`}`
`613`		`- //gb`
	`613`	`+ // gb`
`614`	`614`	`{`
`615`	`615`	`testCase := "1000g"`
`616`	`616`	`want := uint64(1000 * gb)`
`617`	`617`	`result, err := sizeToBytes(testCase)`
`618`	`618`	`assert.Equal(t, want, result)`
`619`	`619`	`assert.Nil(t, err)`
`620`	`620`	`}`
`621`		`- //others`
	`621`	`+ // others`
`622`	`622`	`{`
`623`	`623`	`testCase := "1000a"`
`624`	`624`	`want := uint64(0)`
`@@ -627,7 +627,7 @@ func TestSizeToBytes(t *testing.T) {`
`627`	`627`	`assert.Equal(t, want, result)`
`628`	`628`	`assert.Equal(t, wantError, err)`
`629`	`629`	`}`
`630`		`- //it will return the result of ParseUint() when the parameter without unit`
	`630`	`+ // it will return the result of ParseUint() when the parameter without unit`
`631`	`631`	`{`
`632`	`632`	`guard := Patch(strconv.ParseUint, func(s string, base int, bitSize int) (uint64, error) {`
`633`	`633`	`return uint64(666), nil`
`@@ -640,7 +640,7 @@ func TestSizeToBytes(t *testing.T) {`
`640`	`640`	`assert.Equal(t, want, result)`
`641`	`641`	`assert.Nil(t, err)`
`642`	`642`	`}`
`643`		`- //ParseUint error`
	`643`	`+ // ParseUint error`
`644`	`644`	`{`
`645`	`645`	`guard := Patch(strconv.ParseUint, func(s string, base int, bitSize int) (uint64, error) {`
`646`	`646`	`return uint64(777), fmt.Errorf("error")`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ func (c *backupSidecar) getEnvVars() []corev1.EnvVar {`
`63`	`63`	`Name: "REPLICAS",`
`64`	`64`	`Value: fmt.Sprintf("%d", *c.Spec.Replicas),`
`65`	`65`	`},`
`66`		`- //backup user password for sidecar http server`
	`66`	`+ // backup user password for sidecar http server`
`67`	`67`	`getEnvVarFromSecret(sctName, "BACKUP_USER", "backup-user", true),`
`68`	`68`	`getEnvVarFromSecret(sctName, "BACKUP_PASSWORD", "backup-password", true),`
`69`	`69`	`}`
`@@ -142,5 +142,4 @@ func (c *backupSidecar) getVolumeMounts() []corev1.VolumeMount {`
`142`	`142`	`MountPath: utils.LogsVolumeMountPath,`
`143`	`143`	`},`
`144`	`144`	`}`
`145`		`-`
`146`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,11 +113,11 @@ func TestGetInitMysqlCommand(t *testing.T) {`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`func TestGetInitMysqlEnvVar(t *testing.T) {`
`116`		`- //base env`
	`116`	`+ // base env`
`117`	`117`	`{`
`118`	`118`	`assert.Equal(t, initMysqlEnvs, initMysqlCase.Env)`
`119`	`119`	`}`
`120`		`- //initTokuDB`
	`120`	`+ // initTokuDB`
`121`	`121`	`{`
`122`	`122`	`testToKuDBMysqlCluster := initMysqlMysqlCluster`
`123`	`123`	`testToKuDBMysqlCluster.Spec.MysqlOpts.InitTokuDB = true`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ func (c *initSidecar) getEnvVars() []corev1.EnvVar {`
`111`	`111`	`getEnvVarFromSecret(sctName, "OPERATOR_USER", "operator-user", true),`
`112`	`112`	`getEnvVarFromSecret(sctName, "OPERATOR_PASSWORD", "operator-password", true),`
`113`	`113`
`114`		`- //backup user password for sidecar http server`
	`114`	`+ // backup user password for sidecar http server`
`115`	`115`	`getEnvVarFromSecret(sctName, "BACKUP_USER", "backup-user", true),`
`116`	`116`	`getEnvVarFromSecret(sctName, "BACKUP_PASSWORD", "backup-password", true),`
`117`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -292,11 +292,11 @@ func TestGetInitSidecarCommand(t *testing.T) {`
`292`	`292`	`}`
`293`	`293`
`294`	`294`	`func TestGetInitSidecarEnvVar(t *testing.T) {`
`295`		`- //default`
	`295`	`+ // default`
`296`	`296`	`{`
`297`	`297`	`assert.Equal(t, defaultInitSidecarEnvs, initSidecarCase.Env)`
`298`	`298`	`}`
`299`		`- //initTokuDB`
	`299`	`+ // initTokuDB`
`300`	`300`	`{`
`301`	`301`	`testToKuDBMysqlCluster := initSidecarMysqlCluster`
`302`	`302`	`testToKuDBMysqlCluster.Spec.MysqlOpts.InitTokuDB = true`
`@@ -338,11 +338,11 @@ func TestGetInitSidecarReadinessProbe(t *testing.T) {`
`338`	`338`	`}`
`339`	`339`
`340`	`340`	`func TestGetInitSidecarVolumeMounts(t *testing.T) {`
`341`		`- //default`
	`341`	`+ // default`
`342`	`342`	`{`
`343`	`343`	`assert.Equal(t, defaultInitsidecarVolumeMounts, initSidecarCase.VolumeMounts)`
`344`	`344`	`}`
`345`		`- //init tokudb`
	`345`	`+ // init tokudb`
`346`	`346`	`{`
`347`	`347`	`testToKuDBMysqlCluster := initSidecarMysqlCluster`
`348`	`348`	`testToKuDBMysqlCluster.Spec.MysqlOpts.InitTokuDB = true`
`@@ -358,7 +358,7 @@ func TestGetInitSidecarVolumeMounts(t *testing.T) {`
`358`	`358`	`})`
`359`	`359`	`assert.Equal(t, tokuDBVolumeMounts, tokudbCase.VolumeMounts)`
`360`	`360`	`}`
`361`		`- //enable persistence`
	`361`	`+ // enable persistence`
`362`	`362`	`{`
`363`	`363`	`testPersistenceMysqlCluster := initSidecarMysqlCluster`
`364`	`364`	`testPersistenceMysqlCluster.Spec.Persistence.Enabled = true`
Original file line number	Diff line number	Diff line change
`@@ -60,11 +60,11 @@ func TestGetMysqlCommand(t *testing.T) {`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`func TestGetMysqlEnvVar(t *testing.T) {`
`63`		`- //base env`
	`63`	`+ // base env`
`64`	`64`	`{`
`65`	`65`	`assert.Nil(t, mysqlCase.Env)`
`66`	`66`	`}`
`67`		`- //initTokuDB`
	`67`	`+ // initTokuDB`
`68`	`68`	`{`
`69`	`69`	`volumeMounts := []corev1.EnvVar{`
`70`	`70`	`{`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,6 @@ func NewMetricsSVCSyncer(cli client.Client, c *cluster.Cluster) syncer.Interface`
`51`	`51`	`service.Spec.Ports[0].Name = utils.MetricsPortName`
`52`	`52`	`service.Spec.Ports[0].Port = utils.MetricsPort`
`53`	`53`	`service.Spec.Ports[0].TargetPort = intstr.FromInt(utils.MetricsPort)`
`54`		`-`
`55`	`54`	`return nil`
`56`	`55`	`})`
`57`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ func NewSecretSyncer(cli client.Client, c *cluster.Cluster) syncer.Interface {`
`57`	`57`	`return err`
`58`	`58`	`}`
`59`	`59`
`60`		`- //xtrabackup http server user and password`
	`60`	`+ // xtrabackup http server user and password`
`61`	`61`	`secret.Data["backup-user"] = []byte(utils.BackupUser)`
`62`	`62`	`if err := addRandomPassword(secret.Data, "backup-password"); err != nil {`
`63`	`63`	`return err`
Original file line number	Diff line number	Diff line change
`@@ -576,7 +576,7 @@ func xenonHttpRequest(host, method, url string, rootPasswd []byte, body io.Reade`
`576`	`576`	`return resp.Body, nil`
`577`	`577`	`}`
`578`	`578`
`579`		`-//check the backup is exist and running`
	`579`	`+// check the backup is exist and running`
`580`	`580`	`func (s *StatefulSetSyncer) backupIsRunning(ctx context.Context) (bool, error) {`
`581`	`581`	`backuplist := apiv1alpha1.BackupList{}`
`582`	`582`	`if err := s.cli.List(ctx,`