feat(manifest): support codebuild environment image config

internal/pkg/cli/pipeline_update.go

@@ -256,6 +256,8 @@ func (o *updatePipelineOpts) Execute() error {
 	}
 	o.shouldPromptUpdateConnection = bool
 
+	build := deploy.PipelineBuildFromManifest(pipeline.Build)
+
 	// convert environments to deployment stages
 	stages, err := o.convertStages(pipeline.Stages)
 	if err != nil {
@@ -272,6 +274,7 @@ func (o *updatePipelineOpts) Execute() error {
 		AppName:         o.appName,
 		Name:            pipeline.Name,
 		Source:          source,
+		Build:           build,
 		Stages:          stages,
 		ArtifactBuckets: artifactBuckets,
 		AdditionalTags:  o.app.Tags,

internal/pkg/cli/pipeline_update_test.go

@@ -619,6 +619,61 @@ source:
 
 			expectedError: fmt.Errorf("update pipeline: some error"),
 		},
+		"update and deploy pipeline with specifying build property": {
+			inApp:     &app,
+			inAppName: appName,
+			inRegion:  region,
+			callMocks: func(m updatePipelineMocks) {
+				content := `
+name: pipepiper
+version: 1
+
+source:
+  provider: GitHub
+  properties:
+    repository: aws/somethingCool
+    access_token_secret: "github-token-badgoose-backend"
+    branch: main
+
+build:
+  image: aws/codebuild/standard:3.0
+
+stages:
+    -
+      name: chicken
+      test_commands:
+        - make test
+        - echo "made test"
+    -
+      name: wings
+      test_commands:
+        - echo "bok bok bok"
+`
+				gomock.InOrder(
+					m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineUpdateResourcesStart, appName)).Times(1),
+					m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
+					m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineUpdateResourcesComplete, appName)).Times(1),
+
+					m.ws.EXPECT().ReadPipelineManifest().Return([]byte(content), nil),
+					m.ws.EXPECT().WorkloadNames().Return([]string{"frontend", "backend"}, nil).Times(1),
+
+					// convertStages
+					m.envStore.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
+					m.envStore.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
+
+					// getArtifactBuckets
+					m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
+
+					// deployPipeline
+					m.deployer.EXPECT().PipelineExists(gomock.Any()).Return(true, nil),
+					m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtPipelineUpdateExistPrompt, pipelineName), "").Return(true, nil),
+					m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineUpdateProposalStart, pipelineName)).Times(1),
+					m.deployer.EXPECT().UpdatePipeline(gomock.Any()).Return(nil),
+					m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineUpdateProposalComplete, pipelineName)).Times(1),
+				)
+			},
+			expectedError: nil,
+		},
 	}
 	for name, tc := range testCases {
 		t.Run(name, func(t *testing.T) {

internal/pkg/deploy/cloudformation/pipeline_test.go

@@ -15,6 +15,8 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const defaultImage = "aws/codebuild/amazonlinux2-x86_64-standard:3.0"
+
 func TestCloudFormation_PipelineExists(t *testing.T) {
 	in := &deploy.CreatePipelineInput{
 		AppName: "kudos",
@@ -79,6 +81,9 @@ func TestCloudFormation_CreatePipeline(t *testing.T) {
 			ProviderName:  "Bitbucket",
 			Branch:        "main",
 		},
+		Build: &deploy.Build{
+			Image: defaultImage,
+		},
 		Stages:          nil,
 		ArtifactBuckets: nil,
 	}
@@ -239,6 +244,9 @@ func TestCloudFormation_UpdatePipeline(t *testing.T) {
 			RepositoryURL: "aws/somethingCool",
 			Branch:        "main",
 		},
+		Build: &deploy.Build{
+			Image: defaultImage,
+		},
 		Stages:          nil,
 		ArtifactBuckets: nil,
 	}

internal/pkg/deploy/cloudformation/stack/ghv1_pipeline_integration_test.go

@@ -27,6 +27,9 @@ func TestGHv1Pipeline_Template(t *testing.T) {
 			Branch:                      "mainline",
 			PersonalAccessTokenSecretID: "my secret",
 		},
+		Build: &deploy.Build{
+			Image: "aws/codebuild/amazonlinux2-x86_64-standard:3.0",
+		},
 		Stages: []deploy.PipelineStage{
 			{
 				AssociatedEnvironment: &deploy.AssociatedEnvironment{

internal/pkg/deploy/pipeline.go

@@ -40,6 +40,9 @@ type CreatePipelineInput struct {
 	// The source code provider for this pipeline
 	Source interface{}
 
+	// The build project settings for this pipeline
+	Build *Build
+
 	// The stages of the pipeline. The order of stages in this list
 	// will be the order we deploy to.
 	Stages []PipelineStage
@@ -52,6 +55,13 @@ type CreatePipelineInput struct {
 	AdditionalTags map[string]string
 }
 
+// Build represents CodeBuild project used in the CodePipeline
+// to build and test Docker image.
+type Build struct {
+	// The URI that identifies the Docker image to use for this build project. 
+	Image string
+}
+
 // ArtifactBucket represents an S3 bucket used by the CodePipeline to store
 // intermediate artifacts produced by the pipeline.
 type ArtifactBucket struct {
@@ -171,6 +181,19 @@ func PipelineSourceFromManifest(mfSource *manifest.Source) (source interface{},
 	}
 }
 
+// PipelineBuildFromManifest processes manifest info about the build project settings.
+func PipelineBuildFromManifest(mfBuild *manifest.Build) (build *Build) {
+	var imageURI string
+	if (mfBuild == nil || mfBuild.Image == "") {
+		imageURI = manifest.DefaultImage
+	} else {
+		imageURI = mfBuild.Image
+	}
+	return &Build{
+		Image: imageURI,
+	}
+}
+
 // GitHubPersonalAccessTokenSecretID returns the ID of the secret in the
 // Secrets manager, which stores the GitHub Personal Access token if the
 // provider is "GitHubV1".

internal/pkg/deploy/pipeline_test.go

@@ -148,6 +148,36 @@ func TestPipelineSourceFromManifest(t *testing.T) {
 	}
 }
 
+func TestPipelineBuildFromManifest(t *testing.T) {
+	const defaultImage = "aws/codebuild/amazonlinux2-x86_64-standard:3.0"
+
+	testCases := map[string]struct {
+		mfBuild             *manifest.Build
+		expectedBuild       *Build
+	}{
+		"set default image if not be specified in manifest": {
+			mfBuild: nil,
+			expectedBuild: &Build{
+				Image: defaultImage,
+			},
+		},
+		"set image according to manifest": {
+			mfBuild: &manifest.Build{
+				Image: "aws/codebuild/standard:3.0",
+			},
+			expectedBuild: &Build{
+				Image: "aws/codebuild/standard:3.0",
+			},
+		},
+	}
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			build := PipelineBuildFromManifest(tc.mfBuild)
+			require.Equal(t, tc.expectedBuild, build, "mismatched build")
+		})
+	}
+}
+
 func TestParseOwnerAndRepo(t *testing.T) {
 	testCases := map[string]struct {
 		src            *GitHubSource

internal/pkg/manifest/pipeline.go

@@ -17,6 +17,7 @@ const (
 	GithubV1ProviderName   = "GitHubV1"
 	CodeCommitProviderName = "CodeCommit"
 	BitbucketProviderName  = "Bitbucket"
+	DefaultImage           = "aws/codebuild/amazonlinux2-x86_64-standard:3.0"
 
 	pipelineManifestPath = "cicd/pipeline.yml"
 )
@@ -157,6 +158,7 @@ type PipelineManifest struct {
 	Name    string                     `yaml:"name"`
 	Version PipelineSchemaMajorVersion `yaml:"version"`
 	Source  *Source                    `yaml:"source"`
+	Build   *Build                     `yaml:"build"`
 	Stages  []PipelineStage            `yaml:"stages"`
 
 	parser template.Parser
@@ -168,6 +170,11 @@ type Source struct {
 	Properties   map[string]interface{} `yaml:"properties"`
 }
 
+// Build defines the build project to build and test image.
+type Build struct {
+	Image string                 `yaml:"image"`
+}
+
 // PipelineStage represents a stage in the pipeline manifest
 type PipelineStage struct {
 	Name             string   `yaml:"name"`
@@ -190,6 +197,9 @@ func NewPipelineManifest(pipelineName string, provider Provider, stages []Pipeli
 			ProviderName: provider.Name(),
 			Properties:   provider.Properties(),
 		},
+		Build: &Build{
+			Image: DefaultImage,
+		},
 		Stages: stages,
 
 		parser: template.New(),

internal/pkg/manifest/pipeline_test.go

@@ -20,6 +20,7 @@ import (
 const (
 	defaultGHBranch = "main"
 	defaultCCBranch = "master"
+	defaultImage    = "aws/codebuild/amazonlinux2-x86_64-standard:3.0"
 )
 
 func TestNewProvider(t *testing.T) {
@@ -106,6 +107,9 @@ func TestNewPipelineManifest(t *testing.T) {
 						Branch:        defaultGHBranch,
 					}),
 				},
+				Build: &Build{
+					Image: defaultImage,
+				},
 				Stages: []PipelineStage{
 					{
 						Name:             "chicken",
@@ -218,7 +222,7 @@ stages:
 			inContent:   `corrupted yaml`,
 			expectedErr: errors.New("yaml: unmarshal errors:\n  line 1: cannot unmarshal !!str `corrupt...` into manifest.PipelineManifest"),
 		},
-		"valid pipeline.yml": {
+		"valid pipeline.yml without build": {
 			inContent: `
 name: pipepiper
 version: 1
@@ -261,6 +265,48 @@ stages:
 				},
 			},
 		},
+		"valid pipeline.yml with build": {
+			inContent: `
+name: pipepiper
+version: 1
+
+source:
+  provider: GitHub
+  properties:
+    repository: aws/somethingCool
+    access_token_secret: "github-token-badgoose-backend"
+    branch: main
+
+build:
+  image: aws/codebuild/standard:3.0
+
+stages:
+    -
+      name: chicken
+      test_commands: []
+`,
+			expectedManifest: &PipelineManifest{
+				Name:    "pipepiper",
+				Version: Ver1,
+				Source: &Source{
+					ProviderName: "GitHub",
+					Properties: map[string]interface{}{
+						"access_token_secret": "github-token-badgoose-backend",
+						"repository":          "aws/somethingCool",
+						"branch":              defaultGHBranch,
+					},
+				},
+				Build: &Build{
+					Image: "aws/codebuild/standard:3.0",
+				},
+				Stages: []PipelineStage{
+					{
+						Name:         "chicken",
+						TestCommands: []string{},
+					},
+				},
+			},
+		},
 	}
 
 	for name, tc := range testCases {

templates/cicd/pipeline.yml

@@ -19,6 +19,12 @@ source:
     # Optional: specify the name of an existing CodeStar Connections connection.
     # connection_name: a-connection
     {{- end}}
+
+# This section defines the build project.
+build:
+  # The URI that identifies the Docker image to use for this build project. 
+  image: {{.Build.Image}}
+
 {{$length := len .Stages}}{{if gt $length 0}}
 # The deployment section defines the order the pipeline will deploy
 # to your environments.

templates/cicd/pipeline_cfn.yml

@@ -117,7 +117,7 @@ Resources:
         Type: LINUX_CONTAINER
         ComputeType: BUILD_GENERAL1_SMALL
         PrivilegedMode: true
-        Image: aws/codebuild/amazonlinux2-x86_64-standard:3.0
+        Image: {{.Build.Image}}
         EnvironmentVariables:
           - Name: AWS_ACCOUNT_ID
             Value: !Sub '${AWS::AccountId}'