String content and var style updates

internal/cmd/kafka/command_acl_create.go

@@ -107,7 +107,7 @@ func (c *aclCommand) create(cmd *cobra.Command, _ []string) error {
 					_ = aclutil.PrintACLsWithResourceIdMap(cmd, bindings[:i], os.Stdout, resourceIdMap)
 				}
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 		}

internal/cmd/kafka/command_acl_delete.go

@@ -90,7 +90,7 @@ func (c *aclCommand) delete(cmd *cobra.Command, _ []string) error {
 			} else {
 				printAclsDeleted(cmd, matchingBindingCount)
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 		}

internal/cmd/kafka/command_acl_list.go

@@ -72,7 +72,7 @@ func (c *aclCommand) list(cmd *cobra.Command, _ []string) error {
 		if err == nil && httpResp != nil {
 			if httpResp.StatusCode != http.StatusOK {
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 			// Kafka REST is available and there was no error

internal/cmd/kafka/command_cluster_test.go

@@ -217,7 +217,7 @@ func (suite *KafkaClusterTestSuite) TestClusterShrinkShouldPrompt() {
 	cmd := suite.newCmd(v1.AuthenticatedCloudConfigMock())
 	cmd.SetArgs([]string{"update", clusterName, "--cku", "2"})
 	err := cmd.Execute()
-	req.Contains(err.Error(), "Cluster resize error: failed to read your confirmation")
+	req.Contains(err.Error(), "cluster resize error: failed to read your confirmation")
 	req.True(suite.metricsApi.V2MetricsDatasetQueryPostCalled())
 	req.True(suite.metricsApi.V2MetricsDatasetQueryPostExecuteCalled())
 }

internal/cmd/kafka/command_cluster_update.go

@@ -104,7 +104,7 @@ func (c *clusterCommand) validateResize(cmd *cobra.Command, currentCluster *cmkv
 		}
 		// Ensure the cluster is a Dedicated Cluster
 		if currentCluster.GetSpec().Config.CmkV2Dedicated == nil {
-			return -1, errors.Errorf("failed to update kafka cluster: %v", errors.ClusterResizeNotSupported)
+			return -1, errors.New(errors.ClusterResizeNotSupportedErrorMsg)
 		}
 		// Durability Checks
 		if *currentCluster.GetSpec().Availability == highAvailability && cku <= 1 {

internal/cmd/kafka/command_topic.go

@@ -159,7 +159,7 @@ func (c *authenticatedTopicCommand) getNumPartitions(topicName string) (int, err
 		if err == nil && httpResp != nil {
 			if httpResp.StatusCode != http.StatusOK {
 				return 0, errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 

internal/cmd/kafka/command_topic_consume.go

@@ -111,13 +111,13 @@ func (c *hasAPIKeyTopicCommand) consume(cmd *cobra.Command, args []string) error
 
 	consumer, err := newConsumer(group, cluster, c.clientID, configFile, config)
 	if err != nil {
-		return fmt.Errorf(errors.FailedToCreateConsumerMsg, err)
+		return fmt.Errorf(errors.FailedToCreateConsumerErrorMsg, err)
 	}
 	log.CliLogger.Trace("Create consumer succeeded")
 
 	adminClient, err := ckafka.NewAdminClientFromConsumer(consumer)
 	if err != nil {
-		return fmt.Errorf(errors.FailedToCreateAdminClientMsg, err)
+		return fmt.Errorf(errors.FailedToCreateAdminClientErrorMsg, err)
 	}
 	defer adminClient.Close()
 

internal/cmd/kafka/command_topic_consume_onprem.go

@@ -92,7 +92,7 @@ func (c *authenticatedTopicCommand) onPremConsume(cmd *cobra.Command, args []str
 
 	consumer, err := newOnPremConsumer(cmd, c.clientID, configFile, config)
 	if err != nil {
-		return errors.NewErrorWithSuggestions(fmt.Errorf(errors.FailedToCreateConsumerMsg, err).Error(), errors.OnPremConfigGuideSuggestion)
+		return errors.NewErrorWithSuggestions(fmt.Errorf(errors.FailedToCreateConsumerErrorMsg, err).Error(), errors.OnPremConfigGuideSuggestions)
 	}
 	log.CliLogger.Tracef("Create consumer succeeded")
 
@@ -103,7 +103,7 @@ func (c *authenticatedTopicCommand) onPremConsume(cmd *cobra.Command, args []str
 
 	adminClient, err := ckafka.NewAdminClientFromConsumer(consumer)
 	if err != nil {
-		return fmt.Errorf(errors.FailedToCreateAdminClientMsg, err)
+		return fmt.Errorf(errors.FailedToCreateAdminClientErrorMsg, err)
 	}
 	defer adminClient.Close()
 
@@ -144,7 +144,7 @@ func (c *authenticatedTopicCommand) onPremConsume(cmd *cobra.Command, args []str
 	if valueFormat != "string" {
 		// Only initialize client and context when schema is specified.
 		if c.State == nil { // require log-in to use oauthbearer token
-			return errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestion)
+			return errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestions)
 		}
 		srClient, ctx, err = sr.GetSrApiClientWithToken(cmd, c.Version, c.AuthToken())
 		if err != nil {

internal/cmd/kafka/command_topic_create.go

@@ -118,7 +118,7 @@ func (c *authenticatedTopicCommand) create(cmd *cobra.Command, args []string) er
 		if err == nil && httpResp != nil {
 			if httpResp.StatusCode != http.StatusCreated {
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 			// Kafka REST is available and there was no error

internal/cmd/kafka/command_topic_delete.go

@@ -64,7 +64,7 @@ func (c *authenticatedTopicCommand) delete(cmd *cobra.Command, args []string) er
 		if err == nil && httpResp != nil {
 			if httpResp.StatusCode != http.StatusNoContent {
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 			// Topic successfully deleted

internal/cmd/kafka/command_topic_describe.go

@@ -78,7 +78,7 @@ func (c *authenticatedTopicCommand) describe(cmd *cobra.Command, args []string)
 		if err == nil && httpResp != nil {
 			if httpResp.StatusCode != http.StatusOK {
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 

internal/cmd/kafka/command_topic_list.go

@@ -57,7 +57,7 @@ func (c *authenticatedTopicCommand) list(cmd *cobra.Command, _ []string) error {
 		if err == nil && httpResp != nil {
 			if httpResp.StatusCode != http.StatusOK {
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 			// Kafka REST is available and there was no error

internal/cmd/kafka/command_topic_produce.go

@@ -114,14 +114,14 @@ func (c *hasAPIKeyTopicCommand) produce(cmd *cobra.Command, args []string) error
 
 	producer, err := newProducer(cluster, c.clientID, configFile, config)
 	if err != nil {
-		return fmt.Errorf(errors.FailedToCreateProducerMsg, err)
+		return fmt.Errorf(errors.FailedToCreateProducerErrorMsg, err)
 	}
 	defer producer.Close()
 	log.CliLogger.Tracef("Create producer succeeded")
 
 	adminClient, err := ckafka.NewAdminClientFromProducer(producer)
 	if err != nil {
-		return fmt.Errorf(errors.FailedToCreateAdminClientMsg, err)
+		return fmt.Errorf(errors.FailedToCreateAdminClientErrorMsg, err)
 	}
 	defer adminClient.Close()
 

internal/cmd/kafka/command_topic_produce_onprem.go

@@ -71,7 +71,7 @@ func (c *authenticatedTopicCommand) onPremProduce(cmd *cobra.Command, args []str
 
 	producer, err := newOnPremProducer(cmd, c.clientID, configFile, config)
 	if err != nil {
-		return errors.NewErrorWithSuggestions(fmt.Errorf(errors.FailedToCreateProducerMsg, err).Error(), errors.OnPremConfigGuideSuggestion)
+		return errors.NewErrorWithSuggestions(fmt.Errorf(errors.FailedToCreateProducerErrorMsg, err).Error(), errors.OnPremConfigGuideSuggestions)
 	}
 	defer producer.Close()
 	log.CliLogger.Tracef("Create producer succeeded")
@@ -83,7 +83,7 @@ func (c *authenticatedTopicCommand) onPremProduce(cmd *cobra.Command, args []str
 
 	adminClient, err := ckafka.NewAdminClientFromProducer(producer)
 	if err != nil {
-		return fmt.Errorf(errors.FailedToCreateAdminClientMsg, err)
+		return fmt.Errorf(errors.FailedToCreateAdminClientErrorMsg, err)
 	}
 	defer adminClient.Close()
 
@@ -205,7 +205,7 @@ func (c *authenticatedTopicCommand) registerSchema(cmd *cobra.Command, schemaCfg
 	referencePathMap := map[string]string{}
 	if schemaCfg.ValueFormat != "string" && len(*schemaCfg.SchemaPath) > 0 {
 		if c.State == nil { // require log-in to use oauthbearer token
-			return nil, nil, errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestion)
+			return nil, nil, errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestions)
 		}
 		srClient, ctx, err := sr.GetSrApiClientWithToken(cmd, c.Version, c.AuthToken())
 		if err != nil {

internal/cmd/kafka/command_topic_update.go

@@ -112,7 +112,7 @@ func (c *authenticatedTopicCommand) update(cmd *cobra.Command, args []string) er
 		if err == nil && httpResp != nil {
 			if httpResp.StatusCode != http.StatusNoContent {
 				return errors.NewErrorWithSuggestions(
-					fmt.Sprintf(errors.KafkaRestUnexpectedStatusMsg, httpResp.Request.URL, httpResp.StatusCode),
+					fmt.Sprintf(errors.KafkaRestUnexpectedStatusErrorMsg, httpResp.Request.URL, httpResp.StatusCode),
 					errors.InternalServerErrorSuggestions)
 			}
 
@@ -121,7 +121,7 @@ func (c *authenticatedTopicCommand) update(cmd *cobra.Command, args []string) er
 			if err != nil {
 				return kafkaRestError(kafkaREST.Client.GetConfig().BasePath, err, httpResp)
 			} else if configsResp.Data == nil {
-				return errors.NewErrorWithSuggestions(errors.EmptyResponseMsg, errors.InternalServerErrorSuggestions)
+				return errors.NewErrorWithSuggestions(errors.EmptyResponseErrorMsg, errors.InternalServerErrorSuggestions)
 			}
 			readOnlyConfigs := set.New()
 			configsValues := make(map[string]string)

internal/cmd/kafka/confluent_kafka.go

@@ -72,7 +72,7 @@ func (c *authenticatedTopicCommand) refreshOAuthBearerToken(cmd *cobra.Command,
 	if protocol == "SASL_SSL" && mechanism == "OAUTHBEARER" {
 		oart := ckafka.OAuthBearerTokenRefresh{Config: oauthConfig}
 		if c.State == nil { // require log-in to use oauthbearer token
-			return errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestion)
+			return errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestions)
 		}
 		oauthBearerToken, retrieveErr := retrieveUnsecuredToken(oart, c.AuthToken())
 		if retrieveErr != nil {
@@ -249,7 +249,7 @@ func runConsumer(cmd *cobra.Command, consumer *ckafka.Consumer, groupHandler *Gr
 	for run {
 		select {
 		case <-signals: // Trap SIGINT to trigger a shutdown.
-			utils.ErrPrintln(cmd, errors.StoppingConsumer)
+			utils.ErrPrintln(cmd, errors.StoppingConsumerMsg)
 			consumer.Close()
 			run = false
 		default:

internal/cmd/kafka/confluent_kafka_configs.go

@@ -156,7 +156,7 @@ func setProtocolConfig(cmd *cobra.Command, configMap *ckafka.ConfigMap) (*ckafka
 			return nil, err
 		}
 	default:
-		return nil, errors.NewErrorWithSuggestions(fmt.Errorf(errors.InvalidSecurityProtocolErrorMsg, protocol).Error(), errors.OnPremConfigGuideSuggestion)
+		return nil, errors.NewErrorWithSuggestions(fmt.Errorf(errors.InvalidSecurityProtocolErrorMsg, protocol).Error(), errors.OnPremConfigGuideSuggestions)
 	}
 	return configMap, nil
 }

internal/cmd/kafka/kafka_rest.go

@@ -46,14 +46,14 @@ func kafkaRestError(url string, err error, httpResp *http.Response) error {
 	switch e := err.(type) {
 	case *neturl.Error:
 		if strings.Contains(e.Error(), SelfSignedCertError) || strings.Contains(e.Error(), UnauthorizedCertError) {
-			return errors.NewErrorWithSuggestions(fmt.Sprintf(errors.KafkaRestConnectionMsg, url, e.Err), errors.KafkaRestCertErrorSuggestions)
+			return errors.NewErrorWithSuggestions(fmt.Sprintf(errors.KafkaRestConnectionErrorMsg, url, e.Err), errors.KafkaRestCertErrorSuggestions)
 		}
-		return errors.Errorf(errors.KafkaRestConnectionMsg, url, e.Err)
+		return errors.Errorf(errors.KafkaRestConnectionErrorMsg, url, e.Err)
 	case kafkarestv3.GenericOpenAPIError:
 		openAPIError, parseErr := parseOpenAPIError(err)
 		if parseErr == nil {
 			if strings.Contains(openAPIError.Message, "invalid_token") {
-				return errors.NewErrorWithSuggestions(errors.InvalidMDSToken, errors.InvalidMDSTokenSuggestions)
+				return errors.NewErrorWithSuggestions(errors.InvalidMDSTokenErrorMsg, errors.InvalidMDSTokenSuggestions)
 			}
 			return fmt.Errorf("REST request failed: %v (%v)", openAPIError.Message, openAPIError.Code)
 		}

internal/cmd/kafka/kafka_rest_test.go

@@ -121,7 +121,7 @@ func (suite *KafkaRestTestSuite) TestKafkaRestError() {
 
 	r = kafkaRestError(url, openAPIError, nil)
 	req.NotNil(r)
-	req.Contains(r.Error(), "Unknown")
+	req.Contains(r.Error(), "unknown")
 
 	httpResp := http.Response{
 		Status:     "Code: 400",

internal/cmd/ksql/command_delete.go

@@ -94,7 +94,7 @@ func (c *ksqlCommand) delete(cmd *cobra.Command, args []string, isApp bool) erro
 			if err != nil {
 				return err
 			}
-			return errors.Errorf(errors.KsqlDBTerminateClusterMsg, args[0], string(body))
+			return errors.Errorf(errors.KsqlDBTerminateClusterErrorMsg, args[0], string(body))
 		}
 	}
 

internal/cmd/login/command.go

@@ -372,7 +372,7 @@ func validateURL(url string, isCCloud bool) (string, string, error) {
 	}
 	matched, _ := regexp.MatchString(pattern, url)
 	if !matched {
-		return url, "", errors.New(errors.InvalidLoginURLMsg)
+		return url, "", errors.New(errors.InvalidLoginURLErrorMsg)
 	}
 
 	return url, strings.Join(msg, " and "), nil

internal/cmd/login/command_test.go

@@ -842,7 +842,7 @@ func TestValidateUrl(t *testing.T) {
 			urlIn:      "https:///test.com",
 			urlOut:     "",
 			warningMsg: "default MDS port 8090",
-			errMsg:     errors.InvalidLoginURLMsg,
+			errMsg:     errors.InvalidLoginURLErrorMsg,
 		},
 		{
 			urlIn:      "test.com",

internal/cmd/schema-registry/command_schema_create_onprem.go

@@ -85,7 +85,7 @@ func (c *schemaCommand) onPremCreate(cmd *cobra.Command, _ []string) error {
 
 func (c *schemaCommand) registerSchemaOnPrem(cmd *cobra.Command, schemaCfg *RegisterSchemaConfigs) ([]byte, map[string]string, error) {
 	if c.State == nil { // require log-in to use oauthbearer token
-		return nil, nil, errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestion)
+		return nil, nil, errors.NewErrorWithSuggestions(errors.NotLoggedInErrorMsg, errors.AuthTokenSuggestions)
 	}
 	srClient, ctx, err := GetSrApiClientWithToken(cmd, c.Version, c.AuthToken())
 	if err != nil {

internal/cmd/schema-registry/utils.go

@@ -59,7 +59,7 @@ func getPackageInternalName(inputPackageDisplayName string) (string, error) {
 		}
 	}
 
-	return "", errors.NewErrorWithSuggestions(fmt.Sprintf(errors.SRInvalidPackageType, inputPackageDisplayName),
+	return "", errors.NewErrorWithSuggestions(fmt.Sprintf(errors.SRInvalidPackageTypeErrorMsg, inputPackageDisplayName),
 		fmt.Sprintf(errors.SRInvalidPackageSuggestions, getCommaDelimitedPackagesString()))
 }
 

internal/pkg/auth/auth_token_handler.go

@@ -161,7 +161,7 @@ func (a *AuthTokenHandlerImpl) checkSSOEmailMatchesLogin(client *ccloud.Client,
 		return err
 	}
 	if getMeReply.User.Email != loginEmail {
-		return errors.NewErrorWithSuggestions(fmt.Sprintf(errors.SSOCredentialsDoNotMatchLoginCredentials, loginEmail, getMeReply.User.Email), errors.SSOCredentialsDoNotMatchSuggestions)
+		return errors.NewErrorWithSuggestions(fmt.Sprintf(errors.SSOCredentialsDoNotMatchLoginCredentialsErrorMsg, loginEmail, getMeReply.User.Email), errors.SSOCredentialsDoNotMatchSuggestions)
 	}
 	return nil
 }

internal/pkg/cmd/prerunner.go

@@ -813,7 +813,7 @@ func (r *PreRun) HasAPIKey(command *HasAPIKeyCLICommand) func(*cobra.Command, []
 					cluster.APIKeys[key] = &v1.APIKeyPair{Key: key, Secret: secret}
 				} else if cluster.APIKeys[key] == nil {
 					return errors.NewErrorWithSuggestions(
-						fmt.Sprintf(errors.NoAPISecretStoredOrPassedMsg, key, clusterId),
+						fmt.Sprintf(errors.NoAPISecretStoredOrPassedErrorMsg, key, clusterId),
 						fmt.Sprintf(errors.NoAPISecretStoredOrPassedSuggestions, key, clusterId))
 				}
 			}

internal/pkg/cmd/prerunner_test.go

@@ -652,7 +652,7 @@ func TestPreRun_HasAPIKeyCommand(t *testing.T) {
 		{
 			name:           "api key passed via flag without stored secret",
 			key:            "miles",
-			errMsg:         fmt.Sprintf(errors.NoAPISecretStoredOrPassedMsg, "miles", v1.MockKafkaClusterId()),
+			errMsg:         fmt.Sprintf(errors.NoAPISecretStoredOrPassedErrorMsg, "miles", v1.MockKafkaClusterId()),
 			suggestionsMsg: fmt.Sprintf(errors.NoAPISecretStoredOrPassedSuggestions, "miles", v1.MockKafkaClusterId()),
 			config:         usernameClusterWithoutSecret,
 		},

internal/pkg/errors/README.md

@@ -22,6 +22,8 @@ Suggestions format
 - full sentence
 - capitalize first letter
 - end with a full stop 
+- separate suggestions using a newline; do not add a newline at the end of the last sentence
+- for sentences ending in a url, put a space between the url and the fullstop
 - the variable name must end with *Suggestions*
 
 examples:
@@ -71,7 +73,7 @@ LookUpRoleSuggestions           = "To check for valid roles, use `confluent iam
 return errors.NewWrapErrorWithSuggestions(err, fmt.Sprintf(errors.LookUpRoleErrorMsg, roleName), errors.LookUpRoleSuggestions)
 ```
 
-3. If you know that your error will be used in many places, or need to be caught donwstream and process later, you can define typed error by implenting the `CLITypedError` interface
+3. If you know that your error will be used in many places, or needs to be caught downstream and processed later, you can define a typed error by implenting the `CLITypedError` interface
 ```
 type CLITypedError interface {
 	error

internal/pkg/errors/catcher.go

@@ -106,7 +106,7 @@ func catchCoreV1Errors(err error) error {
 func catchCCloudTokenErrors(err error) error {
 	switch err.(type) {
 	case *ccloud.InvalidLoginError:
-		return NewErrorWithSuggestions(InvalidLoginErrorMsg, AvoidTimeoutSuggestion)
+		return NewErrorWithSuggestions(InvalidLoginErrorMsg, AvoidTimeoutSuggestions)
 	case *ccloud.InvalidTokenError:
 		return NewErrorWithSuggestions(CorruptedTokenErrorMsg, CorruptedTokenSuggestions)
 	case *ccloud.ExpiredTokenError: