refactor: Remove unnecessary pointer

Laubi · Laubi · commit 0ea746f4f61f · 2023-08-23T13:42:06.000+02:00
diff --git a/pkg/deploy/automation.go b/pkg/deploy/automation.go
@@ -38,10 +38,10 @@ func (c *dummyAutomationClient) Upsert(_ context.Context, _ automation.ResourceT
 	return &automation.Response{ID: id}, nil
 }
 
-func deployAutomation(ctx context.Context, client automationClient, properties parameter.Properties, renderedConfig string, c *config.Config) (*parameter.ResolvedEntity, error) {
+func deployAutomation(ctx context.Context, client automationClient, properties parameter.Properties, renderedConfig string, c *config.Config) (parameter.ResolvedEntity, error) {
 	t, ok := c.Type.(config.AutomationType)
 	if !ok {
-		return &parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("config was not of expected type %q, but %q", config.AutomationType{}.ID(), c.Type.ID()))
+		return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("config was not of expected type %q, but %q", config.AutomationType{}.ID(), c.Type.ID()))
 	}
 
 	var id string
@@ -54,13 +54,13 @@ func deployAutomation(ctx context.Context, client automationClient, properties p
 
 	resourceType, err := automationutils.ClientResourceTypeFromConfigType(t.Resource)
 	if err != nil {
-		return nil, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)
+		return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)
 	}
 
 	var resp *automation.Response
 	resp, err = client.Upsert(ctx, resourceType, id, []byte(renderedConfig))
 	if resp == nil || err != nil {
-		return nil, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)
+		return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)
 	}
 
 	name := fmt.Sprintf("[UNKNOWN NAME]%s", resp.ID)
@@ -77,6 +77,6 @@ func deployAutomation(ctx context.Context, client automationClient, properties p
 		Properties: properties,
 		Skip:       false,
 	}
-	return &resolved, nil
+	return resolved, nil
 
 }
diff --git a/pkg/deploy/automation_test.go b/pkg/deploy/automation_test.go
@@ -69,7 +69,7 @@ func TestDeployAutomation_ClientUpsertFails(t *testing.T) {
 			Parameters: toParameterMap([]parameter.NamedParameter{}),
 		}
 		res, err := deployAutomation(context.TODO(), client, nil, "", conf)
-		assert.Nil(t, res)
+		assert.Equal(t, parameter.ResolvedEntity{}, res)
 		assert.Error(t, err)
 	})
 	t.Run("TestDeployAutomation - BusinessCalendar Upsert fails", func(t *testing.T) {
@@ -84,7 +84,7 @@ func TestDeployAutomation_ClientUpsertFails(t *testing.T) {
 			Parameters: toParameterMap([]parameter.NamedParameter{}),
 		}
 		res, err := deployAutomation(context.TODO(), client, nil, "", conf)
-		assert.Nil(t, res)
+		assert.Equal(t, parameter.ResolvedEntity{}, res)
 		assert.Error(t, err)
 	})
 	t.Run("TestDeployAutomation - Scheduling Rule Upsert fails", func(t *testing.T) {
@@ -99,7 +99,7 @@ func TestDeployAutomation_ClientUpsertFails(t *testing.T) {
 			Parameters: toParameterMap([]parameter.NamedParameter{}),
 		}
 		res, err := deployAutomation(context.TODO(), client, nil, "", conf)
-		assert.Nil(t, res)
+		assert.Equal(t, parameter.ResolvedEntity{}, res)
 		assert.Error(t, err)
 	})
 }
diff --git a/pkg/deploy/bucket.go b/pkg/deploy/bucket.go
@@ -31,17 +31,17 @@ type bucketClient interface {
 
 var _ bucketClient = (*bucket.Client)(nil)
 
-func deployBucket(ctx context.Context, client bucketClient, properties parameter.Properties, renderedConfig string, c *config.Config) (*parameter.ResolvedEntity, error) {
+func deployBucket(ctx context.Context, client bucketClient, properties parameter.Properties, renderedConfig string, c *config.Config) (parameter.ResolvedEntity, error) {
 	bucketName := BucketId(c.Coordinate)
 
 	_, err := client.Upsert(ctx, bucketName, []byte(renderedConfig))
 	if err != nil {
-		return &parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("failed to upsert bucket with bucketName %q", bucketName)).withError(err)
+		return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("failed to upsert bucket with bucketName %q", bucketName)).withError(err)
 	}
 
 	properties[config.IdParameter] = bucketName
 
-	return &parameter.ResolvedEntity{
+	return parameter.ResolvedEntity{
 		EntityName: bucketName,
 		Coordinate: c.Coordinate,
 		Properties: properties,
diff --git a/pkg/deploy/classic.go b/pkg/deploy/classic.go
@@ -27,23 +27,23 @@ import (
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/pkg/config/parameter"
 )
 
-func deployClassicConfig(ctx context.Context, configClient dtclient.ConfigClient, apis api.APIs, entityMap *entityMap, properties parameter.Properties, renderedConfig string, conf *config.Config) (*parameter.ResolvedEntity, error) {
+func deployClassicConfig(ctx context.Context, configClient dtclient.ConfigClient, apis api.APIs, entityMap *entityMap, properties parameter.Properties, renderedConfig string, conf *config.Config) (parameter.ResolvedEntity, error) {
 	t, ok := conf.Type.(config.ClassicApiType)
 	if !ok {
-		return &parameter.ResolvedEntity{}, fmt.Errorf("config was not of expected type %q, but %q", config.ClassicApiTypeId, conf.Type.ID())
+		return parameter.ResolvedEntity{}, fmt.Errorf("config was not of expected type %q, but %q", config.ClassicApiTypeId, conf.Type.ID())
 	}
 
 	apiToDeploy, found := apis[t.Api]
 	if !found {
-		return &parameter.ResolvedEntity{}, fmt.Errorf("unknown api `%s`. this is most likely a bug", t.Api)
+		return parameter.ResolvedEntity{}, fmt.Errorf("unknown api `%s`. this is most likely a bug", t.Api)
 	}
 
 	configName, err := extractConfigName(conf, properties)
 	if err != nil {
-		return &parameter.ResolvedEntity{}, err
+		return parameter.ResolvedEntity{}, err
 	}
 	if entityMap.contains(apiToDeploy.ID, configName) && !apiToDeploy.NonUniqueName {
-		return &parameter.ResolvedEntity{}, newConfigDeployErr(conf, fmt.Sprintf("duplicated config name `%s`", configName))
+		return parameter.ResolvedEntity{}, newConfigDeployErr(conf, fmt.Sprintf("duplicated config name `%s`", configName))
 	}
 
 	if apiToDeploy.DeprecatedBy != "" {
@@ -58,13 +58,13 @@ func deployClassicConfig(ctx context.Context, configClient dtclient.ConfigClient
 	}
 
 	if err != nil {
-		return &parameter.ResolvedEntity{}, newConfigDeployErr(conf, err.Error()).withError(err)
+		return parameter.ResolvedEntity{}, newConfigDeployErr(conf, err.Error()).withError(err)
 	}
 
 	properties[config.IdParameter] = entity.Id
 	properties[config.NameParameter] = entity.Name
 
-	return &parameter.ResolvedEntity{
+	return parameter.ResolvedEntity{
 		EntityName: entity.Name,
 		Coordinate: conf.Coordinate,
 		Properties: properties,
diff --git a/pkg/deploy/deploy.go b/pkg/deploy/deploy.go
@@ -83,7 +83,7 @@ func DeployConfigs(clientSet ClientSet, apis api.APIs, sortedConfigs []config.Co
 				return errs
 			}
 		} else {
-			entityMap.put(*entity)
+			entityMap.put(entity)
 		}
 	}
 
@@ -272,7 +272,7 @@ func (c *componentDeployer) deployNode(ctx context.Context, n graph.ConfigNode)
 		return nil
 	}
 
-	c.resolvedEntities.put(*entity)
+	c.resolvedEntities.put(entity)
 	log.WithCtxFields(ctx).Info("Deployment successful")
 	return nil
 }
@@ -318,39 +318,39 @@ func deployComponent(ctx context.Context, component graph.SortedComponent, clien
 }
 
 // deployFunc kinda just is a smarter deploy... TODO refactor!
-func deployFunc(ctx context.Context, c *config.Config, clientSet ClientSet, apis api.APIs, entityMap *entityMap) (*parameter.ResolvedEntity, error) {
+func deployFunc(ctx context.Context, c *config.Config, clientSet ClientSet, apis api.APIs, entityMap *entityMap) (parameter.ResolvedEntity, error) {
 	if c.Skip {
 		log.WithCtxFields(ctx).Info("Skipping deployment of config %s", c.Coordinate)
-		return nil, skipError //fake resolved entity that "old" deploy creates is never needed, as we don't even try to deploy dependencies of skipped configs (so no reference will ever be attempted to resolve)
+		return parameter.ResolvedEntity{}, skipError //fake resolved entity that "old" deploy creates is never needed, as we don't even try to deploy dependencies of skipped configs (so no reference will ever be attempted to resolve)
 	}
 
 	entity, deploymentErrors := deploy(ctx, clientSet, apis, entityMap, c)
 
 	if len(deploymentErrors) > 0 {
-		return nil, fmt.Errorf("failed to deploy config %s: %w", c.Coordinate, errors.Join(deploymentErrors...))
+		return parameter.ResolvedEntity{}, fmt.Errorf("failed to deploy config %s: %w", c.Coordinate, errors.Join(deploymentErrors...))
 	}
 
 	return entity, nil
 }
 
-func deploy(ctx context.Context, clientSet ClientSet, apis api.APIs, em *entityMap, c *config.Config) (*parameter.ResolvedEntity, []error) {
+func deploy(ctx context.Context, clientSet ClientSet, apis api.APIs, em *entityMap, c *config.Config) (parameter.ResolvedEntity, []error) {
 	if c.Skip {
 		log.WithCtxFields(ctx).Info("Skipping deployment of config %s", c.Coordinate)
-		return &parameter.ResolvedEntity{EntityName: c.Coordinate.ConfigId, Coordinate: c.Coordinate, Properties: parameter.Properties{}, Skip: true}, nil
+		return parameter.ResolvedEntity{EntityName: c.Coordinate.ConfigId, Coordinate: c.Coordinate, Properties: parameter.Properties{}, Skip: true}, nil
 	}
 
 	properties, errs := resolveProperties(c, em.get())
 	if len(errs) > 0 {
-		return &parameter.ResolvedEntity{}, errs
+		return parameter.ResolvedEntity{}, errs
 	}
 
 	renderedConfig, err := c.Render(properties)
 	if err != nil {
-		return &parameter.ResolvedEntity{}, []error{err}
+		return parameter.ResolvedEntity{}, []error{err}
 	}
 
 	log.WithCtxFields(ctx).Info("Deploying config")
-	var res *parameter.ResolvedEntity
+	var res parameter.ResolvedEntity
 	var deployErr error
 	switch c.Type.(type) {
 	case config.SettingsType:
@@ -376,7 +376,7 @@ func deploy(ctx context.Context, clientSet ClientSet, apis api.APIs, em *entityM
 		} else {
 			log.WithCtxFields(ctx).WithFields(field.Error(deployErr)).Error("Failed to deploy config %s: %s", c.Coordinate, deployErr.Error())
 		}
-		return nil, []error{deployErr}
+		return parameter.ResolvedEntity{}, []error{deployErr}
 	}
 	return res, nil
 
diff --git a/pkg/deploy/deploy_test.go b/pkg/deploy/deploy_test.go
@@ -269,7 +269,7 @@ func TestDeploySetting(t *testing.T) {
 
 			got, errors := deploy(context.TODO(), ClientSet{Settings: c}, nil, newEntityMap(testApiMap), &tt.given.config)
 			if !tt.wantErr {
-				assert.Equal(t, got, &tt.want)
+				assert.Equal(t, got, tt.want)
 				assert.Emptyf(t, errors, "errors: %v)", errors)
 			} else {
 				assert.NotEmptyf(t, errors, "errors: %v)", errors)
diff --git a/pkg/deploy/settings.go b/pkg/deploy/settings.go
@@ -27,15 +27,15 @@ import (
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/pkg/config/parameter"
 )
 
-func deploySetting(ctx context.Context, settingsClient dtclient.SettingsClient, properties parameter.Properties, renderedConfig string, c *config.Config) (*parameter.ResolvedEntity, error) {
+func deploySetting(ctx context.Context, settingsClient dtclient.SettingsClient, properties parameter.Properties, renderedConfig string, c *config.Config) (parameter.ResolvedEntity, error) {
 	t, ok := c.Type.(config.SettingsType)
 	if !ok {
-		return &parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("config was not of expected type %q, but %q", config.SettingsTypeId, c.Type.ID()))
+		return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("config was not of expected type %q, but %q", config.SettingsTypeId, c.Type.ID()))
 	}
 
 	scope, err := extractScope(properties)
 	if err != nil {
-		return &parameter.ResolvedEntity{}, err
+		return parameter.ResolvedEntity{}, err
 	}
 
 	entity, err := settingsClient.UpsertSettings(ctx, dtclient.SettingsObject{
@@ -47,7 +47,7 @@ func deploySetting(ctx context.Context, settingsClient dtclient.SettingsClient,
 		OriginObjectId: c.OriginObjectId,
 	})
 	if err != nil {
-		return &parameter.ResolvedEntity{}, newConfigDeployErr(c, err.Error()).withError(err)
+		return parameter.ResolvedEntity{}, newConfigDeployErr(c, err.Error()).withError(err)
 	}
 
 	name := fmt.Sprintf("[UNKNOWN NAME]%s", entity.Id)
@@ -59,12 +59,12 @@ func deploySetting(ctx context.Context, settingsClient dtclient.SettingsClient,
 
 	properties[config.IdParameter], err = getEntityID(c, entity)
 	if err != nil {
-		return &parameter.ResolvedEntity{}, newConfigDeployErr(c, err.Error()).withError(err)
+		return parameter.ResolvedEntity{}, newConfigDeployErr(c, err.Error()).withError(err)
 	}
 
 	properties[config.NameParameter] = name
 
-	return &parameter.ResolvedEntity{
+	return parameter.ResolvedEntity{
 		EntityName: name,
 		Coordinate: c.Coordinate,
 		Properties: properties,

Original file line number	Diff line number	Diff line change
`@@ -38,10 +38,10 @@ func (c *dummyAutomationClient) Upsert(_ context.Context, _ automation.ResourceT`
`38`	`38`	`return &automation.Response{ID: id}, nil`
`39`	`39`	`}`
`40`	`40`
`41`		`-func deployAutomation(ctx context.Context, client automationClient, properties parameter.Properties, renderedConfig string, c config.Config) (parameter.ResolvedEntity, error) {`
	`41`	`+func deployAutomation(ctx context.Context, client automationClient, properties parameter.Properties, renderedConfig string, c *config.Config) (parameter.ResolvedEntity, error) {`
`42`	`42`	`t, ok := c.Type.(config.AutomationType)`
`43`	`43`	`if !ok {`
`44`		`- return &parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("config was not of expected type %q, but %q", config.AutomationType{}.ID(), c.Type.ID()))`
	`44`	`+ return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("config was not of expected type %q, but %q", config.AutomationType{}.ID(), c.Type.ID()))`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`var id string`
`@@ -54,13 +54,13 @@ func deployAutomation(ctx context.Context, client automationClient, properties p`
`54`	`54`
`55`	`55`	`resourceType, err := automationutils.ClientResourceTypeFromConfigType(t.Resource)`
`56`	`56`	`if err != nil {`
`57`		`- return nil, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)`
	`57`	`+ return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`var resp *automation.Response`
`61`	`61`	`resp, err = client.Upsert(ctx, resourceType, id, []byte(renderedConfig))`
`62`	`62`	`if resp == nil \|\| err != nil {`
`63`		`- return nil, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)`
	`63`	`+ return parameter.ResolvedEntity{}, newConfigDeployErr(c, fmt.Sprintf("failed to upsert automation object of type %s with id %s", t.Resource, id)).withError(err)`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`name := fmt.Sprintf("[UNKNOWN NAME]%s", resp.ID)`
`@@ -77,6 +77,6 @@ func deployAutomation(ctx context.Context, client automationClient, properties p`
`77`	`77`	`Properties: properties,`
`78`	`78`	`Skip: false,`
`79`	`79`	`}`
`80`		`- return &resolved, nil`
	`80`	`+ return resolved, nil`
`81`	`81`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,23 +27,23 @@ import (`
`27`	`27`	`"github.com/dynatrace/dynatrace-configuration-as-code/v2/pkg/config/parameter"`
`28`	`28`	`)`
`29`	`29`
`30`		`-func deployClassicConfig(ctx context.Context, configClient dtclient.ConfigClient, apis api.APIs, entityMap entityMap, properties parameter.Properties, renderedConfig string, conf config.Config) (*parameter.ResolvedEntity, error) {`
	`30`	`+func deployClassicConfig(ctx context.Context, configClient dtclient.ConfigClient, apis api.APIs, entityMap entityMap, properties parameter.Properties, renderedConfig string, conf config.Config) (parameter.ResolvedEntity, error) {`
`31`	`31`	`t, ok := conf.Type.(config.ClassicApiType)`
`32`	`32`	`if !ok {`
`33`		`- return &parameter.ResolvedEntity{}, fmt.Errorf("config was not of expected type %q, but %q", config.ClassicApiTypeId, conf.Type.ID())`
	`33`	`+ return parameter.ResolvedEntity{}, fmt.Errorf("config was not of expected type %q, but %q", config.ClassicApiTypeId, conf.Type.ID())`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`apiToDeploy, found := apis[t.Api]`
`37`	`37`	`if !found {`
`38`		- return &parameter.ResolvedEntity{}, fmt.Errorf("unknown api `%s`. this is most likely a bug", t.Api)
	`38`	+ return parameter.ResolvedEntity{}, fmt.Errorf("unknown api `%s`. this is most likely a bug", t.Api)
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`configName, err := extractConfigName(conf, properties)`
`42`	`42`	`if err != nil {`
`43`		`- return &parameter.ResolvedEntity{}, err`
	`43`	`+ return parameter.ResolvedEntity{}, err`
`44`	`44`	`}`
`45`	`45`	`if entityMap.contains(apiToDeploy.ID, configName) && !apiToDeploy.NonUniqueName {`
`46`		- return &parameter.ResolvedEntity{}, newConfigDeployErr(conf, fmt.Sprintf("duplicated config name `%s`", configName))
	`46`	+ return parameter.ResolvedEntity{}, newConfigDeployErr(conf, fmt.Sprintf("duplicated config name `%s`", configName))
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`if apiToDeploy.DeprecatedBy != "" {`
`@@ -58,13 +58,13 @@ func deployClassicConfig(ctx context.Context, configClient dtclient.ConfigClient`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`if err != nil {`
`61`		`- return &parameter.ResolvedEntity{}, newConfigDeployErr(conf, err.Error()).withError(err)`
	`61`	`+ return parameter.ResolvedEntity{}, newConfigDeployErr(conf, err.Error()).withError(err)`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`properties[config.IdParameter] = entity.Id`
`65`	`65`	`properties[config.NameParameter] = entity.Name`
`66`	`66`
`67`		`- return &parameter.ResolvedEntity{`
	`67`	`+ return parameter.ResolvedEntity{`
`68`	`68`	`EntityName: entity.Name,`
`69`	`69`	`Coordinate: conf.Coordinate,`
`70`	`70`	`Properties: properties,`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ func DeployConfigs(clientSet ClientSet, apis api.APIs, sortedConfigs []config.Co`
`83`	`83`	`return errs`
`84`	`84`	`}`
`85`	`85`	`} else {`
`86`		`- entityMap.put(*entity)`
	`86`	`+ entityMap.put(entity)`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`@@ -272,7 +272,7 @@ func (c *componentDeployer) deployNode(ctx context.Context, n graph.ConfigNode)`
`272`	`272`	`return nil`
`273`	`273`	`}`
`274`	`274`
`275`		`- c.resolvedEntities.put(*entity)`
	`275`	`+ c.resolvedEntities.put(entity)`
`276`	`276`	`log.WithCtxFields(ctx).Info("Deployment successful")`
`277`	`277`	`return nil`
`278`	`278`	`}`
`@@ -318,39 +318,39 @@ func deployComponent(ctx context.Context, component graph.SortedComponent, clien`
`318`	`318`	`}`
`319`	`319`
`320`	`320`	`// deployFunc kinda just is a smarter deploy... TODO refactor!`
`321`		`-func deployFunc(ctx context.Context, c config.Config, clientSet ClientSet, apis api.APIs, entityMap entityMap) (*parameter.ResolvedEntity, error) {`
	`321`	`+func deployFunc(ctx context.Context, c config.Config, clientSet ClientSet, apis api.APIs, entityMap entityMap) (parameter.ResolvedEntity, error) {`
`322`	`322`	`if c.Skip {`
`323`	`323`	`log.WithCtxFields(ctx).Info("Skipping deployment of config %s", c.Coordinate)`
`324`		`- return nil, skipError //fake resolved entity that "old" deploy creates is never needed, as we don't even try to deploy dependencies of skipped configs (so no reference will ever be attempted to resolve)`
	`324`	`+ return parameter.ResolvedEntity{}, skipError //fake resolved entity that "old" deploy creates is never needed, as we don't even try to deploy dependencies of skipped configs (so no reference will ever be attempted to resolve)`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`entity, deploymentErrors := deploy(ctx, clientSet, apis, entityMap, c)`
`328`	`328`
`329`	`329`	`if len(deploymentErrors) > 0 {`
`330`		`- return nil, fmt.Errorf("failed to deploy config %s: %w", c.Coordinate, errors.Join(deploymentErrors...))`
	`330`	`+ return parameter.ResolvedEntity{}, fmt.Errorf("failed to deploy config %s: %w", c.Coordinate, errors.Join(deploymentErrors...))`
`331`	`331`	`}`
`332`	`332`
`333`	`333`	`return entity, nil`
`334`	`334`	`}`
`335`	`335`
`336`		`-func deploy(ctx context.Context, clientSet ClientSet, apis api.APIs, em entityMap, c config.Config) (*parameter.ResolvedEntity, []error) {`
	`336`	`+func deploy(ctx context.Context, clientSet ClientSet, apis api.APIs, em entityMap, c config.Config) (parameter.ResolvedEntity, []error) {`
`337`	`337`	`if c.Skip {`
`338`	`338`	`log.WithCtxFields(ctx).Info("Skipping deployment of config %s", c.Coordinate)`
`339`		`- return &parameter.ResolvedEntity{EntityName: c.Coordinate.ConfigId, Coordinate: c.Coordinate, Properties: parameter.Properties{}, Skip: true}, nil`
	`339`	`+ return parameter.ResolvedEntity{EntityName: c.Coordinate.ConfigId, Coordinate: c.Coordinate, Properties: parameter.Properties{}, Skip: true}, nil`
`340`	`340`	`}`
`341`	`341`
`342`	`342`	`properties, errs := resolveProperties(c, em.get())`
`343`	`343`	`if len(errs) > 0 {`
`344`		`- return &parameter.ResolvedEntity{}, errs`
	`344`	`+ return parameter.ResolvedEntity{}, errs`
`345`	`345`	`}`
`346`	`346`
`347`	`347`	`renderedConfig, err := c.Render(properties)`
`348`	`348`	`if err != nil {`
`349`		`- return &parameter.ResolvedEntity{}, []error{err}`
	`349`	`+ return parameter.ResolvedEntity{}, []error{err}`
`350`	`350`	`}`
`351`	`351`
`352`	`352`	`log.WithCtxFields(ctx).Info("Deploying config")`
`353`		`- var res *parameter.ResolvedEntity`
	`353`	`+ var res parameter.ResolvedEntity`
`354`	`354`	`var deployErr error`
`355`	`355`	`switch c.Type.(type) {`
`356`	`356`	`case config.SettingsType:`
`@@ -376,7 +376,7 @@ func deploy(ctx context.Context, clientSet ClientSet, apis api.APIs, em *entityM`
`376`	`376`	`} else {`
`377`	`377`	`log.WithCtxFields(ctx).WithFields(field.Error(deployErr)).Error("Failed to deploy config %s: %s", c.Coordinate, deployErr.Error())`
`378`	`378`	`}`
`379`		`- return nil, []error{deployErr}`
	`379`	`+ return parameter.ResolvedEntity{}, []error{deployErr}`
`380`	`380`	`}`
`381`	`381`	`return res, nil`
`382`	`382`