repo_name
stringlengths 1
52
| repo_creator
stringclasses 6
values | programming_language
stringclasses 4
values | code
stringlengths 0
9.68M
| num_lines
int64 1
234k
|
|---|---|---|---|---|
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package ecs
import (
"errors"
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ecs"
)
const (
// DesiredStatusStopped represents the desired status "STOPPED" for a task.
DesiredStatusStopped = ecs.DesiredStatusStopped
fmtErrTaskStopped = "task %s: %s"
)
// ErrWaitServiceStableTimeout occurs when the max retries number waiting for the service to be stable exceeded the limit.
type ErrWaitServiceStableTimeout struct {
maxRetries int
}
func (e *ErrWaitServiceStableTimeout) Error() string {
return fmt.Sprintf("max retries %v exceeded", e.maxRetries)
}
// Timeout allows ErrWaitServiceStableTimeout to implement a timeout error interface.
func (e *ErrWaitServiceStableTimeout) Timeout() bool {
return true
}
// ErrNoDefaultCluster occurs when the default cluster is not found.
var ErrNoDefaultCluster = errors.New("default cluster does not exist")
// ErrWaiterResourceNotReadyForTasks contains the STOPPED reason for the container of the first task that failed to start.
type ErrWaiterResourceNotReadyForTasks struct {
tasks []*Task
awsErrResourceNotReady error
}
func (e *ErrWaiterResourceNotReadyForTasks) Error() string {
for _, task := range e.tasks {
if aws.StringValue(task.LastStatus) != DesiredStatusStopped {
continue
}
taskID, err := TaskID(aws.StringValue(task.TaskArn))
if err != nil {
return err.Error()
}
// Combine both task stop reason and container stop reason.
var errMsg string
if task.StoppedReason != nil {
errMsg = aws.StringValue(task.StoppedReason)
}
// TODO: generalize this to be any essential container.
container := task.Containers[0] // NOTE: right now we only support one container per task
if aws.StringValue(container.LastStatus) == DesiredStatusStopped {
if container.Reason != nil {
errMsg = fmt.Sprintf("%s: %s", errMsg, aws.StringValue(container.Reason))
}
}
if errMsg != "" {
return fmt.Sprintf(fmtErrTaskStopped, taskID[:shortTaskIDLength], errMsg)
}
}
return e.awsErrResourceNotReady.Error()
}
// ErrExecuteCommand occurs when ecs:ExecuteCommand fails.
type ErrExecuteCommand struct {
err error
}
func (e *ErrExecuteCommand) Error() string {
return fmt.Sprintf("execute command: %s", e.err.Error())
}
const (
missingFieldAttachment = "attachment"
missingFieldDetailENIID = "detailENIID"
missingFieldPrivateIPv4Address = "privateIPv4"
)
// ErrTaskENIInfoNotFound when some ENI information is not found in a ECS task.
type ErrTaskENIInfoNotFound struct {
MissingField string
TaskARN string
}
func (e *ErrTaskENIInfoNotFound) Error() string {
switch e.MissingField {
case missingFieldAttachment:
return fmt.Sprintf("cannot find network interface attachment for task %s", e.TaskARN)
case missingFieldDetailENIID:
return fmt.Sprintf("cannot find network interface ID for task %s", e.TaskARN)
case missingFieldPrivateIPv4Address:
return fmt.Sprintf("cannot find private IPv4 address for task %s", e.TaskARN)
}
return ""
}
| 104 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package ecs provides a client to make API requests to Amazon Elastic Container Service.
package ecs
import (
"fmt"
"strings"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/service/ecs"
)
const (
// ServiceDeploymentStatusPrimary is the status PRIMARY of an ECS service deployment.
ServiceDeploymentStatusPrimary = "PRIMARY"
// ServiceDeploymentStatusActive is the status ACTIVE of an ECS service deployment.
ServiceDeploymentStatusActive = "ACTIVE"
)
// Service wraps up ECS Service struct.
type Service ecs.Service
// Deployment contains information of a ECS service Deployment.
type Deployment struct {
Id string `json:"id"`
DesiredCount int64 `json:"desiredCount"`
RunningCount int64 `json:"runningCount"`
UpdatedAt time.Time `json:"updatedAt"`
LaunchType string `json:"launchType"`
TaskDefinition string `json:"taskDefinition"`
Status string `json:"status"`
}
// ServiceStatus contains the status info of a service.
type ServiceStatus struct {
DesiredCount int64 `json:"desiredCount"`
RunningCount int64 `json:"runningCount"`
Status string `json:"status"`
Deployments []Deployment `json:"deployments"`
LastDeploymentAt time.Time `json:"lastDeploymentAt"` // kept to avoid breaking change
TaskDefinition string `json:"taskDefinition"` // kept to avoid breaking change
}
// ServiceStatus returns the status of the running service.
func (s *Service) ServiceStatus() ServiceStatus {
var deployments []Deployment
for _, dp := range s.Deployments {
deployments = append(deployments, Deployment{
Id: aws.StringValue(dp.Id),
DesiredCount: aws.Int64Value(dp.DesiredCount),
RunningCount: aws.Int64Value(dp.RunningCount),
UpdatedAt: aws.TimeValue(dp.UpdatedAt),
LaunchType: aws.StringValue(dp.LaunchType),
TaskDefinition: aws.StringValue(dp.TaskDefinition),
Status: aws.StringValue(dp.Status),
})
}
return ServiceStatus{
Status: aws.StringValue(s.Status),
DesiredCount: aws.Int64Value(s.DesiredCount),
RunningCount: aws.Int64Value(s.RunningCount),
Deployments: deployments,
LastDeploymentAt: aws.TimeValue(s.Deployments[0].UpdatedAt), // FIXME Service assumed to have at least one deployment
TaskDefinition: aws.StringValue(s.Deployments[0].TaskDefinition),
}
}
// ServiceConnectAliases returns the ECS Service Connect client aliases for a service.
func (s *Service) ServiceConnectAliases() []string {
if len(s.Deployments) == 0 {
return nil
}
lastDeployment := s.Deployments[0]
scConfig := lastDeployment.ServiceConnectConfiguration
if scConfig == nil || !aws.BoolValue(scConfig.Enabled) {
return nil
}
var aliases []string
for _, service := range scConfig.Services {
defaultName := aws.StringValue(service.PortName)
if aws.StringValue(service.DiscoveryName) != "" {
defaultName = aws.StringValue(service.DiscoveryName)
}
defaultAlias := fmt.Sprintf("%s.%s", defaultName, aws.StringValue(scConfig.Namespace))
if len(service.ClientAliases) == 0 {
aliases = append(aliases, defaultAlias)
continue
}
for _, clientAlias := range service.ClientAliases {
alias := defaultAlias
if aws.StringValue(clientAlias.DnsName) != "" {
alias = aws.StringValue(clientAlias.DnsName)
}
aliases = append(aliases, fmt.Sprintf("%s:%v", alias, aws.Int64Value(clientAlias.Port)))
}
}
return aliases
}
// LastUpdatedAt returns the last updated time of the ECS service.
func (s *Service) LastUpdatedAt() time.Time {
return aws.TimeValue(s.Deployments[0].UpdatedAt)
}
// TargetGroups returns the ARNs of target groups attached to the service.
func (s *Service) TargetGroups() []string {
var targetGroupARNs []string
for _, lb := range s.LoadBalancers {
targetGroupARNs = append(targetGroupARNs, aws.StringValue(lb.TargetGroupArn))
}
return targetGroupARNs
}
// ServiceArn is the arn of an ECS service.
type ServiceArn string
// ClusterName returns the cluster name.
// For example: arn:aws:ecs:us-west-2:1234567890:service/my-project-test-Cluster-9F7Y0RLP60R7/my-project-test-myService-JSOH5GYBFAIB
// will return my-project-test-Cluster-9F7Y0RLP60R7
func (s *ServiceArn) ClusterName() (string, error) {
serviceArn := string(*s)
parsedArn, err := arn.Parse(serviceArn)
if err != nil {
return "", err
}
resources := strings.Split(parsedArn.Resource, "/")
if len(resources) != 3 {
return "", fmt.Errorf("cannot parse resource for ARN %s", serviceArn)
}
return resources[1], nil
}
// ServiceName returns the service name.
// For example: arn:aws:ecs:us-west-2:1234567890:service/my-project-test-Cluster-9F7Y0RLP60R7/my-project-test-myService-JSOH5GYBFAIB
// will return my-project-test-myService-JSOH5GYBFAIB
func (s *ServiceArn) ServiceName() (string, error) {
serviceArn := string(*s)
parsedArn, err := arn.Parse(serviceArn)
if err != nil {
return "", err
}
resources := strings.Split(parsedArn.Resource, "/")
if len(resources) != 3 {
return "", fmt.Errorf("cannot parse resource for ARN %s", serviceArn)
}
return resources[2], nil
}
// NetworkConfiguration holds service's NetworkConfiguration.
type NetworkConfiguration struct {
AssignPublicIp string
SecurityGroups []string
Subnets []string
}
| 160 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package ecs
import (
"testing"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ecs"
"github.com/stretchr/testify/require"
)
func TestService_TargetGroups(t *testing.T) {
t.Run("should return correct ARNs", func(t *testing.T) {
s := Service{
LoadBalancers: []*ecs.LoadBalancer{
{
TargetGroupArn: aws.String("group-1"),
},
{
TargetGroupArn: aws.String("group-2"),
},
},
}
got := s.TargetGroups()
expected := []string{"group-1", "group-2"}
require.Equal(t, expected, got)
})
}
func TestService_ServiceStatus(t *testing.T) {
t.Run("should include active and primary deployments in status", func(t *testing.T) {
inService := Service{
Deployments: []*ecs.Deployment{
{
Status: aws.String("ACTIVE"),
Id: aws.String("id-1"),
DesiredCount: aws.Int64(3),
RunningCount: aws.Int64(3),
},
{
Status: aws.String("ACTIVE"),
Id: aws.String("id-3"),
DesiredCount: aws.Int64(4),
RunningCount: aws.Int64(2),
},
{
Status: aws.String("PRIMARY"),
Id: aws.String("id-4"),
DesiredCount: aws.Int64(10),
RunningCount: aws.Int64(1),
},
{
Status: aws.String("INACTIVE"),
Id: aws.String("id-5"),
},
},
}
wanted := ServiceStatus{
Status: "",
DesiredCount: 0,
RunningCount: 0,
Deployments: []Deployment{
{
Id: "id-1",
DesiredCount: 3,
RunningCount: 3,
Status: "ACTIVE",
},
{
Id: "id-3",
DesiredCount: 4,
RunningCount: 2,
Status: "ACTIVE",
},
{
Id: "id-4",
DesiredCount: 10,
RunningCount: 1,
Status: "PRIMARY",
},
{
Id: "id-5",
Status: "INACTIVE",
},
},
LastDeploymentAt: time.Time{},
TaskDefinition: "",
}
got := inService.ServiceStatus()
require.Equal(t, got, wanted)
})
}
func TestService_LastUpdatedAt(t *testing.T) {
mockTime1 := time.Unix(14945056, 0)
mockTime2 := time.Unix(14945059, 0)
t.Run("should return correct last updated value", func(t *testing.T) {
s := Service{
Deployments: []*ecs.Deployment{
{
UpdatedAt: &mockTime1,
},
{
UpdatedAt: &mockTime2,
},
},
}
got := s.LastUpdatedAt()
require.Equal(t, mockTime1, got)
})
}
func TestService_ServiceConnectAliases(t *testing.T) {
tests := map[string]struct {
inService *Service
wantedError error
wanted []string
}{
"quit early if not enabled": {
inService: &Service{
Deployments: []*ecs.Deployment{
{
ServiceConnectConfiguration: &ecs.ServiceConnectConfiguration{
Enabled: aws.Bool(false),
},
},
},
},
wanted: []string{},
},
"success": {
inService: &Service{
Deployments: []*ecs.Deployment{
{
ServiceConnectConfiguration: &ecs.ServiceConnectConfiguration{
Enabled: aws.Bool(true),
Namespace: aws.String("foobar.local"),
Services: []*ecs.ServiceConnectService{
{
PortName: aws.String("frontend"),
DiscoveryName: aws.String("front"),
},
{
PortName: aws.String("frontend"),
},
{
PortName: aws.String("frontend"),
ClientAliases: []*ecs.ServiceConnectClientAlias{
{
Port: aws.Int64(5000),
},
{
DnsName: aws.String("api"),
Port: aws.Int64(80),
},
},
},
},
},
},
},
},
wanted: []string{"front.foobar.local", "frontend.foobar.local", "frontend.foobar.local:5000", "api:80"},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
// WHEN
get := tc.inService.ServiceConnectAliases()
// THEN
require.ElementsMatch(t, get, tc.wanted)
})
}
}
| 181 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package ecs provides a client to make API requests to Amazon Elastic Container Service.
package ecs
import (
"fmt"
"strconv"
"strings"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/service/ecs"
)
const (
shortTaskIDLength = 8
imageDigestPrefix = "sha256:"
lastStatusRunning = "RUNNING"
// These field names are not defined as const in sdk.
networkInterfaceIDKey = "networkInterfaceId"
privateIPv4AddressKey = "privateIPv4Address"
networkInterfaceAttachmentType = "ElasticNetworkInterface"
// TaskContainerHealthStatusUnknown wraps the ECS health status UNKNOWN.
TaskContainerHealthStatusUnknown = ecs.HealthStatusUnknown
// TaskContainerHealthStatusHealthy wraps the ECS health status HEALTHY.
TaskContainerHealthStatusHealthy = ecs.HealthStatusHealthy
// TaskContainerHealthStatusUnhealthy wraps the ECS health status UNHEALTHY.
TaskContainerHealthStatusUnhealthy = ecs.HealthStatusUnhealthy
// TaskCapacityProviderFargate is the capacity provider name for FARGATE.
TaskCapacityProviderFargate = "FARGATE"
// TaskCapacityProviderFargateSpot is the capacity provider name for FARGATE_SPOT.
TaskCapacityProviderFargateSpot = "FARGATE_SPOT"
// TaskStatusRunning is the task status running.
TaskStatusRunning = "RUNNING"
)
// Image contains very basic info of a container image.
type Image struct {
ID string
Digest string
}
// Task wraps up ECS Task struct.
type Task ecs.Task
// String returns the human readable format of an ECS task.
// For example, a task with ARN arn:aws:ecs:us-west-2:123456789:task/4082490ee6c245e09d2145010aa1ba8d
// and task definition ARN arn:aws:ecs:us-west-2:123456789012:task-definition/sample-fargate:2
// becomes "4082490e (sample-fargate:2)"
func (t Task) String() string {
taskID, _ := TaskID(aws.StringValue(t.TaskArn))
taskID = shortTaskID(taskID)
taskDefName, _ := taskDefinitionName(aws.StringValue(t.TaskDefinitionArn))
return fmt.Sprintf("%s (%s)", taskID, taskDefName)
}
// TaskStatus returns the status of the running task.
func (t *Task) TaskStatus() (*TaskStatus, error) {
taskID, err := TaskID(aws.StringValue(t.TaskArn))
if err != nil {
return nil, err
}
var startedAt, stoppedAt time.Time
var stoppedReason string
if t.StoppedAt != nil {
stoppedAt = *t.StoppedAt
}
if t.StartedAt != nil {
startedAt = *t.StartedAt
}
if t.StoppedReason != nil {
stoppedReason = aws.StringValue(t.StoppedReason)
}
var images []Image
for _, container := range t.Containers {
images = append(images, Image{
ID: aws.StringValue(container.Image),
Digest: imageDigestValue(aws.StringValue(container.ImageDigest)),
})
}
return &TaskStatus{
Health: aws.StringValue(t.HealthStatus),
ID: taskID,
Images: images,
LastStatus: aws.StringValue(t.LastStatus),
StartedAt: startedAt,
StoppedAt: stoppedAt,
StoppedReason: stoppedReason,
CapacityProvider: aws.StringValue(t.CapacityProviderName),
TaskDefinition: aws.StringValue(t.TaskDefinitionArn),
}, nil
}
// ENI returns the network interface ID of the running task.
// Every Fargate task is provided with an ENI by default (https://docs.aws.amazon.com/AmazonECS/latest/userguide/fargate-task-networking.html).
func (t *Task) ENI() (string, error) {
attachmentENI, err := t.attachmentENI()
if err != nil {
return "", err
}
for _, detail := range attachmentENI.Details {
if aws.StringValue(detail.Name) == networkInterfaceIDKey {
return aws.StringValue(detail.Value), nil
}
}
return "", &ErrTaskENIInfoNotFound{
MissingField: missingFieldDetailENIID,
TaskARN: aws.StringValue(t.TaskArn),
}
}
// PrivateIP returns the private IPv4 address of the task.
func (t *Task) PrivateIP() (string, error) {
attachmentENI, err := t.attachmentENI()
if err != nil {
return "", err
}
for _, detail := range attachmentENI.Details {
if aws.StringValue(detail.Name) == privateIPv4AddressKey {
return aws.StringValue(detail.Value), nil
}
}
return "", &ErrTaskENIInfoNotFound{
MissingField: missingFieldPrivateIPv4Address,
TaskARN: aws.StringValue(t.TaskArn),
}
}
func (t *Task) attachmentENI() (*ecs.Attachment, error) {
// Every Fargate task is provided with an ENI by default (https://docs.aws.amazon.com/AmazonECS/latest/userguide/fargate-task-networking.html).
// So an error is warranted if there is no ENI found.
var attachmentENI *ecs.Attachment
for _, attachment := range t.Attachments {
if aws.StringValue(attachment.Type) == networkInterfaceAttachmentType {
attachmentENI = attachment
break
}
}
if attachmentENI == nil {
return nil, &ErrTaskENIInfoNotFound{
MissingField: missingFieldAttachment,
TaskARN: aws.StringValue(t.TaskArn),
}
}
return attachmentENI, nil
}
// TaskStatus contains the status info of a task.
type TaskStatus struct {
Health string `json:"health"`
ID string `json:"id"`
Images []Image `json:"images"`
LastStatus string `json:"lastStatus"`
StartedAt time.Time `json:"startedAt"`
StoppedAt time.Time `json:"stoppedAt"`
StoppedReason string `json:"stoppedReason"`
CapacityProvider string `json:"capacityProvider"`
TaskDefinition string `json:"taskDefinitionARN"`
}
// TaskDefinition wraps up ECS TaskDefinition struct.
type TaskDefinition ecs.TaskDefinition
// ContainerPlatform holds basic info of a container's platform.
type ContainerPlatform struct {
OperatingSystem string
Architecture string
}
// Platform returns the platform of the task definition.
func (t *TaskDefinition) Platform() *ContainerPlatform {
if t.RuntimePlatform == nil {
return nil
}
return &ContainerPlatform{
OperatingSystem: aws.StringValue(t.RuntimePlatform.OperatingSystemFamily),
Architecture: aws.StringValue(t.RuntimePlatform.CpuArchitecture),
}
}
// ContainerEnvVar holds basic info of an environment variable.
type ContainerEnvVar struct {
Name string
Container string
Value string
}
// EnvironmentVariables returns environment variables of the task definition.
func (t *TaskDefinition) EnvironmentVariables() []*ContainerEnvVar {
var envs []*ContainerEnvVar
for _, container := range t.ContainerDefinitions {
for _, env := range container.Environment {
envs = append(envs, &ContainerEnvVar{
aws.StringValue(env.Name),
aws.StringValue(container.Name),
aws.StringValue(env.Value),
})
}
}
return envs
}
// ContainerSecret holds basic info of a secret.
type ContainerSecret struct {
Name string
Container string
ValueFrom string
}
// Secrets returns secrets of the task definition.
func (t *TaskDefinition) Secrets() []*ContainerSecret {
var secrets []*ContainerSecret
for _, container := range t.ContainerDefinitions {
for _, secret := range container.Secrets {
secrets = append(secrets, &ContainerSecret{
aws.StringValue(secret.Name),
aws.StringValue(container.Name),
aws.StringValue(secret.ValueFrom),
})
}
}
return secrets
}
// Image returns the container's image of the task definition.
func (t *TaskDefinition) Image(containerName string) (string, error) {
for _, container := range t.ContainerDefinitions {
if aws.StringValue(container.Name) == containerName {
return aws.StringValue(container.Image), nil
}
}
return "", fmt.Errorf("container %s not found", containerName)
}
// Command returns the container's command overrides of the task definition.
func (t *TaskDefinition) Command(containerName string) ([]string, error) {
for _, container := range t.ContainerDefinitions {
if aws.StringValue(container.Name) == containerName {
return aws.StringValueSlice(container.Command), nil
}
}
return nil, fmt.Errorf("container %s not found", containerName)
}
// EntryPoint returns the container's entrypoint overrides of the task definition.
func (t *TaskDefinition) EntryPoint(containerName string) ([]string, error) {
for _, container := range t.ContainerDefinitions {
if aws.StringValue(container.Name) == containerName {
return aws.StringValueSlice(container.EntryPoint), nil
}
}
return nil, fmt.Errorf("container %s not found", containerName)
}
// TaskID parses the task ARN and returns the task ID.
// For example: arn:aws:ecs:us-west-2:123456789:task/my-project-test-Cluster-9F7Y0RLP60R7/4082490ee6c245e09d2145010aa1ba8d,
// arn:aws:ecs:us-west-2:123456789:task/4082490ee6c245e09d2145010aa1ba8d
// return 4082490ee6c245e09d2145010aa1ba8d.
func TaskID(taskARN string) (string, error) {
parsedARN, err := arn.Parse(taskARN)
if err != nil {
return "", fmt.Errorf("parse ECS task ARN: %w", err)
}
resources := strings.Split(parsedARN.Resource, "/")
taskID := resources[len(resources)-1]
return taskID, nil
}
// TaskDefinitionVersion takes a task definition ARN and returns its version.
// For example, given "arn:aws:ecs:us-east-1:568623488001:task-definition/some-task-def:6", it returns 6.
func TaskDefinitionVersion(taskDefARN string) (int, error) {
parsedARN, err := arn.Parse(taskDefARN)
if err != nil {
return 0, fmt.Errorf("parse ARN %s: %w", taskDefARN, err)
}
resource := parsedARN.Resource
parts := strings.Split(resource, ":")
version, err := strconv.Atoi(parts[len(parts)-1])
if err != nil {
return 0, fmt.Errorf("convert version %s from string to int: %w", parts[len(parts)-1], err)
}
return version, nil
}
func shortTaskID(id string) string {
if len(id) >= shortTaskIDLength {
return id[:shortTaskIDLength]
}
return id
}
// FilterRunningTasks returns only tasks with the last status to be RUNNING.
func FilterRunningTasks(tasks []*Task) []*Task {
var filtered []*Task
for _, task := range tasks {
if aws.StringValue(task.LastStatus) == lastStatusRunning {
filtered = append(filtered, task)
}
}
return filtered
}
// imageDigestValue strips the hash function prefix, such as "sha256:", from the digest.
// For example: sha256:18f7eb6cff6e63e5f5273fb53f672975fe6044580f66c354f55d2de8dd28aec7
// becomes 18f7eb6cff6e63e5f5273fb53f672975fe6044580f66c354f55d2de8dd28aec7.
func imageDigestValue(digest string) string {
return strings.TrimPrefix(digest, imageDigestPrefix)
}
// taskDefinitionName parses the task definition ARN and returns the task definition name.
// For example: arn:aws:ecs:us-west-2:123456789012:task-definition/sample-fargate:2
// returns sample-fargate:2
func taskDefinitionName(taskDefARN string) (string, error) {
parsedARN, err := arn.Parse(taskDefARN)
if err != nil {
return "", fmt.Errorf("parse ECS task definition ARN: %w", err)
}
resources := strings.Split(parsedARN.Resource, "/")
return resources[len(resources)-1], nil
}
| 330 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package ecs
import (
"errors"
"fmt"
"testing"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ecs"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestTask_TaskStatus(t *testing.T) {
startTime, _ := time.Parse(time.RFC3339, "2006-01-02T15:04:05+00:00")
stopTime, _ := time.Parse(time.RFC3339, "2006-01-02T16:04:05+00:00")
mockImageDigest := "18f7eb6cff6e63e5f5273fb53f672975fe6044580f66c354f55d2de8dd28aec7"
testCases := map[string]struct {
health *string
taskArn *string
containers []*ecs.Container
lastStatus *string
startedAt time.Time
stoppedAt time.Time
stoppedReason *string
wantTaskStatus *TaskStatus
wantErr error
}{
"errors if failed to parse task ID": {
taskArn: aws.String("badTaskArn"),
wantErr: fmt.Errorf("parse ECS task ARN: arn: invalid prefix"),
},
"success with a provisioning task": {
taskArn: aws.String("arn:aws:ecs:us-west-2:123456789:task/my-project-test-Cluster-9F7Y0RLP60R7/4082490ee6c245e09d2145010aa1ba8d"),
containers: []*ecs.Container{
{
Image: aws.String("mockImageArn"),
ImageDigest: aws.String("sha256:" + mockImageDigest),
},
},
health: aws.String("HEALTHY"),
lastStatus: aws.String("UNKNOWN"),
wantTaskStatus: &TaskStatus{
Health: "HEALTHY",
ID: "4082490ee6c245e09d2145010aa1ba8d",
Images: []Image{
{
Digest: mockImageDigest,
ID: "mockImageArn",
},
},
LastStatus: "UNKNOWN",
},
},
"success with a running task": {
taskArn: aws.String("arn:aws:ecs:us-west-2:123456789:task/my-project-test-Cluster-9F7Y0RLP60R7/4082490ee6c245e09d2145010aa1ba8d"),
containers: []*ecs.Container{
{
Image: aws.String("mockImageArn"),
ImageDigest: aws.String("sha256:" + mockImageDigest),
},
},
health: aws.String("HEALTHY"),
lastStatus: aws.String("UNKNOWN"),
startedAt: startTime,
wantTaskStatus: &TaskStatus{
Health: "HEALTHY",
ID: "4082490ee6c245e09d2145010aa1ba8d",
Images: []Image{
{
Digest: mockImageDigest,
ID: "mockImageArn",
},
},
LastStatus: "UNKNOWN",
StartedAt: startTime,
},
},
"success with a stopped task": {
taskArn: aws.String("arn:aws:ecs:us-west-2:123456789:task/my-project-test-Cluster-9F7Y0RLP60R7/4082490ee6c245e09d2145010aa1ba8d"),
containers: []*ecs.Container{
{
Image: aws.String("mockImageArn"),
ImageDigest: aws.String("sha256:" + mockImageDigest),
},
},
health: aws.String("HEALTHY"),
lastStatus: aws.String("UNKNOWN"),
startedAt: startTime,
stoppedAt: stopTime,
stoppedReason: aws.String("some reason"),
wantTaskStatus: &TaskStatus{
Health: "HEALTHY",
ID: "4082490ee6c245e09d2145010aa1ba8d",
Images: []Image{
{
Digest: mockImageDigest,
ID: "mockImageArn",
},
},
LastStatus: "UNKNOWN",
StartedAt: startTime,
StoppedAt: stopTime,
StoppedReason: "some reason",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
task := Task{
HealthStatus: tc.health,
TaskArn: tc.taskArn,
Containers: tc.containers,
LastStatus: tc.lastStatus,
StartedAt: &tc.startedAt,
StoppedAt: &tc.stoppedAt,
StoppedReason: tc.stoppedReason,
}
gotTaskStatus, gotErr := task.TaskStatus()
if gotErr != nil {
require.EqualError(t, tc.wantErr, gotErr.Error())
} else {
require.Equal(t, tc.wantTaskStatus, gotTaskStatus)
}
})
}
}
func TestTask_ENI(t *testing.T) {
testCases := map[string]struct {
taskARN *string
attachments []*ecs.Attachment
wantedENI string
wantedErr error
}{
"no matching attachment": {
taskARN: aws.String("1"),
attachments: []*ecs.Attachment{
{
Type: aws.String("not ElasticNetworkInterface"),
},
},
wantedErr: &ErrTaskENIInfoNotFound{
MissingField: missingFieldAttachment,
TaskARN: "1",
},
},
"no matching detail in network interface attachment": {
taskARN: aws.String("1"),
attachments: []*ecs.Attachment{
{
Type: aws.String("not ElasticNetworkInterface"),
},
{
Type: aws.String("ElasticNetworkInterface"),
Details: []*ecs.KeyValuePair{
{
Name: aws.String("not networkInterfaceId"),
Value: aws.String("val"),
},
},
},
},
wantedErr: &ErrTaskENIInfoNotFound{
MissingField: missingFieldDetailENIID,
TaskARN: "1",
},
},
"successfully retrieve eni id": {
taskARN: aws.String("1"),
attachments: []*ecs.Attachment{
{
Type: aws.String("not ElasticNetworkInterface"),
},
{
Type: aws.String("ElasticNetworkInterface"),
Details: []*ecs.KeyValuePair{
{
Name: aws.String("not networkInterfaceId"),
Value: aws.String("val"),
},
{
Name: aws.String("networkInterfaceId"),
Value: aws.String("eni-123"),
},
},
},
},
wantedENI: "eni-123",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
task := Task{
TaskArn: tc.taskARN,
Attachments: tc.attachments,
}
out, err := task.ENI()
if tc.wantedErr != nil {
require.Equal(t, tc.wantedErr, err)
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedENI, out)
}
})
}
}
func TestTask_PrivateIP(t *testing.T) {
testCases := map[string]struct {
taskARN *string
attachments []*ecs.Attachment
wantedENI string
wantedErr error
}{
"no matching attachment": {
taskARN: aws.String("1"),
attachments: []*ecs.Attachment{
{
Type: aws.String("not ElasticNetworkInterface"),
},
},
wantedErr: &ErrTaskENIInfoNotFound{
MissingField: missingFieldAttachment,
TaskARN: "1",
},
},
"no matching detail in network interface attachment": {
taskARN: aws.String("1"),
attachments: []*ecs.Attachment{
{
Type: aws.String("not ElasticNetworkInterface"),
},
{
Type: aws.String("ElasticNetworkInterface"),
Details: []*ecs.KeyValuePair{
{
Name: aws.String("not privateIPv4Address"),
Value: aws.String("val"),
},
},
},
},
wantedErr: &ErrTaskENIInfoNotFound{
MissingField: missingFieldPrivateIPv4Address,
TaskARN: "1",
},
},
"successfully retrieve eni id": {
taskARN: aws.String("1"),
attachments: []*ecs.Attachment{
{
Type: aws.String("not ElasticNetworkInterface"),
},
{
Type: aws.String("ElasticNetworkInterface"),
Details: []*ecs.KeyValuePair{
{
Name: aws.String("not networkInterfaceId"),
Value: aws.String("val"),
},
{
Name: aws.String("privateIPv4Address"),
Value: aws.String("eni-123"),
},
},
},
},
wantedENI: "eni-123",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
task := Task{
TaskArn: tc.taskARN,
Attachments: tc.attachments,
}
out, err := task.PrivateIP()
if tc.wantedErr != nil {
require.Equal(t, tc.wantedErr, err)
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedENI, out)
}
})
}
}
func Test_TaskID(t *testing.T) {
testCases := map[string]struct {
taskARN string
wantErr error
wantID string
}{
"bad unparsable task ARN": {
taskARN: "mockBadTaskARN",
wantErr: fmt.Errorf("parse ECS task ARN: arn: invalid prefix"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// WHEN
gotID, gotErr := TaskID(tc.taskARN)
// THEN
if gotErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
} else {
require.NoError(t, gotErr)
require.Equal(t, tc.wantID, gotID)
}
})
}
}
func TestTaskDefinition_EnvVars(t *testing.T) {
testCases := map[string]struct {
inContainers []*ecs.ContainerDefinition
wantEnvVars []*ContainerEnvVar
}{
"should return wrapped error given error; otherwise should return list of ContainerEnvVar objects": {
inContainers: []*ecs.ContainerDefinition{
{
Environment: []*ecs.KeyValuePair{
{
Name: aws.String("COPILOT_SERVICE_NAME"),
Value: aws.String("my-svc"),
},
{
Name: aws.String("COPILOT_ENVIRONMENT_NAME"),
Value: aws.String("prod"),
},
},
Name: aws.String("container"),
},
},
wantEnvVars: []*ContainerEnvVar{
{
Name: "COPILOT_SERVICE_NAME",
Container: "container",
Value: "my-svc",
},
{
Name: "COPILOT_ENVIRONMENT_NAME",
Container: "container",
Value: "prod",
},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
taskDefinition := TaskDefinition{
ContainerDefinitions: tc.inContainers,
}
gotEnvVars := taskDefinition.EnvironmentVariables()
require.Equal(t, tc.wantEnvVars, gotEnvVars)
})
}
}
func TestTaskDefinition_Secrets(t *testing.T) {
testCases := map[string]struct {
inContainers []*ecs.ContainerDefinition
wantedSecrets []*ContainerSecret
}{
"should return secrets of the task definition as a list of ContainerSecret objects": {
inContainers: []*ecs.ContainerDefinition{
{
Name: aws.String("container"),
Secrets: []*ecs.Secret{
{
Name: aws.String("GITHUB_WEBHOOK_SECRET"),
ValueFrom: aws.String("GH_WEBHOOK_SECRET"),
},
{
Name: aws.String("SOME_OTHER_SECRET"),
ValueFrom: aws.String("SHHHHHHHH"),
},
},
},
},
wantedSecrets: []*ContainerSecret{
{
Name: "GITHUB_WEBHOOK_SECRET",
Container: "container",
ValueFrom: "GH_WEBHOOK_SECRET",
},
{
Name: "SOME_OTHER_SECRET",
Container: "container",
ValueFrom: "SHHHHHHHH",
},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
taskDefinition := TaskDefinition{
ContainerDefinitions: tc.inContainers,
}
gotSecrets := taskDefinition.Secrets()
require.Equal(t, tc.wantedSecrets, gotSecrets)
})
}
}
func TestTaskDefinition_Image(t *testing.T) {
testCases := map[string]struct {
inContainers []*ecs.ContainerDefinition
inContainerName string
wantedImage string
wantedError error
}{
"should return the container's image": {
inContainers: []*ecs.ContainerDefinition{
{
Name: aws.String("container-1"),
Image: aws.String("image-1"),
},
{
Name: aws.String("container-2"),
Image: aws.String("image-2"),
},
},
inContainerName: "container-2",
wantedImage: "image-2",
},
"container not found": {
inContainers: []*ecs.ContainerDefinition{
{
Name: aws.String("container-1"),
Image: aws.String("image-1"),
},
{
Name: aws.String("container-2"),
Image: aws.String("image-2"),
},
},
inContainerName: "container-3",
wantedError: errors.New("container container-3 not found"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
taskDefinition := TaskDefinition{
ContainerDefinitions: tc.inContainers,
}
gotImages, err := taskDefinition.Image(tc.inContainerName)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
} else {
require.Equal(t, tc.wantedImage, gotImages)
}
})
}
}
func TestTaskDefinition_Command(t *testing.T) {
testCases := map[string]struct {
inContainers []*ecs.ContainerDefinition
inContainerName string
wantedCommand []string
wantedError error
}{
"should return command overrides of the task definition as a list of ContainerCommand": {
inContainers: []*ecs.ContainerDefinition{
{
Name: aws.String("container-1"),
Command: aws.StringSlice([]string{"echo", "strikes", "three"}),
},
{
Name: aws.String("container-2"),
Command: aws.StringSlice([]string{"echo", "ball", "four"}),
},
{
Name: aws.String("container-3"),
},
},
inContainerName: "container-1",
wantedCommand: []string{"echo", "strikes", "three"},
},
"container not found": {
inContainers: []*ecs.ContainerDefinition{
{
Name: aws.String("container-1"),
Command: aws.StringSlice([]string{"echo", "strikes", "three"}),
},
{
Name: aws.String("container-2"),
Command: aws.StringSlice([]string{"echo", "ball", "four"}),
},
},
inContainerName: "container-3",
wantedError: errors.New("container container-3 not found"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
taskDefinition := TaskDefinition{
ContainerDefinitions: tc.inContainers,
}
gotCommands, err := taskDefinition.Command(tc.inContainerName)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
} else {
require.Equal(t, tc.wantedCommand, gotCommands)
}
})
}
}
func TestTaskDefinition_EntryPoint(t *testing.T) {
testCases := map[string]struct {
inContainers []*ecs.ContainerDefinition
inContainerName string
wantedEntryPoints []string
wantedError error
}{
"should return command overrides of the task definition as a list of ContainerCommand": {
inContainers: []*ecs.ContainerDefinition{
{
Name: aws.String("container-1"),
EntryPoint: aws.StringSlice([]string{"echo", "strikes", "three"}),
},
{
Name: aws.String("container-2"),
},
},
inContainerName: "container-1",
wantedEntryPoints: []string{"echo", "strikes", "three"},
},
"container not found": {
inContainers: []*ecs.ContainerDefinition{
{
Name: aws.String("container-1"),
Command: aws.StringSlice([]string{"echo", "strikes", "three"}),
},
{
Name: aws.String("container-2"),
Command: aws.StringSlice([]string{"echo", "ball", "four"}),
},
},
inContainerName: "container-3",
wantedError: errors.New("container container-3 not found"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
taskDefinition := TaskDefinition{
ContainerDefinitions: tc.inContainers,
}
gotEntryPoints, err := taskDefinition.EntryPoint(tc.inContainerName)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
} else {
require.Equal(t, tc.wantedEntryPoints, gotEntryPoints)
}
})
}
}
func TestFilterRunningTasks(t *testing.T) {
testCases := map[string]struct {
inTasks []*Task
wantedTasks []*Task
}{
"should return only running tasks": {
inTasks: []*Task{
{
TaskArn: aws.String("mockTask1"),
LastStatus: aws.String("STOPPED"),
},
{
TaskArn: aws.String("mockTask2"),
LastStatus: aws.String("RUNNING"),
},
},
wantedTasks: []*Task{
{
TaskArn: aws.String("mockTask2"),
LastStatus: aws.String("RUNNING"),
},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
got := FilterRunningTasks(tc.inTasks)
require.Equal(t, tc.wantedTasks, got)
})
}
}
func Test_TaskDefinitionVersion(t *testing.T) {
testCases := map[string]struct {
inARN string
wanted int
wantedError error
}{
"success": {
inARN: "arn:aws:ecs:us-east-1:568623488001:task-definition/some-task-def:6",
wanted: 6,
},
"unable to parse": {
inARN: "random not ARN",
wantedError: errors.New("parse ARN random not ARN: arn: invalid prefix"),
},
"unable to convert version from string to int": {
inARN: "arn:aws:ecs:us-east-1:568623488001:task-definition/some-task-def:six",
wantedError: errors.New("convert version six from string to int: strconv.Atoi: parsing \"six\": invalid syntax"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got, err := TaskDefinitionVersion(tc.inARN)
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, got, tc.wanted)
}
})
}
}
| 703 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/ecs/ecs.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
ecs "github.com/aws/aws-sdk-go/service/ecs"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// DescribeClusters mocks base method.
func (m *Mockapi) DescribeClusters(input *ecs.DescribeClustersInput) (*ecs.DescribeClustersOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeClusters", input)
ret0, _ := ret[0].(*ecs.DescribeClustersOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeClusters indicates an expected call of DescribeClusters.
func (mr *MockapiMockRecorder) DescribeClusters(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClusters", reflect.TypeOf((*Mockapi)(nil).DescribeClusters), input)
}
// DescribeServices mocks base method.
func (m *Mockapi) DescribeServices(input *ecs.DescribeServicesInput) (*ecs.DescribeServicesOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeServices", input)
ret0, _ := ret[0].(*ecs.DescribeServicesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeServices indicates an expected call of DescribeServices.
func (mr *MockapiMockRecorder) DescribeServices(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServices", reflect.TypeOf((*Mockapi)(nil).DescribeServices), input)
}
// DescribeTaskDefinition mocks base method.
func (m *Mockapi) DescribeTaskDefinition(input *ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeTaskDefinition", input)
ret0, _ := ret[0].(*ecs.DescribeTaskDefinitionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeTaskDefinition indicates an expected call of DescribeTaskDefinition.
func (mr *MockapiMockRecorder) DescribeTaskDefinition(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskDefinition", reflect.TypeOf((*Mockapi)(nil).DescribeTaskDefinition), input)
}
// DescribeTasks mocks base method.
func (m *Mockapi) DescribeTasks(input *ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeTasks", input)
ret0, _ := ret[0].(*ecs.DescribeTasksOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeTasks indicates an expected call of DescribeTasks.
func (mr *MockapiMockRecorder) DescribeTasks(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTasks", reflect.TypeOf((*Mockapi)(nil).DescribeTasks), input)
}
// ExecuteCommand mocks base method.
func (m *Mockapi) ExecuteCommand(input *ecs.ExecuteCommandInput) (*ecs.ExecuteCommandOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExecuteCommand", input)
ret0, _ := ret[0].(*ecs.ExecuteCommandOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ExecuteCommand indicates an expected call of ExecuteCommand.
func (mr *MockapiMockRecorder) ExecuteCommand(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteCommand", reflect.TypeOf((*Mockapi)(nil).ExecuteCommand), input)
}
// ListTasks mocks base method.
func (m *Mockapi) ListTasks(input *ecs.ListTasksInput) (*ecs.ListTasksOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListTasks", input)
ret0, _ := ret[0].(*ecs.ListTasksOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListTasks indicates an expected call of ListTasks.
func (mr *MockapiMockRecorder) ListTasks(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasks", reflect.TypeOf((*Mockapi)(nil).ListTasks), input)
}
// RunTask mocks base method.
func (m *Mockapi) RunTask(input *ecs.RunTaskInput) (*ecs.RunTaskOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RunTask", input)
ret0, _ := ret[0].(*ecs.RunTaskOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RunTask indicates an expected call of RunTask.
func (mr *MockapiMockRecorder) RunTask(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTask", reflect.TypeOf((*Mockapi)(nil).RunTask), input)
}
// StopTask mocks base method.
func (m *Mockapi) StopTask(input *ecs.StopTaskInput) (*ecs.StopTaskOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StopTask", input)
ret0, _ := ret[0].(*ecs.StopTaskOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StopTask indicates an expected call of StopTask.
func (mr *MockapiMockRecorder) StopTask(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopTask", reflect.TypeOf((*Mockapi)(nil).StopTask), input)
}
// UpdateService mocks base method.
func (m *Mockapi) UpdateService(input *ecs.UpdateServiceInput) (*ecs.UpdateServiceOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateService", input)
ret0, _ := ret[0].(*ecs.UpdateServiceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UpdateService indicates an expected call of UpdateService.
func (mr *MockapiMockRecorder) UpdateService(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*Mockapi)(nil).UpdateService), input)
}
// WaitUntilTasksRunning mocks base method.
func (m *Mockapi) WaitUntilTasksRunning(input *ecs.DescribeTasksInput) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WaitUntilTasksRunning", input)
ret0, _ := ret[0].(error)
return ret0
}
// WaitUntilTasksRunning indicates an expected call of WaitUntilTasksRunning.
func (mr *MockapiMockRecorder) WaitUntilTasksRunning(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTasksRunning", reflect.TypeOf((*Mockapi)(nil).WaitUntilTasksRunning), input)
}
// MockssmSessionStarter is a mock of ssmSessionStarter interface.
type MockssmSessionStarter struct {
ctrl *gomock.Controller
recorder *MockssmSessionStarterMockRecorder
}
// MockssmSessionStarterMockRecorder is the mock recorder for MockssmSessionStarter.
type MockssmSessionStarterMockRecorder struct {
mock *MockssmSessionStarter
}
// NewMockssmSessionStarter creates a new mock instance.
func NewMockssmSessionStarter(ctrl *gomock.Controller) *MockssmSessionStarter {
mock := &MockssmSessionStarter{ctrl: ctrl}
mock.recorder = &MockssmSessionStarterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockssmSessionStarter) EXPECT() *MockssmSessionStarterMockRecorder {
return m.recorder
}
// StartSession mocks base method.
func (m *MockssmSessionStarter) StartSession(ssmSession *ecs.Session) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StartSession", ssmSession)
ret0, _ := ret[0].(error)
return ret0
}
// StartSession indicates an expected call of StartSession.
func (mr *MockssmSessionStarterMockRecorder) StartSession(ssmSession interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartSession", reflect.TypeOf((*MockssmSessionStarter)(nil).StartSession), ssmSession)
}
| 222 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package elbv2 provides a client to make API requests to Amazon Elastic Load Balancing.
package elbv2
import (
"context"
"errors"
"fmt"
"sort"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/elbv2"
"github.com/dustin/go-humanize/english"
)
const (
// TargetHealthStateHealthy wraps the ELBV2 health status HEALTHY.
TargetHealthStateHealthy = elbv2.TargetHealthStateEnumHealthy
)
type api interface {
DescribeTargetHealth(*elbv2.DescribeTargetHealthInput) (*elbv2.DescribeTargetHealthOutput, error)
DescribeRules(*elbv2.DescribeRulesInput) (*elbv2.DescribeRulesOutput, error)
DescribeRulesWithContext(context.Context, *elbv2.DescribeRulesInput, ...request.Option) (*elbv2.DescribeRulesOutput, error)
}
// ELBV2 wraps an AWS ELBV2 client.
type ELBV2 struct {
client api
}
// New returns a ELBV2 configured against the input session.
func New(sess *session.Session) *ELBV2 {
return &ELBV2{
client: elbv2.New(sess),
}
}
// ListenerRulesHostHeaders returns all the host headers for all listener rules.
func (e *ELBV2) ListenerRulesHostHeaders(ruleARNs []string) ([]string, error) {
resp, err := e.client.DescribeRules(&elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice(ruleARNs),
})
if err != nil {
return nil, fmt.Errorf("get listener rule for %s: %w", english.WordSeries(ruleARNs, "and"), err)
}
if len(resp.Rules) == 0 {
return nil, fmt.Errorf("cannot find listener rule %s", english.WordSeries(ruleARNs, "and"))
}
exists := struct{}{}
hostHeaderSet := make(map[string]struct{})
for _, rule := range resp.Rules {
for _, condition := range rule.Conditions {
if aws.StringValue(condition.Field) == "host-header" {
// Values is a legacy field that allowed specifying only a single host name.
// The alternative is to use HostHeaderConfig for multiple values.
// Only one of these fields should be set, but we collect from both to be safe.
for _, value := range condition.Values {
hostHeaderSet[aws.StringValue(value)] = exists
}
if condition.HostHeaderConfig == nil {
break
}
for _, value := range condition.HostHeaderConfig.Values {
hostHeaderSet[aws.StringValue(value)] = exists
}
break
}
}
}
var hostHeaders []string
for hostHeader := range hostHeaderSet {
hostHeaders = append(hostHeaders, hostHeader)
}
sort.Slice(hostHeaders, func(i, j int) bool { return hostHeaders[i] < hostHeaders[j] })
return hostHeaders, nil
}
// Rule wraps an elbv2.Rule to add some nice functionality to it.
type Rule elbv2.Rule
// DescribeRule returns the Rule with ruleARN.
func (e *ELBV2) DescribeRule(ctx context.Context, ruleARN string) (Rule, error) {
resp, err := e.client.DescribeRulesWithContext(ctx, &elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{ruleARN}),
})
if err != nil {
return Rule{}, err
} else if len(resp.Rules) == 0 {
return Rule{}, errors.New("not found")
}
return Rule(*resp.Rules[0]), nil
}
// HasRedirectAction returns true if the rule has a redirect action.
func (r *Rule) HasRedirectAction() bool {
for _, action := range r.Actions {
if aws.StringValue(action.Type) == elbv2.ActionTypeEnumRedirect {
return true
}
}
return false
}
// TargetHealth wraps up elbv2.TargetHealthDescription.
type TargetHealth elbv2.TargetHealthDescription
// TargetsHealth returns the health status of the targets in a target group.
func (e *ELBV2) TargetsHealth(targetGroupARN string) ([]*TargetHealth, error) {
in := &elbv2.DescribeTargetHealthInput{
TargetGroupArn: aws.String(targetGroupARN),
}
out, err := e.client.DescribeTargetHealth(in)
if err != nil {
return nil, fmt.Errorf("describe target health for target group %s: %w", targetGroupARN, err)
}
ret := make([]*TargetHealth, len(out.TargetHealthDescriptions))
for idx, description := range out.TargetHealthDescriptions {
ret[idx] = (*TargetHealth)(description)
}
return ret, nil
}
// TargetID returns the target's ID, which is either an instance or an IP address.
func (t *TargetHealth) TargetID() string {
return t.targetID()
}
// HealthStatus contains the health status info of a target.
type HealthStatus struct {
TargetID string `json:"targetID"`
HealthDescription string `json:"description"`
HealthState string `json:"state"`
HealthReason string `json:"reason"`
}
// HealthStatus returns the health status of the target.
func (t *TargetHealth) HealthStatus() *HealthStatus {
return &HealthStatus{
TargetID: t.targetID(),
HealthDescription: aws.StringValue(t.TargetHealth.Description),
HealthState: aws.StringValue(t.TargetHealth.State),
HealthReason: aws.StringValue(t.TargetHealth.Reason),
}
}
func (t *TargetHealth) targetID() string {
return aws.StringValue(t.Target.Id)
}
| 156 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package elbv2
import (
"context"
"errors"
"fmt"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/elbv2"
"github.com/aws/copilot-cli/internal/pkg/aws/elbv2/mocks"
)
func TestELBV2_TargetsHealth(t *testing.T) {
testCases := map[string]struct {
targetGroupARN string
setUpMock func(m *mocks.Mockapi)
wantedOut []*TargetHealth
wantedError error
}{
"success": {
targetGroupARN: "group-1",
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeTargetHealth(&elbv2.DescribeTargetHealthInput{
TargetGroupArn: aws.String("group-1"),
}).Return(&elbv2.DescribeTargetHealthOutput{
TargetHealthDescriptions: []*elbv2.TargetHealthDescription{
{
HealthCheckPort: aws.String("80"),
Target: &elbv2.TargetDescription{
Id: aws.String("10.00.233"),
},
TargetHealth: &elbv2.TargetHealth{
Description: aws.String("timed out"),
Reason: aws.String(elbv2.TargetHealthReasonEnumTargetTimeout),
State: aws.String(elbv2.TargetHealthStateEnumUnhealthy),
},
},
{
HealthCheckPort: aws.String("80"),
Target: &elbv2.TargetDescription{
Id: aws.String("10.00.322"),
},
TargetHealth: &elbv2.TargetHealth{
State: aws.String(elbv2.TargetHealthStateEnumHealthy),
},
},
{
HealthCheckPort: aws.String("80"),
Target: &elbv2.TargetDescription{
Id: aws.String("10.00.332"),
},
TargetHealth: &elbv2.TargetHealth{
Description: aws.String("mismatch"),
Reason: aws.String(elbv2.TargetHealthReasonEnumTargetResponseCodeMismatch),
State: aws.String(elbv2.TargetHealthStateEnumUnhealthy),
},
},
},
}, nil)
},
wantedOut: []*TargetHealth{
{
HealthCheckPort: aws.String("80"),
Target: &elbv2.TargetDescription{
Id: aws.String("10.00.233"),
},
TargetHealth: &elbv2.TargetHealth{
Description: aws.String("timed out"),
Reason: aws.String(elbv2.TargetHealthReasonEnumTargetTimeout),
State: aws.String(elbv2.TargetHealthStateEnumUnhealthy),
},
},
{
HealthCheckPort: aws.String("80"),
Target: &elbv2.TargetDescription{
Id: aws.String("10.00.322"),
},
TargetHealth: &elbv2.TargetHealth{
State: aws.String(elbv2.TargetHealthStateEnumHealthy),
},
},
{
HealthCheckPort: aws.String("80"),
Target: &elbv2.TargetDescription{
Id: aws.String("10.00.332"),
},
TargetHealth: &elbv2.TargetHealth{
Description: aws.String("mismatch"),
Reason: aws.String(elbv2.TargetHealthReasonEnumTargetResponseCodeMismatch),
State: aws.String(elbv2.TargetHealthStateEnumUnhealthy),
},
},
},
},
"failed to describe target health": {
targetGroupARN: "group-1",
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeTargetHealth(&elbv2.DescribeTargetHealthInput{
TargetGroupArn: aws.String("group-1"),
}).Return(nil, errors.New("some error"))
},
wantedError: errors.New("describe target health for target group group-1: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAPI := mocks.NewMockapi(ctrl)
tc.setUpMock(mockAPI)
elbv2Client := ELBV2{
client: mockAPI,
}
got, err := elbv2Client.TargetsHealth(tc.targetGroupARN)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedOut, got)
}
})
}
}
func TestELBV2_ListenerRuleHostHeaders(t *testing.T) {
mockARN1 := "mockListenerRuleARN1"
mockARN2 := "mockListenerRuleARN2"
testCases := map[string]struct {
setUpMock func(m *mocks.Mockapi)
inARNs []string
wanted []string
wantedError error
}{
"fail to describe rules": {
inARNs: []string{mockARN1},
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeRules(&elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{mockARN1}),
}).Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("get listener rule for mockListenerRuleARN1: some error"),
},
"cannot find listener rule": {
inARNs: []string{mockARN1},
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeRules(&elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{mockARN1}),
}).Return(&elbv2.DescribeRulesOutput{}, nil)
},
wantedError: fmt.Errorf("cannot find listener rule mockListenerRuleARN1"),
},
"success": {
inARNs: []string{mockARN1},
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeRules(&elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{mockARN1}),
}).Return(&elbv2.DescribeRulesOutput{
Rules: []*elbv2.Rule{
{
Conditions: []*elbv2.RuleCondition{
{
Field: aws.String("path-pattern"),
Values: []*string{aws.String("/*")},
},
{
Field: aws.String("host-header"),
Values: aws.StringSlice([]string{"copilot.com", "archer.com"}),
HostHeaderConfig: &elbv2.HostHeaderConditionConfig{
Values: aws.StringSlice([]string{"copilot.com", "archer.com"}),
},
},
},
},
},
}, nil)
},
wanted: []string{"archer.com", "copilot.com"},
},
"succes in case of multiple rules": {
inARNs: []string{mockARN1, mockARN2},
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeRules(&elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{mockARN1, mockARN2}),
}).Return(&elbv2.DescribeRulesOutput{
Rules: []*elbv2.Rule{
{
Conditions: []*elbv2.RuleCondition{
{
Field: aws.String("path-pattern"),
Values: []*string{aws.String("/*")},
},
{
Field: aws.String("host-header"),
Values: aws.StringSlice([]string{"copilot.com", "archer.com"}),
HostHeaderConfig: &elbv2.HostHeaderConditionConfig{
Values: aws.StringSlice([]string{"copilot.com", "archer.com"}),
},
},
},
},
{
Conditions: []*elbv2.RuleCondition{
{
Field: aws.String("path-pattern"),
Values: []*string{aws.String("/*")},
},
{
Field: aws.String("host-header"),
Values: aws.StringSlice([]string{"v1.copilot.com", "v1.archer.com"}),
HostHeaderConfig: &elbv2.HostHeaderConditionConfig{
Values: aws.StringSlice([]string{"v1.copilot.com", "v1.archer.com"}),
},
},
},
},
},
}, nil)
},
wanted: []string{"archer.com", "copilot.com", "v1.archer.com", "v1.copilot.com"},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAPI := mocks.NewMockapi(ctrl)
tc.setUpMock(mockAPI)
elbv2Client := ELBV2{
client: mockAPI,
}
got, err := elbv2Client.ListenerRulesHostHeaders(tc.inARNs)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wanted, got)
}
})
}
}
func TestELBV2_DescribeRule(t *testing.T) {
mockARN := "mockListenerRuleARN"
testCases := map[string]struct {
setUpMock func(m *mocks.Mockapi)
expectedErr string
expected Rule
}{
"fail to describe rules": {
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeRulesWithContext(gomock.Any(), &elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{mockARN}),
}).Return(nil, errors.New("some error"))
},
expectedErr: "some error",
},
"cannot find listener rule": {
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeRulesWithContext(gomock.Any(), &elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{mockARN}),
}).Return(&elbv2.DescribeRulesOutput{}, nil)
},
expectedErr: `not found`,
},
"success": {
setUpMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeRulesWithContext(gomock.Any(), &elbv2.DescribeRulesInput{
RuleArns: aws.StringSlice([]string{mockARN}),
}).Return(&elbv2.DescribeRulesOutput{
Rules: []*elbv2.Rule{
{
RuleArn: aws.String(mockARN),
},
},
}, nil)
},
expected: Rule(elbv2.Rule{
RuleArn: aws.String(mockARN),
}),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAPI := mocks.NewMockapi(ctrl)
tc.setUpMock(mockAPI)
elbv2Client := ELBV2{
client: mockAPI,
}
actual, err := elbv2Client.DescribeRule(context.Background(), mockARN)
if tc.expectedErr != "" {
require.EqualError(t, err, tc.expectedErr)
} else {
require.Equal(t, tc.expected, actual)
}
})
}
}
func TestELBV2Rule_HasRedirectAction(t *testing.T) {
testCases := map[string]struct {
rule Rule
expected bool
}{
"rule doesn't have redirect": {
rule: Rule(elbv2.Rule{
Actions: []*elbv2.Action{
{
Type: aws.String(elbv2.ActionTypeEnumForward),
},
},
}),
},
"rule has redirect": {
rule: Rule(elbv2.Rule{
Actions: []*elbv2.Action{
{
Type: aws.String(elbv2.ActionTypeEnumRedirect),
},
},
}),
expected: true,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
require.Equal(t, tc.expected, tc.rule.HasRedirectAction())
})
}
}
func TestTargetHealth_HealthStatus(t *testing.T) {
testCases := map[string]struct {
inTargetHealth *TargetHealth
wanted *HealthStatus
}{
"unhealthy status with all params": {
inTargetHealth: &TargetHealth{
Target: &elbv2.TargetDescription{
Id: aws.String("42.42.42.42"),
},
TargetHealth: &elbv2.TargetHealth{
State: aws.String("unhealthy"),
Description: aws.String("some description"),
Reason: aws.String("some reason"),
},
},
wanted: &HealthStatus{
TargetID: "42.42.42.42",
HealthState: "unhealthy",
HealthDescription: "some description",
HealthReason: "some reason",
},
},
"healthy status with description and reason empty": {
inTargetHealth: &TargetHealth{
Target: &elbv2.TargetDescription{
Id: aws.String("24.24.24.24"),
},
TargetHealth: &elbv2.TargetHealth{
State: aws.String("healthy"),
},
},
wanted: &HealthStatus{
TargetID: "24.24.24.24",
HealthState: "healthy",
HealthDescription: "",
HealthReason: "",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := tc.inTargetHealth.HealthStatus()
require.Equal(t, got, tc.wanted)
})
}
}
| 414 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/elbv2/elbv2.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
request "github.com/aws/aws-sdk-go/aws/request"
elbv2 "github.com/aws/aws-sdk-go/service/elbv2"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// DescribeRules mocks base method.
func (m *Mockapi) DescribeRules(arg0 *elbv2.DescribeRulesInput) (*elbv2.DescribeRulesOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeRules", arg0)
ret0, _ := ret[0].(*elbv2.DescribeRulesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeRules indicates an expected call of DescribeRules.
func (mr *MockapiMockRecorder) DescribeRules(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRules", reflect.TypeOf((*Mockapi)(nil).DescribeRules), arg0)
}
// DescribeRulesWithContext mocks base method.
func (m *Mockapi) DescribeRulesWithContext(arg0 context.Context, arg1 *elbv2.DescribeRulesInput, arg2 ...request.Option) (*elbv2.DescribeRulesOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DescribeRulesWithContext", varargs...)
ret0, _ := ret[0].(*elbv2.DescribeRulesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeRulesWithContext indicates an expected call of DescribeRulesWithContext.
func (mr *MockapiMockRecorder) DescribeRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesWithContext", reflect.TypeOf((*Mockapi)(nil).DescribeRulesWithContext), varargs...)
}
// DescribeTargetHealth mocks base method.
func (m *Mockapi) DescribeTargetHealth(arg0 *elbv2.DescribeTargetHealthInput) (*elbv2.DescribeTargetHealthOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeTargetHealth", arg0)
ret0, _ := ret[0].(*elbv2.DescribeTargetHealthOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeTargetHealth indicates an expected call of DescribeTargetHealth.
func (mr *MockapiMockRecorder) DescribeTargetHealth(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealth", reflect.TypeOf((*Mockapi)(nil).DescribeTargetHealth), arg0)
}
| 88 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package iam provides a client to make API requests to the AWS Identity and Access Management service.
package iam
import (
"fmt"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/iam"
)
const (
ecsServiceName = "ecs.amazonaws.com"
)
type api interface {
ListRoleTags(input *iam.ListRoleTagsInput) (*iam.ListRoleTagsOutput, error)
DeleteRolePolicy(input *iam.DeleteRolePolicyInput) (*iam.DeleteRolePolicyOutput, error)
ListRolePolicies(input *iam.ListRolePoliciesInput) (*iam.ListRolePoliciesOutput, error)
DeleteRole(input *iam.DeleteRoleInput) (*iam.DeleteRoleOutput, error)
CreateServiceLinkedRole(input *iam.CreateServiceLinkedRoleInput) (*iam.CreateServiceLinkedRoleOutput, error)
ListPolicies(input *iam.ListPoliciesInput) (*iam.ListPoliciesOutput, error)
}
// IAM wraps the AWS SDK's IAM client.
type IAM struct {
client api
}
// New returns an IAM client configured against the input session.
func New(s *session.Session) *IAM {
return &IAM{
client: iam.New(s),
}
}
// ListRoleTags gathers all the tags associated with an IAM role.
func (c *IAM) ListRoleTags(roleName string) (map[string]string, error) {
tags := make(map[string]string)
var marker *string
for {
out, err := c.client.ListRoleTags(&iam.ListRoleTagsInput{
RoleName: aws.String(roleName),
Marker: marker,
})
if err != nil {
return nil, fmt.Errorf("list role tags for role %s and marker %v: %w", roleName, marker, err)
}
for _, tag := range out.Tags {
tags[aws.StringValue(tag.Key)] = aws.StringValue(tag.Value)
}
if !aws.BoolValue(out.IsTruncated) {
return tags, nil
}
marker = out.Marker
}
}
// DeleteRole deletes an IAM role based on its ARN.
// If the role does not exist it returns nil.
func (c *IAM) DeleteRole(roleNameOrARN string) error {
roleName := roleNameOrARN
if parsed, err := arn.Parse(roleNameOrARN); err == nil {
// The parameter is an ARN instead!
// Sample ARN format: arn:aws:iam::1111:role/phonetool-test-CFNExecutionRole
roleName = strings.TrimPrefix(parsed.Resource, "role/")
}
if err := c.deleteRolePolicies(roleName); err != nil {
return err
}
if _, err := c.client.DeleteRole(&iam.DeleteRoleInput{
RoleName: aws.String(roleName),
}); err != nil {
if isNotExistErr(err) {
// The role does not exist, exit successfully.
return nil
}
return fmt.Errorf("delete role named %s: %w", roleName, err)
}
return nil
}
// CreateECSServiceLinkedRole creates a Service-Linked Role for Amazon ECS.
// This role is necessary so that Amazon ECS can call AWS APIs.
// https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html
func (c *IAM) CreateECSServiceLinkedRole() error {
if _, err := c.client.CreateServiceLinkedRole(&iam.CreateServiceLinkedRoleInput{
AWSServiceName: aws.String(ecsServiceName),
}); err != nil {
return fmt.Errorf("create service linked role for %s: %w", ecsServiceName, err)
}
return nil
}
// ListPolicyNames returns a list of local policy names.
func (c *IAM) ListPolicyNames() ([]string, error) {
var policies []*iam.Policy
var marker *string
for {
output, err := c.client.ListPolicies(&iam.ListPoliciesInput{
Marker: marker,
Scope: aws.String("Local"),
PolicyUsageFilter: aws.String("PermissionsBoundary"),
})
if err != nil {
return nil, fmt.Errorf("list IAM policies: %w", err)
}
policies = append(policies, output.Policies...)
if !aws.BoolValue(output.IsTruncated) {
break
}
marker = output.Marker
}
var policyNames = make([]string, len(policies))
for i, policy := range policies {
policyNames[i] = aws.StringValue(policy.PolicyName)
}
return policyNames, nil
}
func (c *IAM) deleteRolePolicies(roleName string) error {
policyNames, err := c.listRolePolicyNames(roleName)
if err != nil {
return err
}
for _, policyName := range policyNames {
if _, err := c.client.DeleteRolePolicy(&iam.DeleteRolePolicyInput{
PolicyName: policyName,
RoleName: aws.String(roleName),
}); err != nil {
return fmt.Errorf("delete policy named %s in role %s: %w", aws.StringValue(policyName), roleName, err)
}
}
return nil
}
func (c *IAM) listRolePolicyNames(roleName string) ([]*string, error) {
var policyNames []*string
var marker *string
for {
out, err := c.client.ListRolePolicies(&iam.ListRolePoliciesInput{
Marker: marker,
RoleName: aws.String(roleName),
})
if err != nil {
if isNotExistErr(err) {
return nil, nil
}
return nil, fmt.Errorf("list role policies for role %s: %v", roleName, err)
}
policyNames = append(policyNames, out.PolicyNames...)
if !aws.BoolValue(out.IsTruncated) {
return policyNames, nil
}
marker = out.Marker
}
}
func isNotExistErr(err error) bool {
aerr, ok := err.(awserr.Error)
if !ok {
return false
}
switch aerr.Code() {
case iam.ErrCodeNoSuchEntityException:
return true
default:
return false
}
}
| 178 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package iam
import (
"errors"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/aws/copilot-cli/internal/pkg/aws/iam/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestIAM_ListRoleTags(t *testing.T) {
testCases := map[string]struct {
inRoleName string
inClient func(ctrl *gomock.Controller) *mocks.Mockapi
wantedTags map[string]string
wantedErr error
}{
"wraps unexpected error when cannot list role tags": {
inRoleName: "read-only",
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().ListRoleTags(gomock.Any()).Return(nil, errors.New("some error"))
return m
},
wantedErr: errors.New("list role tags for role read-only and marker <nil>: some error"),
},
"collects multiple tags until the response is no longer truncated": {
inRoleName: "read-only",
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
gomock.InOrder(
m.EXPECT().ListRoleTags(&iam.ListRoleTagsInput{
RoleName: aws.String("read-only"),
}).Return(&iam.ListRoleTagsOutput{
IsTruncated: aws.Bool(true),
Marker: aws.String("marker"),
Tags: []*iam.Tag{
{
Key: aws.String("copilot-application"),
Value: aws.String("hello"),
},
},
}, nil),
m.EXPECT().ListRoleTags(&iam.ListRoleTagsInput{
RoleName: aws.String("read-only"),
Marker: aws.String("marker"),
}).Return(&iam.ListRoleTagsOutput{
Tags: []*iam.Tag{
{
Key: aws.String("copilot-environment"),
Value: aws.String("world"),
},
},
}, nil),
)
return m
},
wantedTags: map[string]string{
"copilot-application": "hello",
"copilot-environment": "world",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
iam := &IAM{
client: tc.inClient(ctrl),
}
// WHEN
actual, err := iam.ListRoleTags(tc.inRoleName)
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedTags, actual)
}
})
}
}
func TestIAM_DeleteRole(t *testing.T) {
testCases := map[string]struct {
inRoleNameOrARN string
inClient func(ctrl *gomock.Controller) *mocks.Mockapi
wantedErr error
}{
"wraps error when cannot list role policies and ensure role name is used if the input is not an ARN": {
inRoleNameOrARN: "phonetool-test-CFNExecutionRole",
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
ListRolePolicies(&iam.ListRolePoliciesInput{
RoleName: aws.String("phonetool-test-CFNExecutionRole"),
}).
Return(nil, errors.New("some error"))
m.EXPECT().DeleteRolePolicy(gomock.Any()).Times(0)
return m
},
wantedErr: errors.New("list role policies for role phonetool-test-CFNExecutionRole: some error"),
},
"wraps error when cannot delete role policies": {
inRoleNameOrARN: "arn:aws:iam::1111:role/phonetool-test-CFNExecutionRole",
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
ListRolePolicies(gomock.Any()).
Return(&iam.ListRolePoliciesOutput{
PolicyNames: []*string{aws.String("policy1")},
}, nil)
m.EXPECT().DeleteRolePolicy(gomock.Any()).Return(nil, errors.New("some error"))
return m
},
wantedErr: errors.New("delete policy named policy1 in role phonetool-test-CFNExecutionRole: some error"),
},
"wraps error when cannot delete role": {
inRoleNameOrARN: "arn:aws:iam::1111:role/phonetool-test-CFNExecutionRole",
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
ListRolePolicies(gomock.Any()).
Return(&iam.ListRolePoliciesOutput{}, nil)
m.EXPECT().DeleteRole(gomock.Any()).Return(nil, errors.New("some error"))
return m
},
wantedErr: errors.New("delete role named phonetool-test-CFNExecutionRole: some error"),
},
"returns nil if the role does not exist": {
inRoleNameOrARN: "arn:aws:iam::1111:role/phonetool-test-CFNExecutionRole",
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
ListRolePolicies(gomock.Any()).
Return(nil, awserr.New(iam.ErrCodeNoSuchEntityException, "does not exist", nil))
m.EXPECT().DeleteRole(gomock.Any()).Return(nil, awserr.New(iam.ErrCodeNoSuchEntityException, "does not exist", nil))
return m
},
},
"returns nil when the role policies and the role can be deleted successfully": {
inRoleNameOrARN: "arn:aws:iam::1111:role/phonetool-test-CFNExecutionRole",
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
ListRolePolicies(&iam.ListRolePoliciesInput{
RoleName: aws.String("phonetool-test-CFNExecutionRole"),
}).
Return(&iam.ListRolePoliciesOutput{
PolicyNames: []*string{aws.String("policy1"), aws.String("policy2")},
}, nil)
gomock.InOrder(
m.EXPECT().DeleteRolePolicy(&iam.DeleteRolePolicyInput{
PolicyName: aws.String("policy1"),
RoleName: aws.String("phonetool-test-CFNExecutionRole"),
}).Return(nil, nil),
m.EXPECT().DeleteRolePolicy(&iam.DeleteRolePolicyInput{
PolicyName: aws.String("policy2"),
RoleName: aws.String("phonetool-test-CFNExecutionRole"),
}).Return(nil, nil),
)
m.EXPECT().DeleteRole(&iam.DeleteRoleInput{
RoleName: aws.String("phonetool-test-CFNExecutionRole"),
}).Return(nil, nil)
return m
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
iam := &IAM{
client: tc.inClient(ctrl),
}
// WHEN
err := iam.DeleteRole(tc.inRoleNameOrARN)
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestIAM_CreateECSServiceLinkedRole(t *testing.T) {
testCases := map[string]struct {
inClient func(ctrl *gomock.Controller) *mocks.Mockapi
wantedErr error
}{
"wraps error on failure": {
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
CreateServiceLinkedRole(gomock.Any()).
Return(nil, errors.New("some error"))
return m
},
wantedErr: errors.New("create service linked role for ecs.amazonaws.com: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
iam := &IAM{
client: tc.inClient(ctrl),
}
// WHEN
err := iam.CreateECSServiceLinkedRole()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestIAM_ListPolicies(t *testing.T) {
testCases := map[string]struct {
inClient func(ctrl *gomock.Controller) *mocks.Mockapi
wantedPolicies []string
wantedErr error
}{
"wraps error on failure": {
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
ListPolicies(gomock.Any()).
Return(nil, errors.New("some error"))
return m
},
wantedErr: errors.New("list IAM policies: some error"),
},
"returns list of policy names": {
inClient: func(ctrl *gomock.Controller) *mocks.Mockapi {
m := mocks.NewMockapi(ctrl)
m.EXPECT().
ListPolicies(gomock.Any()).
Return(&iam.ListPoliciesOutput{
Policies: []*iam.Policy{
{
PolicyName: aws.String("myFirstPolicyName"),
},
{
PolicyName: aws.String("mySecondPolicyName"),
},
},
}, nil)
return m
},
wantedPolicies: []string{"myFirstPolicyName", "mySecondPolicyName"},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
iam := &IAM{
client: tc.inClient(ctrl),
}
// WHEN
output, err := iam.ListPolicyNames()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedPolicies, output)
}
})
}
}
| 306 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/iam/iam.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
iam "github.com/aws/aws-sdk-go/service/iam"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// CreateServiceLinkedRole mocks base method.
func (m *Mockapi) CreateServiceLinkedRole(input *iam.CreateServiceLinkedRoleInput) (*iam.CreateServiceLinkedRoleOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateServiceLinkedRole", input)
ret0, _ := ret[0].(*iam.CreateServiceLinkedRoleOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateServiceLinkedRole indicates an expected call of CreateServiceLinkedRole.
func (mr *MockapiMockRecorder) CreateServiceLinkedRole(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceLinkedRole", reflect.TypeOf((*Mockapi)(nil).CreateServiceLinkedRole), input)
}
// DeleteRole mocks base method.
func (m *Mockapi) DeleteRole(input *iam.DeleteRoleInput) (*iam.DeleteRoleOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteRole", input)
ret0, _ := ret[0].(*iam.DeleteRoleOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeleteRole indicates an expected call of DeleteRole.
func (mr *MockapiMockRecorder) DeleteRole(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*Mockapi)(nil).DeleteRole), input)
}
// DeleteRolePolicy mocks base method.
func (m *Mockapi) DeleteRolePolicy(input *iam.DeleteRolePolicyInput) (*iam.DeleteRolePolicyOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteRolePolicy", input)
ret0, _ := ret[0].(*iam.DeleteRolePolicyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeleteRolePolicy indicates an expected call of DeleteRolePolicy.
func (mr *MockapiMockRecorder) DeleteRolePolicy(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolePolicy", reflect.TypeOf((*Mockapi)(nil).DeleteRolePolicy), input)
}
// ListPolicies mocks base method.
func (m *Mockapi) ListPolicies(input *iam.ListPoliciesInput) (*iam.ListPoliciesOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListPolicies", input)
ret0, _ := ret[0].(*iam.ListPoliciesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListPolicies indicates an expected call of ListPolicies.
func (mr *MockapiMockRecorder) ListPolicies(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPolicies", reflect.TypeOf((*Mockapi)(nil).ListPolicies), input)
}
// ListRolePolicies mocks base method.
func (m *Mockapi) ListRolePolicies(input *iam.ListRolePoliciesInput) (*iam.ListRolePoliciesOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListRolePolicies", input)
ret0, _ := ret[0].(*iam.ListRolePoliciesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListRolePolicies indicates an expected call of ListRolePolicies.
func (mr *MockapiMockRecorder) ListRolePolicies(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolePolicies", reflect.TypeOf((*Mockapi)(nil).ListRolePolicies), input)
}
// ListRoleTags mocks base method.
func (m *Mockapi) ListRoleTags(input *iam.ListRoleTagsInput) (*iam.ListRoleTagsOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListRoleTags", input)
ret0, _ := ret[0].(*iam.ListRoleTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListRoleTags indicates an expected call of ListRoleTags.
func (mr *MockapiMockRecorder) ListRoleTags(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRoleTags", reflect.TypeOf((*Mockapi)(nil).ListRoleTags), input)
}
| 126 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package identity provides a client to make API requests to AWS Security Token Service.
package identity
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/sts"
)
type api interface {
GetCallerIdentity(input *sts.GetCallerIdentityInput) (*sts.GetCallerIdentityOutput, error)
}
// STS wraps the internal sts client.
type STS struct {
client api
}
// New returns a STS configured with the input session.
func New(s *session.Session) STS {
return STS{
client: sts.New(s),
}
}
// Caller holds information about a calling entity.
type Caller struct {
RootUserARN string
Account string
UserID string
}
// Get returns the Caller associated with the Client's session.
func (s STS) Get() (Caller, error) {
out, err := s.client.GetCallerIdentity(&sts.GetCallerIdentityInput{})
if err != nil {
return Caller{}, fmt.Errorf("get caller identity: %w", err)
}
parsedARN, err := arn.Parse(aws.StringValue(out.Arn))
if err != nil {
return Caller{}, fmt.Errorf("parse caller arn: %w", err)
}
return Caller{
RootUserARN: fmt.Sprintf("arn:%s:iam::%s:root", parsedARN.Partition, aws.StringValue(out.Account)),
Account: aws.StringValue(out.Account),
UserID: aws.StringValue(out.UserId),
}, nil
}
| 56 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package identity
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/service/sts"
"github.com/aws/copilot-cli/internal/pkg/aws/identity/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestIdentity_Get(t *testing.T) {
mockError := errors.New("error")
mockBadARN := "mockArn"
mockARN := "arn:aws:iam::1111:role/phonetool-test-CFNExecutionRole"
mockChinaARN := "arn:aws-cn:iam::1111:role/phonetool-test-CFNExecutionRole"
mockAccount := "123412341234"
mockUserID := "mockUserID"
testCases := map[string]struct {
callMock func(m *mocks.Mockapi)
wantIdentity Caller
wantErr error
}{
"should return wrapped error given error from STS GetCallerIdentity": {
callMock: func(m *mocks.Mockapi) {
m.EXPECT().GetCallerIdentity(gomock.Any()).Return(nil, mockError)
},
wantErr: fmt.Errorf("get caller identity: %w", mockError),
},
"should return wrapped error if cannot parse the account arn": {
callMock: func(m *mocks.Mockapi) {
m.EXPECT().GetCallerIdentity(gomock.Any()).Return(&sts.GetCallerIdentityOutput{
Account: &mockAccount,
Arn: &mockBadARN,
UserId: &mockUserID,
}, nil)
},
wantErr: fmt.Errorf("parse caller arn: arn: invalid prefix"),
},
"should return Identity": {
callMock: func(m *mocks.Mockapi) {
m.EXPECT().GetCallerIdentity(gomock.Any()).Return(&sts.GetCallerIdentityOutput{
Account: &mockAccount,
Arn: &mockARN,
UserId: &mockUserID,
}, nil)
},
wantIdentity: Caller{
Account: mockAccount,
RootUserARN: fmt.Sprintf("arn:aws:iam::%s:root", mockAccount),
UserID: mockUserID,
},
},
"should return Identity in non standard partition": {
callMock: func(m *mocks.Mockapi) {
m.EXPECT().GetCallerIdentity(gomock.Any()).Return(&sts.GetCallerIdentityOutput{
Account: &mockAccount,
Arn: &mockChinaARN,
UserId: &mockUserID,
}, nil)
},
wantIdentity: Caller{
Account: mockAccount,
RootUserARN: fmt.Sprintf("arn:aws-cn:iam::%s:root", mockAccount),
UserID: mockUserID,
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockClient := mocks.NewMockapi(ctrl)
sts := STS{
client: mockClient,
}
tc.callMock(mockClient)
gotIdentity, gotErr := sts.Get()
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
} else {
require.NoError(t, gotErr)
require.Equal(t, tc.wantIdentity, gotIdentity)
}
})
}
}
| 101 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/identity/identity.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
sts "github.com/aws/aws-sdk-go/service/sts"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// GetCallerIdentity mocks base method.
func (m *Mockapi) GetCallerIdentity(input *sts.GetCallerIdentityInput) (*sts.GetCallerIdentityOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetCallerIdentity", input)
ret0, _ := ret[0].(*sts.GetCallerIdentityOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetCallerIdentity indicates an expected call of GetCallerIdentity.
func (mr *MockapiMockRecorder) GetCallerIdentity(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentity", reflect.TypeOf((*Mockapi)(nil).GetCallerIdentity), input)
}
| 51 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package partitions
import (
"fmt"
"github.com/aws/aws-sdk-go/aws/endpoints"
)
// Region is an AWS region ID.
type Region string
// Partition returns the first partition which includes the region passed in, from a list of the partitions the SDK is bundled with.
func (r Region) Partition() (endpoints.Partition, error) {
partition, ok := endpoints.PartitionForRegion(endpoints.DefaultPartitions(), string(r))
if !ok {
return endpoints.Partition{}, fmt.Errorf("find the partition for region %s", string(r))
}
return partition, nil
}
// IsAvailableInRegion returns true if the service ID is available in the given region.
func IsAvailableInRegion(sID string, region string) (bool, error) {
partition, err := Region(region).Partition()
if err != nil {
return false, err
}
regions, partitionOrServiceExists := endpoints.RegionsForService(endpoints.DefaultPartitions(), partition.ID(), sID)
if !partitionOrServiceExists {
return false, nil
}
_, existInRegion := regions[region]
return existInRegion, nil
}
| 37 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package partitions
import (
"errors"
"github.com/aws/copilot-cli/internal/pkg/aws/apprunner"
"github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"testing"
"github.com/stretchr/testify/require"
)
func TestRegion_Partition(t *testing.T) {
testCases := map[string]struct {
region string
wantedErr error
}{
"error finding the partition": {
region: "weird region",
wantedErr: errors.New("find the partition for region weird region"),
},
"success": {
region: "us-west-2",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
_, err := Region(tc.region).Partition()
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestRegion_IsAvailableInRegion(t *testing.T) {
testCases := map[string]struct {
sID string
region string
want bool
wantedErr error
}{
"ecs service exist in the given region": {
region: "us-west-2",
sID: ecs.EndpointsID,
want: true,
},
"ecs service does not exist in the given region": {
region: "us-west-3",
sID: ecs.EndpointsID,
want: false,
},
"apprunner service exist in the given region": {
region: "us-west-2",
sID: apprunner.EndpointsID,
want: true,
},
"apprunner service does not exist in the given region": {
region: "us-west-1",
sID: apprunner.EndpointsID,
want: false,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got, err := IsAvailableInRegion(tc.sID, tc.region)
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.want, got)
}
})
}
}
| 82 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package profile provides functionality to parse AWS named profiles.
package profile
import (
"fmt"
"os"
"path/filepath"
"strings"
"github.com/aws/copilot-cli/internal/pkg/ini"
)
const (
awsCredentialsDir = ".aws"
awsConfigFileName = "config"
)
type sectionsGetter interface {
Sections() []string
}
// Config represents the local AWS config file.
type Config struct {
// f is the ~/.aws/config INI file.
f sectionsGetter
}
// NewConfig returns a new parsed Config object from $HOME/.aws/config.
func NewConfig() (*Config, error) {
cfgPath, err := cfgPath()
if err != nil {
return nil, fmt.Errorf("get the path of configuration file: %w", err)
}
cfg, err := ini.New(cfgPath)
if err != nil {
return nil, fmt.Errorf("read AWS config file %s, you might need to run %s first: %w", cfgPath, "aws configure", err)
}
return &Config{
f: cfg,
}, nil
}
// Names returns a list of profile names available in the user's config file.
// An error is returned if the config file can't be found or parsed.
func (c *Config) Names() []string {
var profiles []string
for _, section := range c.f.Sections() {
// Named profiles created with "aws configure" are formatted as "[profile test]".
profiles = append(profiles, strings.TrimSpace(strings.TrimPrefix(section, "profile")))
}
return profiles
}
func cfgPath() (string, error) {
if os.Getenv("AWS_CONFIG_FILE") != "" {
return os.Getenv("AWS_CONFIG_FILE"), nil
}
homeDir, err := os.UserHomeDir()
if err != nil {
return "", fmt.Errorf("get home directory: %w", err)
}
return filepath.Join(homeDir, awsCredentialsDir, awsConfigFileName), nil
}
| 70 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package profile
import (
"testing"
"github.com/stretchr/testify/require"
)
type mockINI struct {
sections []string
}
func (m *mockINI) Sections() []string {
return m.sections
}
func TestConfig_Names(t *testing.T) {
testCases := map[string]struct {
ini *mockINI
wantedNames []string
}{
"return nil if there are no sections in the file": {
ini: &mockINI{
sections: nil,
},
},
"trim 'profile' from profile names": {
ini: &mockINI{
sections: []string{
"profile profile1",
"test",
"default",
},
},
wantedNames: []string{
"profile1",
"test",
"default",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
conf := &Config{
f: tc.ini,
}
// WHEN
profiles := conf.Names()
// THEN
require.Equal(t, tc.wantedNames, profiles)
})
}
}
| 63 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package resourcegroups provides a client to make API requests to AWS Resource Groups
package resourcegroups
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
)
const (
// ResourceTypeStateMachine is the resource type for the state machine of a job.
ResourceTypeStateMachine = "states:stateMachine"
)
type api interface {
GetResources(input *resourcegroupstaggingapi.GetResourcesInput) (*resourcegroupstaggingapi.GetResourcesOutput, error)
}
// ResourceGroups wraps an AWS ResourceGroups client.
type ResourceGroups struct {
client api
}
// Resource contains the ARN and the tags of the resource.
type Resource struct {
ARN string
Tags map[string]string
}
// New returns a ResourceGroup struct configured against the input session.
func New(s *session.Session) *ResourceGroups {
return &ResourceGroups{
client: resourcegroupstaggingapi.New(s),
}
}
// GetResourcesByTags gets tag set and ARN for the resource with input resource type and tags.
func (rg *ResourceGroups) GetResourcesByTags(resourceType string, tags map[string]string) ([]*Resource, error) {
var resources []*Resource
var tagFilter []*resourcegroupstaggingapi.TagFilter
for k, v := range tags {
var values []*string
if v != "" {
values = aws.StringSlice([]string{v})
}
tagFilter = append(tagFilter, &resourcegroupstaggingapi.TagFilter{
Key: aws.String(k),
Values: values,
})
}
resourceResp := &resourcegroupstaggingapi.GetResourcesOutput{}
for {
var err error
resourceResp, err = rg.client.GetResources(&resourcegroupstaggingapi.GetResourcesInput{
PaginationToken: resourceResp.PaginationToken,
ResourceTypeFilters: aws.StringSlice([]string{resourceType}),
TagFilters: tagFilter,
})
if err != nil {
return nil, fmt.Errorf("get resource: %w", err)
}
for _, resourceTagMapping := range resourceResp.ResourceTagMappingList {
tags := make(map[string]string)
for _, tag := range resourceTagMapping.Tags {
if tag.Key == nil {
continue
}
tags[*tag.Key] = aws.StringValue(tag.Value)
}
resources = append(resources, &Resource{
ARN: aws.StringValue(resourceTagMapping.ResourceARN),
Tags: tags,
})
}
// usually pagination token is "" when it doesn't have any next page. However, since it
// is type *string, it is safer for us to check nil value for it as well.
if token := resourceResp.PaginationToken; aws.StringValue(token) == "" {
break
}
}
return resources, nil
}
| 90 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package resourcegroups
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
rgapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
"github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
var testTags = map[string]string{
"copilot-environment": "test",
}
const (
testResourceType = "cloudwatch:alarm"
testArn = "arn:aws:cloudwatch:us-west-2:1234567890:alarm:SDc-ReadCapacityUnitsLimit-BasicAlarm"
mockArn1 = "arn:aws:cloudwatch:us-west-2:1234567890:alarm:mockAlarmName1"
mockArn2 = "arn:aws:cloudwatch:us-west-2:1234567890:alarm:mockAlarmName2"
)
func TestResourceGroups_GetResourcesByTags(t *testing.T) {
mockRequest := &rgapi.GetResourcesInput{
PaginationToken: nil,
ResourceTypeFilters: aws.StringSlice([]string{testResourceType}),
TagFilters: []*rgapi.TagFilter{
{
Key: aws.String("copilot-environment"),
Values: aws.StringSlice([]string{"test"}),
},
},
}
mockResponse := &rgapi.GetResourcesOutput{
ResourceTagMappingList: []*rgapi.ResourceTagMapping{
{
ResourceARN: aws.String(testArn),
Tags: []*rgapi.Tag{
{
Key: aws.String("copilot-environment"),
Value: aws.String("test"),
},
},
},
},
}
mockError := errors.New("some error")
testCases := map[string]struct {
inTags map[string]string
inResourceType string
setupMocks func(m *mocks.Mockapi)
expectedOut []*Resource
expectedErr error
}{
"returns list of arns": {
inTags: testTags,
inResourceType: testResourceType,
setupMocks: func(m *mocks.Mockapi) {
m.EXPECT().GetResources(mockRequest).Return(mockResponse, nil)
},
expectedOut: []*Resource{
{
ARN: testArn,
Tags: testTags,
},
},
expectedErr: nil,
},
"wraps error from API call": {
inTags: testTags,
inResourceType: testResourceType,
setupMocks: func(m *mocks.Mockapi) {
m.EXPECT().GetResources(mockRequest).Return(nil, mockError)
},
expectedOut: nil,
expectedErr: fmt.Errorf("get resource: some error"),
},
"success with pagination": {
inTags: testTags,
inResourceType: testResourceType,
setupMocks: func(m *mocks.Mockapi) {
gomock.InOrder(
m.EXPECT().GetResources(mockRequest).Return(&rgapi.GetResourcesOutput{
PaginationToken: aws.String("mockNextToken"),
ResourceTagMappingList: []*rgapi.ResourceTagMapping{
{
ResourceARN: aws.String(mockArn1),
Tags: []*rgapi.Tag{{Key: aws.String("copilot-environment"), Value: aws.String("test")}},
},
},
}, nil),
m.EXPECT().GetResources(&rgapi.GetResourcesInput{
PaginationToken: aws.String("mockNextToken"),
ResourceTypeFilters: aws.StringSlice([]string{testResourceType}),
TagFilters: []*rgapi.TagFilter{
{
Key: aws.String("copilot-environment"),
Values: aws.StringSlice([]string{"test"}),
},
},
}).Return(&rgapi.GetResourcesOutput{
PaginationToken: nil,
ResourceTagMappingList: []*rgapi.ResourceTagMapping{
{
ResourceARN: aws.String(mockArn2),
Tags: []*rgapi.Tag{{Key: aws.String("copilot-environment"), Value: aws.String("test")}},
},
},
}, nil),
)
},
expectedOut: []*Resource{
{
ARN: mockArn1,
Tags: testTags,
},
{
ARN: mockArn2,
Tags: testTags,
},
},
expectedErr: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockClient := mocks.NewMockapi(ctrl)
rg := &ResourceGroups{client: mockClient}
// WHEN
tc.setupMocks(mockClient)
actualOut, actualErr := rg.GetResourcesByTags(tc.inResourceType, tc.inTags)
// THEN
if actualErr != nil {
require.EqualError(t, tc.expectedErr, actualErr.Error())
} else {
require.Equal(t, tc.expectedOut, actualOut)
}
})
}
}
| 156 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/resourcegroups/resourcegroups.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
resourcegroupstaggingapi "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// GetResources mocks base method.
func (m *Mockapi) GetResources(input *resourcegroupstaggingapi.GetResourcesInput) (*resourcegroupstaggingapi.GetResourcesOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetResources", input)
ret0, _ := ret[0].(*resourcegroupstaggingapi.GetResourcesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetResources indicates an expected call of GetResources.
func (mr *MockapiMockRecorder) GetResources(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResources", reflect.TypeOf((*Mockapi)(nil).GetResources), input)
}
| 51 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package route53
import (
"fmt"
"github.com/dustin/go-humanize/english"
)
// ErrDomainHostedZoneNotFound occurs when the domain hosted zone is not found.
type ErrDomainHostedZoneNotFound struct {
domainName string
}
func (err *ErrDomainHostedZoneNotFound) Error() string {
return fmt.Sprintf("hosted zone is not found for domain %s", err.domainName)
}
// ErrDomainNotFound occurs when the domain is not found in the account.
type ErrDomainNotFound struct {
domainName string
}
func (err *ErrDomainNotFound) Error() string {
return fmt.Sprintf("domain %s is not found in the account", err.domainName)
}
// ErrUnmatchedNSRecords occurs when the NS records associated with the domain do not match the name server records
// in the route53 hosted zone.
type ErrUnmatchedNSRecords struct {
domainName string
hostedZoneID string
r53Records []string
dnsRecords []string
}
func (err *ErrUnmatchedNSRecords) Error() string {
return fmt.Sprintf("name server records for %q do not match records for hosted zone %q", err.domainName, err.hostedZoneID)
}
// RecommendActions implements the main.actionRecommender interface.
func (err *ErrUnmatchedNSRecords) RecommendActions() string {
return fmt.Sprintf(`Domain name %q has the following name server records: %s
Whereas the hosted zone ID %q for the domain has: %s
Copilot will proceed, but to use Route 53 as the DNS service,
please ensure the name server records are mapped correctly:
- https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/migrate-dns-domain-in-use.html#migrate-dns-change-name-servers-with-provider`,
err.domainName, english.WordSeries(err.dnsRecords, "and"),
err.hostedZoneID, english.WordSeries(err.r53Records, "and"))
}
| 53 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package route53
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestErrUnmatchedNSRecords_Error(t *testing.T) {
err := &ErrUnmatchedNSRecords{
domainName: "amazon.com",
hostedZoneID: "Z0698117FUWMJ87C39TF",
r53Records: []string{"ns-1119.awsdns-11.org", "ns-501.awsdns-62.com", "ns-955.awsdns-55.net", "ns-2022.awsdns-60.co.uk"},
dnsRecords: []string{"dns-ns2.amazon.com.", "dns-ns1.amazon.com."},
}
require.EqualError(t, err, `name server records for "amazon.com" do not match records for hosted zone "Z0698117FUWMJ87C39TF"`)
}
func TestErrUnmatchedNSRecords_RecommendActions(t *testing.T) {
err := &ErrUnmatchedNSRecords{
domainName: "amazon.com",
hostedZoneID: "Z0698117FUWMJ87C39TF",
r53Records: []string{"ns-1119.awsdns-11.org", "ns-501.awsdns-62.com", "ns-955.awsdns-55.net", "ns-2022.awsdns-60.co.uk"},
dnsRecords: []string{"dns-ns2.amazon.com.", "dns-ns1.amazon.com."},
}
require.Equal(t,
`Domain name "amazon.com" has the following name server records: dns-ns2.amazon.com. and dns-ns1.amazon.com.
Whereas the hosted zone ID "Z0698117FUWMJ87C39TF" for the domain has: ns-1119.awsdns-11.org, ns-501.awsdns-62.com, ns-955.awsdns-55.net and ns-2022.awsdns-60.co.uk
Copilot will proceed, but to use Route 53 as the DNS service,
please ensure the name server records are mapped correctly:
- https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/migrate-dns-domain-in-use.html#migrate-dns-change-name-servers-with-provider`,
err.RecommendActions())
}
| 39 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package route53 provides functionality to manipulate route53 primitives.
package route53
import (
"context"
"fmt"
"net"
"strings"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/route53"
)
const (
// See https://docs.aws.amazon.com/general/latest/gr/r53.html
// For Route53 API endpoint, "Route 53 in AWS Regions other than the Beijing and Ningxia Regions: specify us-east-1 as the Region."
route53Region = "us-east-1"
)
type api interface {
ListHostedZonesByName(*route53.ListHostedZonesByNameInput) (*route53.ListHostedZonesByNameOutput, error)
ListResourceRecordSets(*route53.ListResourceRecordSetsInput) (*route53.ListResourceRecordSetsOutput, error)
}
type nameserverResolver interface {
LookupNS(ctx context.Context, name string) ([]*net.NS, error)
}
// Route53 wraps an Route53 client.
type Route53 struct {
client api
dns nameserverResolver
hostedZoneIDFor map[string]string
}
// New returns a Route53 struct configured against the input session.
func New(s *session.Session) *Route53 {
return &Route53{
client: route53.New(s, aws.NewConfig().WithRegion(route53Region)),
dns: new(net.Resolver),
hostedZoneIDFor: make(map[string]string),
}
}
// DomainHostedZoneID returns the Hosted Zone ID of a domain.
func (r53 *Route53) DomainHostedZoneID(domainName string) (string, error) {
if id, ok := r53.hostedZoneIDFor[domainName]; ok {
return id, nil
}
in := &route53.ListHostedZonesByNameInput{DNSName: aws.String(domainName)}
resp, err := r53.client.ListHostedZonesByName(in)
if err != nil {
return "", fmt.Errorf("list hosted zone for %s: %w", domainName, err)
}
for {
hostedZones := filterHostedZones(resp.HostedZones, matchesDomain(domainName))
if len(hostedZones) > 0 {
// return the first match.
id := strings.TrimPrefix(aws.StringValue(hostedZones[0].Id), "/hostedzone/")
r53.hostedZoneIDFor[domainName] = id
return id, nil
}
if !aws.BoolValue(resp.IsTruncated) {
return "", &ErrDomainHostedZoneNotFound{
domainName: domainName,
}
}
in = &route53.ListHostedZonesByNameInput{DNSName: resp.NextDNSName, HostedZoneId: resp.NextHostedZoneId}
resp, err = r53.client.ListHostedZonesByName(in)
if err != nil {
return "", fmt.Errorf("list hosted zone for %s: %w", domainName, err)
}
}
}
// ValidateDomainOwnership returns nil if the NS records associated with the domain name matches the NS records of the
// route53 hosted zone for the domain.
// If there are missing NS records returns ErrUnmatchedNSRecords.
func (r53 *Route53) ValidateDomainOwnership(domainName string) error {
hzID, err := r53.DomainHostedZoneID(domainName)
if err != nil {
return err
}
wanted, err := r53.listHostedZoneNSRecords(domainName, hzID)
if err != nil {
return err
}
actual, err := r53.lookupNSRecords(domainName)
if err != nil {
return err
}
if !isStrictSubset(actual, wanted) {
return &ErrUnmatchedNSRecords{
domainName: domainName,
hostedZoneID: hzID,
r53Records: wanted,
dnsRecords: actual,
}
}
return nil
}
func (r53 *Route53) listHostedZoneNSRecords(domainName, hostedZoneID string) ([]string, error) {
out, err := r53.client.ListResourceRecordSets(&route53.ListResourceRecordSetsInput{
HostedZoneId: aws.String(hostedZoneID),
})
if err != nil {
return nil, fmt.Errorf("list resource record sets for hosted zone ID %q: %w", hostedZoneID, err)
}
var records []string
for _, set := range out.ResourceRecordSets {
if aws.StringValue(set.Type) != "NS" {
continue
}
if name := aws.StringValue(set.Name); !(name == domainName || name == domainName+".") /* filter only for parent domain */ {
continue
}
for _, record := range set.ResourceRecords {
records = append(records, cleanNSRecord(aws.StringValue(record.Value)))
}
}
return records, nil
}
func (r53 *Route53) lookupNSRecords(domainName string) ([]string, error) {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
nameservers, err := r53.dns.LookupNS(ctx, domainName)
if err != nil {
return nil, fmt.Errorf("look up NS records for domain %q: %w", domainName, err)
}
var records []string
for _, nameserver := range nameservers {
records = append(records, cleanNSRecord(nameserver.Host))
}
return records, nil
}
type filterZoneFunc func(*route53.HostedZone) bool
func filterHostedZones(zones []*route53.HostedZone, fn filterZoneFunc) []*route53.HostedZone {
var hostedZones []*route53.HostedZone
for _, hostedZone := range zones {
if fn(hostedZone) {
hostedZones = append(hostedZones, hostedZone)
}
}
return hostedZones
}
func matchesDomain(domain string) filterZoneFunc {
return func(z *route53.HostedZone) bool {
// example.com. should match example.com
return domain == aws.StringValue(z.Name) || domain+"." == aws.StringValue(z.Name)
}
}
func cleanNSRecord(record string) string {
if !strings.HasSuffix(record, ".") {
return record
}
return record[:len(record)-1]
}
func isStrictSubset(subset, superset []string) bool {
if len(subset) > len(superset) {
return false
}
isMember := make(map[string]struct{}, len(superset))
for _, item := range superset {
isMember[item] = struct{}{}
}
for _, item := range subset {
if _, ok := isMember[item]; !ok {
return false
}
}
return true
}
| 193 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package route53
import (
"errors"
"fmt"
"net"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/route53"
"github.com/aws/copilot-cli/internal/pkg/aws/route53/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestRoute53_DomainHostedZoneID(t *testing.T) {
testCases := map[string]struct {
domainName string
mockRoute53Client func(m *mocks.Mockapi)
wantErr error
wantHostedZoneID string
}{
"domain exists": {
domainName: "mockDomain.com",
mockRoute53Client: func(m *mocks.Mockapi) {
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("mockDomain.com"),
}).Return(&route53.ListHostedZonesByNameOutput{
IsTruncated: aws.Bool(false),
HostedZones: []*route53.HostedZone{
{
Name: aws.String("mockDomain.com"),
Id: aws.String("mockID"),
},
},
}, nil)
},
wantHostedZoneID: "mockID",
wantErr: nil,
},
"DNS with subdomain": {
domainName: "mockDomain.subdomain.com",
mockRoute53Client: func(m *mocks.Mockapi) {
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("mockDomain.subdomain.com"),
}).Return(&route53.ListHostedZonesByNameOutput{
IsTruncated: aws.Bool(false),
HostedZones: []*route53.HostedZone{
{
Name: aws.String("mockDomain.subdomain.com."),
Id: aws.String("mockID"),
},
},
}, nil)
},
wantHostedZoneID: "mockID",
wantErr: nil,
},
"domain exists within more than one page": {
domainName: "mockDomain3.com",
mockRoute53Client: func(m *mocks.Mockapi) {
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("mockDomain3.com"),
}).Return(&route53.ListHostedZonesByNameOutput{
IsTruncated: aws.Bool(true),
NextDNSName: aws.String("mockDomain2.com"),
NextHostedZoneId: aws.String("mockID"),
HostedZones: []*route53.HostedZone{
{
Name: aws.String("mockDomain1.com"),
Id: aws.String("mockID1"),
},
},
}, nil)
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("mockDomain2.com"),
HostedZoneId: aws.String("mockID"),
}).Return(&route53.ListHostedZonesByNameOutput{
IsTruncated: aws.Bool(false),
HostedZones: []*route53.HostedZone{
{
Name: aws.String("mockDomain2.com"),
Id: aws.String("mockID2"),
},
{
Name: aws.String("mockDomain3.com"),
Id: aws.String("mockID3"),
},
},
}, nil)
},
wantHostedZoneID: "mockID3",
wantErr: nil,
},
"domain does not exist": {
domainName: "mockDomain4.com",
mockRoute53Client: func(m *mocks.Mockapi) {
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("mockDomain4.com"),
}).Return(&route53.ListHostedZonesByNameOutput{
IsTruncated: aws.Bool(true),
NextDNSName: aws.String("mockDomain2.com"),
NextHostedZoneId: aws.String("mockID"),
HostedZones: []*route53.HostedZone{
{
Name: aws.String("mockDomain1.com"),
},
},
}, nil)
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("mockDomain2.com"),
HostedZoneId: aws.String("mockID"),
}).Return(&route53.ListHostedZonesByNameOutput{
IsTruncated: aws.Bool(false),
HostedZones: []*route53.HostedZone{
{
Name: aws.String("mockDomain2.com"),
},
{
Name: aws.String("mockDomain3.com"),
},
},
}, nil)
},
wantErr: &ErrDomainHostedZoneNotFound{
domainName: "mockDomain4.com",
},
},
"failed to validate if domain exists": {
domainName: "mockDomain.com",
mockRoute53Client: func(m *mocks.Mockapi) {
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("mockDomain.com"),
}).Return(nil, errors.New("some error"))
},
wantErr: fmt.Errorf("list hosted zone for mockDomain.com: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockRoute53Client := mocks.NewMockapi(ctrl)
tc.mockRoute53Client(mockRoute53Client)
service := Route53{
client: mockRoute53Client,
hostedZoneIDFor: make(map[string]string),
}
gotID, gotErr := service.DomainHostedZoneID(tc.domainName)
if gotErr != nil {
require.EqualError(t, tc.wantErr, gotErr.Error())
} else {
require.Equal(t, tc.wantHostedZoneID, gotID)
}
})
}
t.Run("should only call route53 once for the same hosted zone", func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := mocks.NewMockapi(ctrl)
m.EXPECT().ListHostedZonesByName(&route53.ListHostedZonesByNameInput{
DNSName: aws.String("example.com"),
}).Return(&route53.ListHostedZonesByNameOutput{
IsTruncated: aws.Bool(false),
HostedZones: []*route53.HostedZone{
{
Name: aws.String("example.com"),
Id: aws.String("Z0698117FUWMJ87C39TF"),
},
},
}, nil).Times(1)
service := Route53{
client: m,
hostedZoneIDFor: make(map[string]string),
}
// Call once and make the request.
actual, err := service.DomainHostedZoneID("example.com")
require.NoError(t, err)
require.Equal(t, "Z0698117FUWMJ87C39TF", actual)
// Call again and Times should be 1.
actual, err = service.DomainHostedZoneID("example.com")
require.NoError(t, err)
require.Equal(t, "Z0698117FUWMJ87C39TF", actual)
})
}
func TestRoute53_ValidateDomainOwnership(t *testing.T) {
t.Run("should return a wrapped error if resource record sets cannot be retrieved", func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAWS := mocks.NewMockapi(ctrl)
mockAWS.EXPECT().ListResourceRecordSets(gomock.Any()).Return(nil, errors.New("some error"))
r53 := Route53{
client: mockAWS,
hostedZoneIDFor: map[string]string{
"example.com": "Z0698117FUWMJ87C39TF",
},
}
// WHEN
err := r53.ValidateDomainOwnership("example.com")
// THEN
require.EqualError(t, err, `list resource record sets for hosted zone ID "Z0698117FUWMJ87C39TF": some error`)
})
t.Run("should return a wrapped error if the DNS look up for name server records fails", func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAWS := mocks.NewMockapi(ctrl)
mockAWS.EXPECT().ListResourceRecordSets(gomock.Any()).Return(&route53.ListResourceRecordSetsOutput{}, nil)
mockResolver := mocks.NewMocknameserverResolver(ctrl)
mockResolver.EXPECT().LookupNS(gomock.Any(), gomock.Any()).Return(nil, errors.New("some error"))
r53 := Route53{
client: mockAWS,
dns: mockResolver,
hostedZoneIDFor: map[string]string{
"example.com": "Z0698117FUWMJ87C39TF",
},
}
// WHEN
err := r53.ValidateDomainOwnership("example.com")
// THEN
require.EqualError(t, err, `look up NS records for domain "example.com": some error`)
})
t.Run("should return ErrUnmatchedNSRecords if the records are not equal", func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAWS := mocks.NewMockapi(ctrl)
mockAWS.EXPECT().ListResourceRecordSets(gomock.Any()).Return(&route53.ListResourceRecordSetsOutput{
ResourceRecordSets: []*route53.ResourceRecordSet{
{
Name: aws.String("example.com."),
Type: aws.String("NS"),
ResourceRecords: []*route53.ResourceRecord{
{
Value: aws.String("ns-1119.awsdns-11.org."),
},
{
Value: aws.String("ns-501.awsdns-62.com."),
},
},
},
},
}, nil)
mockResolver := mocks.NewMocknameserverResolver(ctrl)
mockResolver.EXPECT().LookupNS(gomock.Any(), gomock.Any()).Return([]*net.NS{
{
Host: "dns-ns2.amazon.com.",
},
{
Host: "dns-ns1.amazon.com.",
},
}, nil)
r53 := Route53{
client: mockAWS,
dns: mockResolver,
hostedZoneIDFor: map[string]string{
"example.com": "Z0698117FUWMJ87C39TF",
},
}
// WHEN
err := r53.ValidateDomainOwnership("example.com")
// THEN
var wanted *ErrUnmatchedNSRecords
require.ErrorAs(t, err, &wanted)
})
t.Run("should return nil when NS records match exactly", func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAWS := mocks.NewMockapi(ctrl)
mockAWS.EXPECT().ListResourceRecordSets(&route53.ListResourceRecordSetsInput{
HostedZoneId: aws.String("Z0698117FUWMJ87C39TF"),
}).Return(&route53.ListResourceRecordSetsOutput{
ResourceRecordSets: []*route53.ResourceRecordSet{
{
Name: aws.String("example.com."),
Type: aws.String("NS"),
ResourceRecords: []*route53.ResourceRecord{
{
Value: aws.String("dns-ns1.amazon.com."),
},
{
Value: aws.String("dns-ns2.amazon.com"),
},
},
},
{
Name: aws.String("demo.example.com."),
Type: aws.String("NS"),
ResourceRecords: []*route53.ResourceRecord{
{
Value: aws.String("ns-473.awsdns-59.com"),
},
},
},
},
}, nil)
mockResolver := mocks.NewMocknameserverResolver(ctrl)
mockResolver.EXPECT().LookupNS(gomock.Any(), "example.com").Return([]*net.NS{
{
Host: "dns-ns2.amazon.com.",
},
{
Host: "dns-ns1.amazon.com",
},
}, nil)
r53 := Route53{
client: mockAWS,
dns: mockResolver,
hostedZoneIDFor: map[string]string{
"example.com": "Z0698117FUWMJ87C39TF",
},
}
// WHEN
err := r53.ValidateDomainOwnership("example.com")
// THEN
require.NoError(t, err)
})
t.Run("should return nil when ns records are just a subset", func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockAWS := mocks.NewMockapi(ctrl)
mockAWS.EXPECT().ListResourceRecordSets(&route53.ListResourceRecordSetsInput{
HostedZoneId: aws.String("Z0698117FUWMJ87C39TF"),
}).Return(&route53.ListResourceRecordSetsOutput{
ResourceRecordSets: []*route53.ResourceRecordSet{
{
Name: aws.String("example.com."),
Type: aws.String("NS"),
ResourceRecords: []*route53.ResourceRecord{
{
Value: aws.String("dns-ns1.amazon.com."),
},
{
Value: aws.String("dns-ns2.amazon.com."),
},
{
Value: aws.String("dns-ns3.amazon.com."),
},
{
Value: aws.String("dns-ns4.amazon.com."),
},
},
},
},
}, nil)
mockResolver := mocks.NewMocknameserverResolver(ctrl)
mockResolver.EXPECT().LookupNS(gomock.Any(), "example.com").Return([]*net.NS{
{
Host: "dns-ns2.amazon.com.",
},
{
Host: "dns-ns1.amazon.com",
},
}, nil)
r53 := Route53{
client: mockAWS,
dns: mockResolver,
hostedZoneIDFor: map[string]string{
"example.com": "Z0698117FUWMJ87C39TF",
},
}
// WHEN
err := r53.ValidateDomainOwnership("example.com")
// THEN
require.NoError(t, err)
})
}
| 402 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/route53/route53.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
net "net"
reflect "reflect"
route53 "github.com/aws/aws-sdk-go/service/route53"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// ListHostedZonesByName mocks base method.
func (m *Mockapi) ListHostedZonesByName(arg0 *route53.ListHostedZonesByNameInput) (*route53.ListHostedZonesByNameOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListHostedZonesByName", arg0)
ret0, _ := ret[0].(*route53.ListHostedZonesByNameOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListHostedZonesByName indicates an expected call of ListHostedZonesByName.
func (mr *MockapiMockRecorder) ListHostedZonesByName(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByName", reflect.TypeOf((*Mockapi)(nil).ListHostedZonesByName), arg0)
}
// ListResourceRecordSets mocks base method.
func (m *Mockapi) ListResourceRecordSets(arg0 *route53.ListResourceRecordSetsInput) (*route53.ListResourceRecordSetsOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListResourceRecordSets", arg0)
ret0, _ := ret[0].(*route53.ListResourceRecordSetsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListResourceRecordSets indicates an expected call of ListResourceRecordSets.
func (mr *MockapiMockRecorder) ListResourceRecordSets(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSets", reflect.TypeOf((*Mockapi)(nil).ListResourceRecordSets), arg0)
}
// MocknameserverResolver is a mock of nameserverResolver interface.
type MocknameserverResolver struct {
ctrl *gomock.Controller
recorder *MocknameserverResolverMockRecorder
}
// MocknameserverResolverMockRecorder is the mock recorder for MocknameserverResolver.
type MocknameserverResolverMockRecorder struct {
mock *MocknameserverResolver
}
// NewMocknameserverResolver creates a new mock instance.
func NewMocknameserverResolver(ctrl *gomock.Controller) *MocknameserverResolver {
mock := &MocknameserverResolver{ctrl: ctrl}
mock.recorder = &MocknameserverResolverMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MocknameserverResolver) EXPECT() *MocknameserverResolverMockRecorder {
return m.recorder
}
// LookupNS mocks base method.
func (m *MocknameserverResolver) LookupNS(ctx context.Context, name string) ([]*net.NS, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LookupNS", ctx, name)
ret0, _ := ret[0].([]*net.NS)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// LookupNS indicates an expected call of LookupNS.
func (mr *MocknameserverResolverMockRecorder) LookupNS(ctx, name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupNS", reflect.TypeOf((*MocknameserverResolver)(nil).LookupNS), ctx, name)
}
| 106 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package s3 provides a client to make API requests to Amazon Simple Storage Service.
package s3
import (
"errors"
"fmt"
"io"
"mime"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go/aws"
awsarn "github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/endpoints"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/service/s3/s3manager"
"github.com/dustin/go-humanize"
"github.com/xlab/treeprint"
)
const (
// EndpointsID is the ID to look up the S3 service endpoint.
EndpointsID = s3.EndpointsID
// Error codes.
errCodeNotFound = "NotFound"
// Object location prefixes.
s3URIPrefix = "s3://"
// Delimiter for ListObjectsV2Input.
slashDelimiter = "/"
)
type s3ManagerAPI interface {
Upload(input *s3manager.UploadInput, options ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error)
}
type s3API interface {
ListObjectVersions(input *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)
ListObjectsV2(input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)
DeleteObjects(input *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)
HeadBucket(input *s3.HeadBucketInput) (*s3.HeadBucketOutput, error)
}
// NamedBinary is a named binary to be uploaded.
type NamedBinary interface {
Name() string
Content() []byte
}
// CompressAndUploadFunc is invoked to zip multiple template contents and upload them to an S3 bucket under the specified key.
type CompressAndUploadFunc func(key string, objects ...NamedBinary) (url string, err error)
// S3 wraps an Amazon Simple Storage Service client.
type S3 struct {
s3Manager s3ManagerAPI
s3Client s3API
}
// New returns an S3 client configured against the input session.
func New(s *session.Session) *S3 {
return &S3{
s3Manager: s3manager.NewUploader(s),
s3Client: s3.New(s),
}
}
// Upload uploads a file to an S3 bucket under the specified key.
// Per s3's recommendation https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html:
// The bucket owner, in addition to the object owner, is granted full control.
func (s *S3) Upload(bucket, key string, data io.Reader) (string, error) {
return s.upload(bucket, key, data)
}
// EmptyBucket deletes all objects within the bucket.
func (s *S3) EmptyBucket(bucket string) error {
var listResp *s3.ListObjectVersionsOutput
var err error
bucketExists, err := s.bucketExists(bucket)
if err != nil {
return fmt.Errorf("unable to determine the existence of bucket %s: %w", bucket, err)
}
if !bucketExists {
return nil
}
listParams := &s3.ListObjectVersionsInput{
Bucket: aws.String(bucket),
}
// Remove all versions of all objects.
for {
listResp, err = s.s3Client.ListObjectVersions(listParams)
if err != nil {
return fmt.Errorf("list objects for bucket %s: %w", bucket, err)
}
var objectsToDelete []*s3.ObjectIdentifier
for _, object := range listResp.Versions {
objectsToDelete = append(objectsToDelete, &s3.ObjectIdentifier{
Key: object.Key,
VersionId: object.VersionId,
})
}
// After deleting other versions, remove delete markers version.
// For info on "delete marker": https://docs.aws.amazon.com/AmazonS3/latest/dev/DeleteMarker.html
for _, deleteMarker := range listResp.DeleteMarkers {
objectsToDelete = append(objectsToDelete, &s3.ObjectIdentifier{
Key: deleteMarker.Key,
VersionId: deleteMarker.VersionId,
})
}
if len(objectsToDelete) == 0 {
return nil
}
delResp, err := s.s3Client.DeleteObjects(&s3.DeleteObjectsInput{
Bucket: aws.String(bucket),
Delete: &s3.Delete{
Objects: objectsToDelete,
Quiet: aws.Bool(true), // we don't care about success values
},
})
switch {
case err != nil:
return fmt.Errorf("delete objects from bucket %s: %w", bucket, err)
case len(delResp.Errors) > 0:
return errors.Join(
fmt.Errorf("%d/%d objects failed to delete", len(delResp.Errors), len(objectsToDelete)),
fmt.Errorf("first failed on key %q: %s", aws.StringValue(delResp.Errors[0].Key), aws.StringValue(delResp.Errors[0].Message)),
)
}
if !aws.BoolValue(listResp.IsTruncated) {
return nil
}
listParams.KeyMarker = listResp.NextKeyMarker
listParams.VersionIdMarker = listResp.NextVersionIdMarker
}
}
// ParseURL parses URLs or s3 URIs and returns the bucket name and the optional key.
// For example, the URL: "https://stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r.s3-us-west-2.amazonaws.com/scripts/dns-cert-validator/dd2278811c3"
// or alternatively, the s3 URI: "s3://stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r/scripts/dns-cert-validator/dd2278811c3"
// Returns "stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r" and "scripts/dns-cert-validator/dd2278811c3"
func ParseURL(url string) (bucket string, key string, err error) {
if strings.HasPrefix(url, s3URIPrefix) {
return parseS3URI(url)
}
return parseHTTPURI(url)
}
// ParseARN parses an S3 bucket or object ARN.
// For example, a bucket arn "arn:aws:s3:::my-bucket" returns "my-bucket", "", nil.
// Whereas, an object arn "arn:aws:s3:::my-bucket/key.json" returns "my-bucket, "key.json", nil
func ParseARN(arn string) (bucket, key string, err error) {
parsedARN, err := awsarn.Parse(arn)
if err != nil {
return "", "", fmt.Errorf("invalid S3 ARN: %w", err)
}
parts := strings.SplitN(parsedARN.Resource, "/", 2)
if len(parts) == 1 {
return parts[0], "", nil
}
return parts[0], parts[1], nil
}
// URL returns a virtual-hosted–style S3 url for the object stored at key in a bucket created in the specified region.
func URL(region, bucket, key string) string {
tld := "com"
for cn := range endpoints.AwsCnPartition().Regions() {
if cn == region {
tld = "cn"
break
}
}
if key != "" {
return fmt.Sprintf("https://%s.s3.%s.amazonaws.%s/%s", bucket, region, tld, key)
}
return fmt.Sprintf("https://%s.s3.%s.amazonaws.%s", bucket, region, tld)
}
// Location returns an S3 object location URI in the format "s3://bucket/key".
func Location(bucket, key string) string {
return fmt.Sprintf("s3://%s/%s", bucket, key)
}
// FormatARN formats an S3 object ARN.
// For example: arn:aws:s3:::stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r.s3-us-west-2.amazonaws.com/scripts/dns-cert-validator/dd2278811c3
func FormatARN(partition, location string) string {
return fmt.Sprintf("arn:%s:s3:::%s", partition, location)
}
// BucketTree creates an ASCII tree representing the folder structure of a bucket's objects.
func (s *S3) BucketTree(bucket string) (string, error) {
outputs, err := s.listObjects(bucket, "/")
if err != nil || outputs == nil {
return "", err
}
var contents []*s3.Object
var prefixes []*s3.CommonPrefix
for _, output := range outputs {
contents = append(contents, output.Contents...)
prefixes = append(prefixes, output.CommonPrefixes...)
}
tree := treeprint.New()
// Add top-level files.
for _, object := range contents {
tree.AddNode(aws.StringValue(object.Key))
}
// Recursively add folders and their children.
if err := s.addNodes(tree, prefixes, bucket); err != nil {
return "", err
}
return tree.String(), nil
}
// BucketSizeAndCount returns the total size and number of objects in an S3 bucket.
func (s *S3) BucketSizeAndCount(bucket string) (string, int, error) {
outputs, err := s.listObjects(bucket, "")
if err != nil || outputs == nil {
return "", 0, err
}
var size int64
var count int
for _, output := range outputs {
for _, object := range output.Contents {
size += aws.Int64Value(object.Size)
count++
}
}
return humanize.Bytes(uint64(size)), count, nil
}
func (s *S3) listObjects(bucket, delimiter string) ([]s3.ListObjectsV2Output, error) {
exists, err := s.bucketExists(bucket)
if err != nil || !exists {
return nil, err
}
var outputs []s3.ListObjectsV2Output
listResp := &s3.ListObjectsV2Output{}
for {
listParams := &s3.ListObjectsV2Input{
Bucket: aws.String(bucket),
Delimiter: aws.String(delimiter),
ContinuationToken: listResp.NextContinuationToken,
}
listResp, err = s.s3Client.ListObjectsV2(listParams)
if err != nil {
return nil, fmt.Errorf("list objects for bucket %s: %w", bucket, err)
}
outputs = append(outputs, *listResp)
if listResp.NextContinuationToken == nil {
break
}
}
return outputs, nil
}
func (s *S3) bucketExists(bucket string) (bool, error) {
input := &s3.HeadBucketInput{
Bucket: aws.String(bucket),
}
_, err := s.s3Client.HeadBucket(input)
if err != nil {
var aerr awserr.Error
if errors.As(err, &aerr) && aerr.Code() == errCodeNotFound {
return false, nil
}
return false, err
}
return true, nil
}
func (s *S3) addNodes(tree treeprint.Tree, prefixes []*s3.CommonPrefix, bucket string) error {
if len(prefixes) == 0 {
return nil
}
listResp := &s3.ListObjectsV2Output{}
var err error
for _, prefix := range prefixes {
var respContents []*s3.Object
var respPrefixes []*s3.CommonPrefix
branch := tree.AddBranch(filepath.Base(aws.StringValue(prefix.Prefix)))
for {
listParams := &s3.ListObjectsV2Input{
Bucket: aws.String(bucket),
Delimiter: aws.String(slashDelimiter),
ContinuationToken: listResp.ContinuationToken,
Prefix: prefix.Prefix,
}
listResp, err = s.s3Client.ListObjectsV2(listParams)
if err != nil {
return fmt.Errorf("list objects for bucket %s: %w", bucket, err)
}
respContents = append(respContents, listResp.Contents...)
respPrefixes = append(respPrefixes, listResp.CommonPrefixes...)
if listResp.NextContinuationToken == nil {
break
}
}
for _, file := range respContents {
fileName := filepath.Base(aws.StringValue(file.Key))
branch.AddNode(fileName)
}
if err := s.addNodes(branch, respPrefixes, bucket); err != nil {
return err
}
}
return nil
}
func (s *S3) upload(bucket, key string, buf io.Reader) (string, error) {
in := &s3manager.UploadInput{
Body: buf,
Bucket: aws.String(bucket),
Key: aws.String(key),
ACL: aws.String(s3.ObjectCannedACLBucketOwnerFullControl),
ContentType: defaultContentTypeFromExt(key),
}
resp, err := s.s3Manager.Upload(in)
if err != nil {
return "", fmt.Errorf("upload %s to bucket %s: %w", key, bucket, err)
}
return resp.Location, nil
}
func defaultContentTypeFromExt(key string) *string {
contentType := mime.TypeByExtension(filepath.Ext(key))
if contentType == "" {
return nil
}
return aws.String(contentType)
}
// parseS3URI parses the bucket name and object key from a [s3:// URI].
// For example: s3://mybucket/puppy.jpg
//
// [s3:// URI]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-bucket-intro.html#accessing-a-bucket-using-S3-format
func parseS3URI(uri string) (bucket, key string, err error) {
parsed := strings.SplitN(strings.TrimPrefix(uri, s3URIPrefix), "/", 2)
bucket = parsed[0]
if bucket == "" {
return "", "", fmt.Errorf("cannot parse S3 URI %s into bucket name and key", uri)
}
if len(parsed) == 2 {
key = parsed[1]
}
return
}
// parseHTTPURL parses the bucket name and optional key from a [virtual-hosted-style access URL].
// For example: https://DOC-EXAMPLE-BUCKET1.s3.us-west-2.amazonaws.com/puppy.png
//
// [virtual-hosted-style access URL]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-bucket-intro.html#virtual-host-style-url-ex
func parseHTTPURI(url string) (bucket, key string, err error) {
parsedURL := strings.SplitN(strings.TrimPrefix(url, "https://"), "/", 2)
// go through the host backwards and find the first piece that
// starts with 's3' - the rest of the host (to the left of 's3')
// is the bucket name. this is to support both URL host formats:
// <bucket>.s3-<region>.amazonaws.com and <bucket>.s3.<region>.amazonaws.com
split := strings.Split(parsedURL[0], ".")
bucketEndIdx := len(split) - 1
for ; bucketEndIdx > 0; bucketEndIdx-- {
if strings.HasPrefix(split[bucketEndIdx], "s3") {
break
}
}
bucket = strings.Join(split[:bucketEndIdx], ".")
if bucket == "" {
return "", "", fmt.Errorf("cannot parse S3 URL %s into bucket name and key", url)
}
if len(parsedURL) == 2 {
key = parsedURL[1]
}
return
}
| 383 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package s3
import (
"bytes"
"errors"
"fmt"
"io"
"testing"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/service/s3/s3manager"
"github.com/aws/copilot-cli/internal/pkg/aws/s3/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestS3_Upload(t *testing.T) {
testCases := map[string]struct {
mockS3ManagerClient func(m *mocks.Mocks3ManagerAPI)
wantedURL string
wantError error
}{
"return error if upload fails": {
mockS3ManagerClient: func(m *mocks.Mocks3ManagerAPI) {
m.EXPECT().Upload(gomock.Any()).Do(func(in *s3manager.UploadInput, _ ...func(*s3manager.Uploader)) {
require.Equal(t, aws.StringValue(in.Bucket), "mockBucket")
require.Equal(t, aws.StringValue(in.Key), "src/mockIndex.html")
}).Return(nil, errors.New("some error"))
},
wantError: fmt.Errorf("upload src/mockIndex.html to bucket mockBucket: some error"),
},
"should upload to the s3 bucket": {
mockS3ManagerClient: func(m *mocks.Mocks3ManagerAPI) {
m.EXPECT().Upload(gomock.Any()).Do(func(in *s3manager.UploadInput, _ ...func(*s3manager.Uploader)) {
b, err := io.ReadAll(in.Body)
require.NoError(t, err)
require.Equal(t, "bar", string(b))
require.Equal(t, "mockBucket", aws.StringValue(in.Bucket))
require.Equal(t, "src/mockIndex.html", aws.StringValue(in.Key))
require.Equal(t, "text/html; charset=utf-8", aws.StringValue(in.ContentType))
require.Equal(t, s3.ObjectCannedACLBucketOwnerFullControl, aws.StringValue(in.ACL))
}).Return(&s3manager.UploadOutput{
Location: "mockURL",
}, nil)
},
wantedURL: "mockURL",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockS3ManagerClient := mocks.NewMocks3ManagerAPI(ctrl)
tc.mockS3ManagerClient(mockS3ManagerClient)
service := S3{
s3Manager: mockS3ManagerClient,
}
gotURL, gotErr := service.Upload("mockBucket", "src/mockIndex.html", bytes.NewBuffer([]byte("bar")))
if gotErr != nil {
require.EqualError(t, gotErr, tc.wantError.Error())
} else {
require.Equal(t, gotErr, nil)
require.Equal(t, gotURL, tc.wantedURL)
}
})
}
}
func TestS3_EmptyBucket(t *testing.T) {
batchObject1 := make([]*s3.ObjectVersion, 1000)
batchObject2 := make([]*s3.ObjectVersion, 10)
deleteMarkers := make([]*s3.DeleteMarkerEntry, 10)
batchObjectID1 := make([]*s3.ObjectIdentifier, 1000)
batchObjectID2 := make([]*s3.ObjectIdentifier, 10)
batchObjectID3 := make([]*s3.ObjectIdentifier, 20)
for i := 0; i < 1000; i++ {
batchObject1[i] = &s3.ObjectVersion{
Key: aws.String("mockKey"),
VersionId: aws.String("mockVersion"),
}
batchObjectID1[i] = &s3.ObjectIdentifier{
Key: aws.String("mockKey"),
VersionId: aws.String("mockVersion"),
}
}
for i := 0; i < 10; i++ {
batchObject2[i] = &s3.ObjectVersion{
Key: aws.String("mockKey"),
VersionId: aws.String("mockVersion"),
}
deleteMarkers[i] = &s3.DeleteMarkerEntry{
Key: aws.String("mockKey"),
VersionId: aws.String("mockVersion"),
}
batchObjectID2[i] = &s3.ObjectIdentifier{
Key: aws.String("mockKey"),
VersionId: aws.String("mockVersion"),
}
batchObjectID3[i] = &s3.ObjectIdentifier{
Key: aws.String("mockKey"),
VersionId: aws.String("mockVersion"),
}
batchObjectID3[i+10] = &s3.ObjectIdentifier{
Key: aws.String("mockKey"),
VersionId: aws.String("mockVersion"),
}
}
testCases := map[string]struct {
inBucket string
mockS3Client func(m *mocks.Mocks3API)
wantErr error
}{
"should delete all objects within the bucket": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, nil)
m.EXPECT().ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String("mockBucket"),
}).Return(&s3.ListObjectVersionsOutput{
IsTruncated: aws.Bool(false),
Versions: batchObject2,
}, nil)
m.EXPECT().DeleteObjects(&s3.DeleteObjectsInput{
Bucket: aws.String("mockBucket"),
Delete: &s3.Delete{
Objects: batchObjectID2,
Quiet: aws.Bool(true),
},
}).Return(&s3.DeleteObjectsOutput{}, nil)
},
wantErr: nil,
},
"should batch delete all objects within the bucket": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, nil)
m.EXPECT().ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String("mockBucket"),
}).Return(&s3.ListObjectVersionsOutput{
IsTruncated: aws.Bool(true),
Versions: batchObject1,
}, nil)
m.EXPECT().DeleteObjects(&s3.DeleteObjectsInput{
Bucket: aws.String("mockBucket"),
Delete: &s3.Delete{
Objects: batchObjectID1,
Quiet: aws.Bool(true),
},
}).Return(&s3.DeleteObjectsOutput{}, nil)
m.EXPECT().ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String("mockBucket"),
}).Return(&s3.ListObjectVersionsOutput{
IsTruncated: aws.Bool(false),
Versions: batchObject2,
}, nil)
m.EXPECT().DeleteObjects(&s3.DeleteObjectsInput{
Bucket: aws.String("mockBucket"),
Delete: &s3.Delete{
Objects: batchObjectID2,
Quiet: aws.Bool(true),
},
}).Return(&s3.DeleteObjectsOutput{}, nil)
},
wantErr: nil,
},
"should delete all objects within the bucket including delete markers": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, nil)
m.EXPECT().ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String("mockBucket"),
}).Return(&s3.ListObjectVersionsOutput{
IsTruncated: aws.Bool(false),
Versions: batchObject2,
DeleteMarkers: deleteMarkers,
}, nil)
m.EXPECT().DeleteObjects(&s3.DeleteObjectsInput{
Bucket: aws.String("mockBucket"),
Delete: &s3.Delete{
Objects: batchObjectID3,
Quiet: aws.Bool(true),
},
}).Return(&s3.DeleteObjectsOutput{}, nil)
},
wantErr: nil,
},
"should wrap up error if fail to list objects": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, nil)
m.EXPECT().ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, errors.New("some error"))
},
wantErr: fmt.Errorf("list objects for bucket mockBucket: some error"),
},
"should not invoke DeleteObjects if bucket is empty": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, nil)
m.EXPECT().ListObjectVersions(gomock.Any()).Return(&s3.ListObjectVersionsOutput{
IsTruncated: aws.Bool(false),
}, nil)
m.EXPECT().DeleteObjects(gomock.Any()).Times(0)
},
wantErr: nil,
},
"should wrap up error if fail to delete objects": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, nil)
m.EXPECT().ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String("mockBucket"),
}).Return(&s3.ListObjectVersionsOutput{
IsTruncated: aws.Bool(false),
Versions: batchObject2,
}, nil)
m.EXPECT().DeleteObjects(&s3.DeleteObjectsInput{
Bucket: aws.String("mockBucket"),
Delete: &s3.Delete{
Objects: batchObjectID2,
Quiet: aws.Bool(true),
},
}).Return(nil, errors.New("some error"))
},
wantErr: fmt.Errorf("delete objects from bucket mockBucket: some error"),
},
"should not proceed with deletion as the bucket doesnt exists": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, awserr.New(errCodeNotFound, "message", nil))
},
wantErr: nil,
},
"should throw error while perform bucket exists check": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, awserr.New("Unknown", "message", nil))
},
wantErr: fmt.Errorf("unable to determine the existence of bucket %s: %w", "mockBucket",
awserr.New("Unknown", "message", nil)),
},
"some objects failed to delete": {
inBucket: "mockBucket",
mockS3Client: func(m *mocks.Mocks3API) {
m.EXPECT().HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String("mockBucket"),
}).Return(nil, nil)
m.EXPECT().ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String("mockBucket"),
}).Return(&s3.ListObjectVersionsOutput{
IsTruncated: aws.Bool(false),
Versions: batchObject2,
}, nil)
m.EXPECT().DeleteObjects(&s3.DeleteObjectsInput{
Bucket: aws.String("mockBucket"),
Delete: &s3.Delete{
Objects: batchObjectID2,
Quiet: aws.Bool(true),
},
}).Return(&s3.DeleteObjectsOutput{
Errors: []*s3.Error{
{
Key: aws.String("mock/key"),
Message: aws.String("some error"),
},
},
}, nil)
},
wantErr: fmt.Errorf(`1/10 objects failed to delete
first failed on key "mock/key": some error`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockS3Client := mocks.NewMocks3API(ctrl)
tc.mockS3Client(mockS3Client)
service := S3{
s3Client: mockS3Client,
}
gotErr := service.EmptyBucket(tc.inBucket)
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
return
}
require.NoError(t, gotErr)
})
}
}
func TestS3_ParseURL(t *testing.T) {
testCases := map[string]struct {
inURL string
wantedBucketName string
wantedKey string
wantError error
}{
"return error if fail to parse": {
inURL: "badURL",
wantError: fmt.Errorf("cannot parse S3 URL badURL into bucket name and key"),
},
"return error S3 URI": {
inURL: "s3://",
wantError: fmt.Errorf("cannot parse S3 URI s3:// into bucket name and key"),
},
"parses S3 URI": {
inURL: "s3://amplify-demo-dev-94628-deployment/auth/amplify-meta.json",
wantedBucketName: "amplify-demo-dev-94628-deployment",
wantedKey: "auth/amplify-meta.json",
},
"parses object URL": {
inURL: "https://stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r.s3-us-west-2.amazonaws.com/scripts/dns-cert-validator/dd2278811c3",
wantedBucketName: "stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r",
wantedKey: "scripts/dns-cert-validator/dd2278811c3",
},
"parses bucket URL": {
inURL: "https://stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r.s3-us-west-2.amazonaws.com",
wantedBucketName: "stackset-myapp-infrastru-pipelinebuiltartifactbuc-1nk5t9zkymh8r",
wantedKey: "",
},
"parses object URL with dots": {
inURL: "https://bucket.with.dots.in.name.s3.us-west-2.amazonaws.com/scripts/dns-cert-validator/dd2278811c3",
wantedBucketName: "bucket.with.dots.in.name",
wantedKey: "scripts/dns-cert-validator/dd2278811c3",
},
"parses legacy object URL with dots": {
inURL: "https://bucket.with.dots.in.name.s3-us-west-2.amazonaws.com/scripts/dns-cert-validator/dd2278811c3",
wantedBucketName: "bucket.with.dots.in.name",
wantedKey: "scripts/dns-cert-validator/dd2278811c3",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
gotBucketName, gotKey, gotErr := ParseURL(tc.inURL)
if gotErr != nil {
require.EqualError(t, gotErr, tc.wantError.Error())
} else {
require.NoError(t, tc.wantError)
require.Equal(t, tc.wantedBucketName, gotBucketName)
require.Equal(t, tc.wantedKey, gotKey)
}
})
}
}
func Test_ParseARN(t *testing.T) {
type wanted struct {
bucket string
key string
err error
}
testCases := map[string]struct {
in string
wanted wanted
}{
"bad bad arn": {
in: "i am not an arn at all",
wanted: wanted{err: errors.New("invalid S3 ARN")},
},
"parses an S3 bucket arn": {
in: "arn:aws:s3:::amplify-demo-dev-94628-deployment",
wanted: wanted{bucket: "amplify-demo-dev-94628-deployment"},
},
"parses an S3 object arn": {
in: "arn:aws:s3:::amplify-demo-dev-94628-deployment/studio-backend/auth/demo6a968da2/build/parameters.json",
wanted: wanted{bucket: "amplify-demo-dev-94628-deployment", key: "studio-backend/auth/demo6a968da2/build/parameters.json"},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
bucket, key, err := ParseARN(tc.in)
if tc.wanted.err != nil {
require.ErrorContains(t, err, tc.wanted.err.Error())
return
}
require.Equal(t, tc.wanted.bucket, bucket)
require.Equal(t, tc.wanted.key, key)
})
}
}
func TestURL(t *testing.T) {
testCases := map[string]struct {
region string
bucket string
key string
wanted string
}{
// See https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-bucket-intro.html#virtual-host-style-url-ex
"Formats a virtual-hosted-style URL": {
region: "us-west-2",
bucket: "mybucket",
key: "puppy.jpg",
wanted: "https://mybucket.s3.us-west-2.amazonaws.com/puppy.jpg",
},
"Formats a virtual-hosted-style URL with no key": {
region: "us-west-2",
bucket: "mybucket",
wanted: "https://mybucket.s3.us-west-2.amazonaws.com",
},
"Formats the URL for a region in the aws-cn partition": {
region: "cn-north-1",
bucket: "mybucket",
key: "puppy.jpg",
wanted: "https://mybucket.s3.cn-north-1.amazonaws.cn/puppy.jpg",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
require.Equal(t, tc.wanted, URL(tc.region, tc.bucket, tc.key))
})
}
}
func TestS3_FormatARN(t *testing.T) {
testCases := map[string]struct {
inPartition string
inLocation string
wantedARN string
}{
"success": {
inPartition: "aws",
inLocation: "stackset-demo-infrastruc-pipelinebuiltartifactbuc-11dj7ctf52wyf/manual/1638391936/env",
wantedARN: "arn:aws:s3:::stackset-demo-infrastruc-pipelinebuiltartifactbuc-11dj7ctf52wyf/manual/1638391936/env",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
gotARN := FormatARN(tc.inPartition, tc.inLocation)
require.Equal(t, gotARN, tc.wantedARN)
})
}
}
func TestS3_BucketTree(t *testing.T) {
type s3Mocks struct {
s3API *mocks.Mocks3API
s3ManagerAPI *mocks.Mocks3ManagerAPI
}
mockBucket := aws.String("bucketName")
delimiter := aws.String("/")
nonexistentError := awserr.New(errCodeNotFound, "msg", errors.New("some error"))
mockContinuationToken := "next"
firstResp := s3.ListObjectsV2Output{
CommonPrefixes: []*s3.CommonPrefix{
{Prefix: aws.String("Images")},
{Prefix: aws.String("css")},
{Prefix: aws.String("top")},
},
Contents: []*s3.Object{
{Key: aws.String("README.md")},
{Key: aws.String("error.html")},
{Key: aws.String("index.html")},
},
Delimiter: delimiter,
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
}
imagesResp := s3.ListObjectsV2Output{
Contents: []*s3.Object{
{Key: aws.String("firstImage.PNG")},
{Key: aws.String("secondImage.PNG")},
},
Delimiter: delimiter,
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
}
cssResp := s3.ListObjectsV2Output{
Contents: []*s3.Object{
{Key: aws.String("Style.css")},
{Key: aws.String("bootstrap.min.css")},
},
Delimiter: delimiter,
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
}
topResp := s3.ListObjectsV2Output{
CommonPrefixes: []*s3.CommonPrefix{
{Prefix: aws.String("middle")},
},
Delimiter: delimiter,
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
}
middleResp := s3.ListObjectsV2Output{
Contents: []*s3.Object{
{Key: aws.String("bottom.html")},
},
Delimiter: delimiter,
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
}
testCases := map[string]struct {
setupMocks func(mocks s3Mocks)
wantTree string
wantErr error
}{
"should return all objects within the bucket as a tree string": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
ContinuationToken: nil,
Delimiter: delimiter,
Prefix: nil,
}).Return(&firstResp, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: delimiter,
Prefix: aws.String("Images"),
}).Return(&imagesResp, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: delimiter,
Prefix: aws.String("css"),
}).Return(&cssResp, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: delimiter,
Prefix: aws.String("top"),
}).Return(&topResp, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: delimiter,
Prefix: aws.String("middle"),
}).Return(&middleResp, nil)
},
wantTree: `.
├── README.md
├── error.html
├── index.html
├── Images
│ ├── firstImage.PNG
│ └── secondImage.PNG
├── css
│ ├── Style.css
│ └── bootstrap.min.css
└── top
└── middle
└── bottom.html
`,
},
"should handle multiple pages of objects": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
ContinuationToken: nil,
Delimiter: delimiter,
Prefix: nil,
}).Return(
&s3.ListObjectsV2Output{
Contents: []*s3.Object{
{Key: aws.String("README.md")},
},
Delimiter: delimiter,
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
NextContinuationToken: &mockContinuationToken,
}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
ContinuationToken: &mockContinuationToken,
Delimiter: delimiter,
Prefix: nil,
}).Return(
&s3.ListObjectsV2Output{
Contents: []*s3.Object{
{Key: aws.String("READMETOO.md")},
},
Delimiter: delimiter,
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
NextContinuationToken: nil,
}, nil)
},
wantTree: `.
├── README.md
└── READMETOO.md
`,
},
"return nil if bucket doesn't exist": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nonexistentError)
},
},
"return err if cannot determine if bucket exists": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, errors.New("some error"))
},
wantErr: errors.New("some error"),
},
"should wrap error if fail to list objects": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
ContinuationToken: nil,
Delimiter: delimiter,
Prefix: nil,
}).Return(nil, errors.New("some error"))
},
wantErr: errors.New("list objects for bucket bucketName: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockS3Client := mocks.NewMocks3API(ctrl)
mockS3Manager := mocks.NewMocks3ManagerAPI(ctrl)
s3mocks := s3Mocks{
s3API: mockS3Client,
s3ManagerAPI: mockS3Manager,
}
service := S3{
s3Client: mockS3Client,
}
tc.setupMocks(s3mocks)
gotTree, gotErr := service.BucketTree(aws.StringValue(mockBucket))
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
return
}
require.NoError(t, gotErr)
require.Equal(t, tc.wantTree, gotTree)
})
}
}
func TestS3_BucketSizeAndCount(t *testing.T) {
type s3Mocks struct {
s3API *mocks.Mocks3API
s3ManagerAPI *mocks.Mocks3ManagerAPI
}
mockBucket := aws.String("bucketName")
nonexistentError := awserr.New(errCodeNotFound, "msg", errors.New("some error"))
mockContinuationToken := "next"
resp := s3.ListObjectsV2Output{
Contents: []*s3.Object{
{
Key: aws.String("README.md"),
Size: aws.Int64(111111),
},
{
Key: aws.String("error.html"),
Size: aws.Int64(222222),
},
{
Key: aws.String("index.html"),
Size: aws.Int64(333333),
},
},
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
}
testCases := map[string]struct {
setupMocks func(mocks s3Mocks)
wantSize string
wantCount int
wantErr error
}{
"should return correct size and count": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: aws.String(""),
ContinuationToken: nil,
Prefix: nil,
}).Return(&resp, nil)
},
wantSize: "667 kB",
wantCount: 3,
},
"should handle multiple pages of objects": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: aws.String(""),
ContinuationToken: nil,
Prefix: nil,
}).Return(
&s3.ListObjectsV2Output{
Contents: []*s3.Object{
{
Key: aws.String("README.md"),
Size: aws.Int64(123),
},
},
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
NextContinuationToken: &mockContinuationToken,
}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: aws.String(""),
ContinuationToken: &mockContinuationToken,
Prefix: nil,
}).Return(
&s3.ListObjectsV2Output{
Contents: []*s3.Object{
{
Key: aws.String("READMETOO.md"),
Size: aws.Int64(321),
},
},
KeyCount: aws.Int64(14),
MaxKeys: aws.Int64(1000),
Name: mockBucket,
NextContinuationToken: nil,
}, nil)
},
wantSize: "444 B",
wantCount: 2,
},
"empty bucket": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: aws.String(""),
ContinuationToken: nil,
Prefix: nil,
}).Return(&s3.ListObjectsV2Output{
Contents: nil,
Name: mockBucket,
}, nil)
},
wantSize: "0 B",
wantCount: 0,
},
"return nil if bucket doesn't exist": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nonexistentError)
},
},
"return err if cannot determine if bucket exists": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, errors.New("some error"))
},
wantErr: errors.New("some error"),
},
"should wrap error if fail to list objects": {
setupMocks: func(m s3Mocks) {
m.s3API.EXPECT().HeadBucket(&s3.HeadBucketInput{Bucket: mockBucket}).Return(&s3.HeadBucketOutput{}, nil)
m.s3API.EXPECT().ListObjectsV2(&s3.ListObjectsV2Input{
Bucket: mockBucket,
Delimiter: aws.String(""),
ContinuationToken: nil,
}).Return(nil, errors.New("some error"))
},
wantErr: errors.New("list objects for bucket bucketName: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockS3Client := mocks.NewMocks3API(ctrl)
mockS3Manager := mocks.NewMocks3ManagerAPI(ctrl)
s3mocks := s3Mocks{
s3API: mockS3Client,
s3ManagerAPI: mockS3Manager,
}
service := S3{
s3Client: mockS3Client,
}
tc.setupMocks(s3mocks)
gotSize, gotCount, gotErr := service.BucketSizeAndCount(aws.StringValue(mockBucket))
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
return
}
require.NoError(t, gotErr)
require.Equal(t, tc.wantSize, gotSize)
require.Equal(t, tc.wantCount, gotCount)
})
}
}
| 866 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/s3/s3.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
s3 "github.com/aws/aws-sdk-go/service/s3"
s3manager "github.com/aws/aws-sdk-go/service/s3/s3manager"
gomock "github.com/golang/mock/gomock"
)
// Mocks3ManagerAPI is a mock of s3ManagerAPI interface.
type Mocks3ManagerAPI struct {
ctrl *gomock.Controller
recorder *Mocks3ManagerAPIMockRecorder
}
// Mocks3ManagerAPIMockRecorder is the mock recorder for Mocks3ManagerAPI.
type Mocks3ManagerAPIMockRecorder struct {
mock *Mocks3ManagerAPI
}
// NewMocks3ManagerAPI creates a new mock instance.
func NewMocks3ManagerAPI(ctrl *gomock.Controller) *Mocks3ManagerAPI {
mock := &Mocks3ManagerAPI{ctrl: ctrl}
mock.recorder = &Mocks3ManagerAPIMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mocks3ManagerAPI) EXPECT() *Mocks3ManagerAPIMockRecorder {
return m.recorder
}
// Upload mocks base method.
func (m *Mocks3ManagerAPI) Upload(input *s3manager.UploadInput, options ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{input}
for _, a := range options {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Upload", varargs...)
ret0, _ := ret[0].(*s3manager.UploadOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Upload indicates an expected call of Upload.
func (mr *Mocks3ManagerAPIMockRecorder) Upload(input interface{}, options ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{input}, options...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*Mocks3ManagerAPI)(nil).Upload), varargs...)
}
// Mocks3API is a mock of s3API interface.
type Mocks3API struct {
ctrl *gomock.Controller
recorder *Mocks3APIMockRecorder
}
// Mocks3APIMockRecorder is the mock recorder for Mocks3API.
type Mocks3APIMockRecorder struct {
mock *Mocks3API
}
// NewMocks3API creates a new mock instance.
func NewMocks3API(ctrl *gomock.Controller) *Mocks3API {
mock := &Mocks3API{ctrl: ctrl}
mock.recorder = &Mocks3APIMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mocks3API) EXPECT() *Mocks3APIMockRecorder {
return m.recorder
}
// DeleteObjects mocks base method.
func (m *Mocks3API) DeleteObjects(input *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteObjects", input)
ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeleteObjects indicates an expected call of DeleteObjects.
func (mr *Mocks3APIMockRecorder) DeleteObjects(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjects", reflect.TypeOf((*Mocks3API)(nil).DeleteObjects), input)
}
// HeadBucket mocks base method.
func (m *Mocks3API) HeadBucket(input *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HeadBucket", input)
ret0, _ := ret[0].(*s3.HeadBucketOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HeadBucket indicates an expected call of HeadBucket.
func (mr *Mocks3APIMockRecorder) HeadBucket(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucket", reflect.TypeOf((*Mocks3API)(nil).HeadBucket), input)
}
// ListObjectVersions mocks base method.
func (m *Mocks3API) ListObjectVersions(input *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListObjectVersions", input)
ret0, _ := ret[0].(*s3.ListObjectVersionsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListObjectVersions indicates an expected call of ListObjectVersions.
func (mr *Mocks3APIMockRecorder) ListObjectVersions(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersions", reflect.TypeOf((*Mocks3API)(nil).ListObjectVersions), input)
}
// ListObjectsV2 mocks base method.
func (m *Mocks3API) ListObjectsV2(input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListObjectsV2", input)
ret0, _ := ret[0].(*s3.ListObjectsV2Output)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListObjectsV2 indicates an expected call of ListObjectsV2.
func (mr *Mocks3APIMockRecorder) ListObjectsV2(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2", reflect.TypeOf((*Mocks3API)(nil).ListObjectsV2), input)
}
// MockNamedBinary is a mock of NamedBinary interface.
type MockNamedBinary struct {
ctrl *gomock.Controller
recorder *MockNamedBinaryMockRecorder
}
// MockNamedBinaryMockRecorder is the mock recorder for MockNamedBinary.
type MockNamedBinaryMockRecorder struct {
mock *MockNamedBinary
}
// NewMockNamedBinary creates a new mock instance.
func NewMockNamedBinary(ctrl *gomock.Controller) *MockNamedBinary {
mock := &MockNamedBinary{ctrl: ctrl}
mock.recorder = &MockNamedBinaryMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNamedBinary) EXPECT() *MockNamedBinaryMockRecorder {
return m.recorder
}
// Content mocks base method.
func (m *MockNamedBinary) Content() []byte {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Content")
ret0, _ := ret[0].([]byte)
return ret0
}
// Content indicates an expected call of Content.
func (mr *MockNamedBinaryMockRecorder) Content() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Content", reflect.TypeOf((*MockNamedBinary)(nil).Content))
}
// Name mocks base method.
func (m *MockNamedBinary) Name() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Name")
ret0, _ := ret[0].(string)
return ret0
}
// Name indicates an expected call of Name.
func (mr *MockNamedBinaryMockRecorder) Name() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockNamedBinary)(nil).Name))
}
| 191 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package secretsmanager provides a client to make API requests to AWS Secrets Manager.
package secretsmanager
import (
"fmt"
"time"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/service/secretsmanager"
)
type api interface {
CreateSecret(*secretsmanager.CreateSecretInput) (*secretsmanager.CreateSecretOutput, error)
DeleteSecret(*secretsmanager.DeleteSecretInput) (*secretsmanager.DeleteSecretOutput, error)
DescribeSecret(input *secretsmanager.DescribeSecretInput) (*secretsmanager.DescribeSecretOutput, error)
}
// SecretsManager wraps the AWS SecretManager client.
type SecretsManager struct {
secretsManager api
sessionRegion string
}
// New returns a SecretsManager configured against the input session.
func New(s *session.Session) *SecretsManager {
return &SecretsManager{
secretsManager: secretsmanager.New(s),
sessionRegion: *s.Config.Region,
}
}
var secretTags = func() []*secretsmanager.Tag {
timestamp := time.Now().UTC().Format(time.UnixDate)
return []*secretsmanager.Tag{
{
Key: aws.String("copilot-application"),
Value: aws.String(timestamp),
},
}
}
// CreateSecret creates a secret using the default KMS key "aws/secretmanager" to encrypt the secret and returns its ARN.
func (s *SecretsManager) CreateSecret(secretName, secretString string) (string, error) {
resp, err := s.secretsManager.CreateSecret(&secretsmanager.CreateSecretInput{
Name: aws.String(secretName),
SecretString: aws.String(secretString),
Tags: secretTags(),
})
if err != nil {
if aerr, ok := err.(awserr.Error); ok {
if aerr.Code() == secretsmanager.ErrCodeResourceExistsException {
// TODO update secret if value provided?
return "", &ErrSecretAlreadyExists{
secretName: secretName,
parentErr: err,
}
}
}
return "", fmt.Errorf("create secret %s: %w", secretName, err)
}
return aws.StringValue(resp.ARN), nil
}
// DeleteSecret force removes the secret from SecretsManager.
func (s *SecretsManager) DeleteSecret(secretName string) error {
_, err := s.secretsManager.DeleteSecret(&secretsmanager.DeleteSecretInput{
SecretId: aws.String(secretName),
ForceDeleteWithoutRecovery: aws.Bool(true), // forego the waiting period to delete the secret
})
if err != nil {
return fmt.Errorf("delete secret %s from secrets manager: %w", secretName, err)
}
return nil
}
// DescribeSecretOutput is the output returned by DescribeSecret.
type DescribeSecretOutput struct {
Name *string
CreatedDate *time.Time
Tags []*secretsmanager.Tag
}
// DescribeSecret retrieves the details of a secret.
func (s *SecretsManager) DescribeSecret(secretName string) (*DescribeSecretOutput, error) {
resp, err := s.secretsManager.DescribeSecret(&secretsmanager.DescribeSecretInput{
SecretId: aws.String(secretName),
})
if err != nil {
if aerr, ok := err.(awserr.Error); ok {
if aerr.Code() == secretsmanager.ErrCodeResourceNotFoundException {
return nil, &ErrSecretNotFound{
secretName: secretName,
parentErr: err,
}
}
}
return nil, fmt.Errorf("describe secret %s: %w", secretName, err)
}
return &DescribeSecretOutput{
Name: resp.Name,
CreatedDate: resp.CreatedDate,
Tags: resp.Tags,
}, nil
}
// ErrSecretAlreadyExists occurs if a secret with the same name already exists.
type ErrSecretAlreadyExists struct {
secretName string
parentErr error
}
func (err *ErrSecretAlreadyExists) Error() string {
return fmt.Sprintf("secret %s already exists", err.secretName)
}
// ErrSecretNotFound occurs if a secret with the given name does not exist.
type ErrSecretNotFound struct {
secretName string
parentErr error
}
func (err *ErrSecretNotFound) Error() string {
return fmt.Sprintf("secret %s was not found: %s", err.secretName, err.parentErr)
}
| 136 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package secretsmanager wraps AWS SecretsManager API functionality.
package secretsmanager
import (
"errors"
"fmt"
"github.com/aws/aws-sdk-go/service/secretsmanager"
"testing"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/copilot-cli/internal/pkg/aws/secretsmanager/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestSecretsManager_CreateSecret(t *testing.T) {
mockSecretName := "github-token-backend-badgoose"
mockSecretString := "H0NKH0NKH0NK"
mockError := errors.New("mockError")
mockOutput := &secretsmanager.CreateSecretOutput{
ARN: aws.String("arn-goose"),
}
mockAwsErr := awserr.New(secretsmanager.ErrCodeResourceExistsException, "", nil)
tests := map[string]struct {
inSecretName string
inSecretString string
callMock func(m *mocks.Mockapi)
expectedError error
}{
"should wrap error returned by CreateSecret": {
inSecretName: mockSecretName,
inSecretString: mockSecretString,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().CreateSecret(&secretsmanager.CreateSecretInput{
Name: aws.String(mockSecretName),
SecretString: aws.String(mockSecretString),
Tags: []*secretsmanager.Tag{},
}).Return(nil, mockError)
},
expectedError: fmt.Errorf("create secret %s: %w", mockSecretName, mockError),
},
"should return no error if secret already exists": {
inSecretName: mockSecretName,
inSecretString: mockSecretString,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().CreateSecret(&secretsmanager.CreateSecretInput{
Name: aws.String(mockSecretName),
SecretString: aws.String(mockSecretString),
Tags: []*secretsmanager.Tag{},
}).Return(nil, mockAwsErr)
},
expectedError: &ErrSecretAlreadyExists{
secretName: mockSecretName,
parentErr: mockAwsErr,
},
},
"should return no error if successful": {
inSecretName: mockSecretName,
inSecretString: mockSecretString,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().CreateSecret(&secretsmanager.CreateSecretInput{
Name: aws.String(mockSecretName),
SecretString: aws.String(mockSecretString),
Tags: []*secretsmanager.Tag{},
}).Return(mockOutput, nil)
},
expectedError: nil,
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSecretsManager := mocks.NewMockapi(ctrl)
sm := SecretsManager{
secretsManager: mockSecretsManager,
}
tc.callMock(mockSecretsManager)
// WHEN
oldSecretTags := secretTags
defer func() { secretTags = oldSecretTags }()
secretTags = func() []*secretsmanager.Tag {
return []*secretsmanager.Tag{}
}
_, err := sm.CreateSecret(tc.inSecretName, tc.inSecretString)
// THEN
require.Equal(t, tc.expectedError, err)
})
}
}
func TestSecretsManager_DeleteSecret(t *testing.T) {
mockSecretName := "github-token-backend-badgoose"
mockError := errors.New("mockError")
tests := map[string]struct {
inSecretName string
callMock func(m *mocks.Mockapi)
expectedError error
}{
"should wrap error returned by DeleteSecret": {
inSecretName: mockSecretName,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().DeleteSecret(&secretsmanager.DeleteSecretInput{
SecretId: aws.String(mockSecretName),
ForceDeleteWithoutRecovery: aws.Bool(true),
}).Return(nil, mockError)
},
expectedError: fmt.Errorf("delete secret %s from secrets manager: %w", mockSecretName, mockError),
},
"should return no error if successful": {
inSecretName: mockSecretName,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().DeleteSecret(&secretsmanager.DeleteSecretInput{
SecretId: aws.String(mockSecretName),
ForceDeleteWithoutRecovery: aws.Bool(true),
}).Return(nil, nil)
},
expectedError: nil,
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSecretsManager := mocks.NewMockapi(ctrl)
sm := SecretsManager{
secretsManager: mockSecretsManager,
}
tc.callMock(mockSecretsManager)
// WHEN
err := sm.DeleteSecret(tc.inSecretName)
// THEN
require.Equal(t, tc.expectedError, err)
})
}
}
func TestSecretsManager_DescribeSecret(t *testing.T) {
mockTime := time.Now()
mockSecretName := "github-token-backend-badgoose"
mockError := errors.New("mockError")
mockAPIOutput := &secretsmanager.DescribeSecretOutput{
CreatedDate: aws.Time(mockTime),
Name: aws.String(mockSecretName),
Tags: []*secretsmanager.Tag{},
}
mockOutput := &DescribeSecretOutput{
CreatedDate: aws.Time(mockTime),
Name: aws.String(mockSecretName),
Tags: []*secretsmanager.Tag{},
}
mockAwsErr := awserr.New(secretsmanager.ErrCodeResourceNotFoundException, "", nil)
tests := map[string]struct {
inSecretName string
callMock func(m *mocks.Mockapi)
expectedResp *DescribeSecretOutput
expectedError error
}{
"should wrap error returned by DescribeSecret": {
inSecretName: mockSecretName,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeSecret(&secretsmanager.DescribeSecretInput{
SecretId: aws.String(mockSecretName),
}).Return(nil, mockError)
},
expectedError: fmt.Errorf("describe secret %s: %w", mockSecretName, mockError),
},
"should return no error if secret is not found": {
inSecretName: mockSecretName,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeSecret(&secretsmanager.DescribeSecretInput{
SecretId: aws.String(mockSecretName),
}).Return(nil, mockAwsErr)
},
expectedError: &ErrSecretNotFound{
secretName: mockSecretName,
parentErr: mockAwsErr,
},
},
"should return no error if successful": {
inSecretName: mockSecretName,
callMock: func(m *mocks.Mockapi) {
m.EXPECT().DescribeSecret(&secretsmanager.DescribeSecretInput{
SecretId: aws.String(mockSecretName),
}).Return(mockAPIOutput, nil)
},
expectedResp: mockOutput,
expectedError: nil,
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSecretsManager := mocks.NewMockapi(ctrl)
sm := SecretsManager{
secretsManager: mockSecretsManager,
}
tc.callMock(mockSecretsManager)
// WHEN
oldSecretTags := secretTags
defer func() { secretTags = oldSecretTags }()
secretTags = func() []*secretsmanager.Tag {
return []*secretsmanager.Tag{}
}
resp, err := sm.DescribeSecret(tc.inSecretName)
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.expectedResp, resp)
}
})
}
}
| 254 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/secretsmanager/secretsmanager.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
secretsmanager "github.com/aws/aws-sdk-go/service/secretsmanager"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// CreateSecret mocks base method.
func (m *Mockapi) CreateSecret(arg0 *secretsmanager.CreateSecretInput) (*secretsmanager.CreateSecretOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateSecret", arg0)
ret0, _ := ret[0].(*secretsmanager.CreateSecretOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateSecret indicates an expected call of CreateSecret.
func (mr *MockapiMockRecorder) CreateSecret(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*Mockapi)(nil).CreateSecret), arg0)
}
// DeleteSecret mocks base method.
func (m *Mockapi) DeleteSecret(arg0 *secretsmanager.DeleteSecretInput) (*secretsmanager.DeleteSecretOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteSecret", arg0)
ret0, _ := ret[0].(*secretsmanager.DeleteSecretOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeleteSecret indicates an expected call of DeleteSecret.
func (mr *MockapiMockRecorder) DeleteSecret(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*Mockapi)(nil).DeleteSecret), arg0)
}
// DescribeSecret mocks base method.
func (m *Mockapi) DescribeSecret(input *secretsmanager.DescribeSecretInput) (*secretsmanager.DescribeSecretOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeSecret", input)
ret0, _ := ret[0].(*secretsmanager.DescribeSecretOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeSecret indicates an expected call of DescribeSecret.
func (mr *MockapiMockRecorder) DescribeSecret(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecret", reflect.TypeOf((*Mockapi)(nil).DescribeSecret), input)
}
| 81 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package sessions
import (
"fmt"
"strings"
"github.com/aws/copilot-cli/internal/pkg/term/color"
)
type errMissingRegion struct{}
// Implements error interface.
func (e *errMissingRegion) Error() string {
return "missing region configuration"
}
// RecommendActions returns recommended actions to be taken after the error.
// Implements main.actionRecommender interface.
func (e *errMissingRegion) RecommendActions() string { // implements new actionRecommender interface.
return fmt.Sprintf(`It looks like your AWS region configuration is missing.
- We recommend including your region configuration in the "~/.aws/config" file.
- Alternatively, you can run %s to set the environment variable.
More information: https://aws.github.io/copilot-cli/docs/credentials/`, color.HighlightCode("export AWS_REGION=<application region>"))
}
type errCredRetrieval struct {
profile string
parentErr error
}
// Implements error interface.
func (e *errCredRetrieval) Error() string {
return e.parentErr.Error()
}
// RecommendActions returns recommended actions to be taken after the error.
// Implements main.actionRecommender interface.
func (e *errCredRetrieval) RecommendActions() string {
notice := "It looks like your AWS credentials are misconfigured or missing"
if e.profile != "" {
notice = fmt.Sprintf("It looks like your AWS profile [%s] is misconfigured or missing", e.profile)
}
return fmt.Sprintf(`%s:
More information: https://aws.github.io/copilot-cli/docs/credentials/`, notice)
}
func isCredRetrievalErr(err error) bool {
return strings.Contains(err.Error(), "context deadline exceeded") || strings.Contains(err.Error(), "NoCredentialProviders")
}
| 53 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package sessions provides functions that return AWS sessions to use in the AWS SDK.
package sessions
import (
"context"
"fmt"
"net/http"
"runtime"
"sync"
"time"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials/stscreds"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/aws/session"
)
// Timeout settings.
const (
maxRetriesOnRecoverableFailures = 8 // Default provided by SDK is 3 which means requests are retried up to only 2 seconds.
credsTimeout = 10 * time.Second
clientTimeout = 30 * time.Second
)
// User-Agent settings.
const (
userAgentProductName = "aws-copilot"
)
// Provider provides methods to create sessions.
// Once a session is created, it's cached locally so that the same session is not re-created.
type Provider struct {
defaultSess *session.Session
// Metadata associated with the provider.
userAgentExtras []string
sessionValidator sessionValidator
}
type sessionValidator interface {
ValidateCredentials(sess *session.Session) (credentials.Value, error)
}
var instance *Provider
var once sync.Once
// ImmutableProvider returns an immutable session Provider with the options applied.
func ImmutableProvider(options ...func(*Provider)) *Provider {
once.Do(func() {
instance = &Provider{
sessionValidator: &validator{},
}
for _, option := range options {
option(instance)
}
})
return instance
}
// UserAgentExtras augments a session provider with additional User-Agent extras.
func UserAgentExtras(extras ...string) func(*Provider) {
return func(p *Provider) {
p.userAgentExtras = append(p.userAgentExtras, extras...)
}
}
// UserAgentExtras adds additional User-Agent extras to cached sessions and any new sessions.
func (p *Provider) UserAgentExtras(extras ...string) {
p.userAgentExtras = append(p.userAgentExtras, extras...)
if p.defaultSess != nil {
p.defaultSess.Handlers.Build.SwapNamed(p.userAgentHandler())
}
}
// Default returns a session configured against the "default" AWS profile.
// Default assumes that a region must be present with a session, otherwise it returns an error.
func (p *Provider) Default() (*session.Session, error) {
sess, err := p.defaultSession()
if err != nil {
return nil, err
}
if aws.StringValue(sess.Config.Region) == "" {
return nil, &errMissingRegion{}
}
return sess, nil
}
// DefaultWithRegion returns a session configured against the "default" AWS profile and the input region.
func (p *Provider) DefaultWithRegion(region string) (*session.Session, error) {
sess, err := session.NewSessionWithOptions(session.Options{
Config: *newConfig().WithRegion(region),
SharedConfigState: session.SharedConfigEnable,
AssumeRoleTokenProvider: stscreds.StdinTokenProvider,
})
if err != nil {
return nil, err
}
sess.Handlers.Build.PushBackNamed(p.userAgentHandler())
return sess, nil
}
// FromProfile returns a session configured against the input profile name.
func (p *Provider) FromProfile(name string) (*session.Session, error) {
sess, err := session.NewSessionWithOptions(session.Options{
Config: *newConfig(),
SharedConfigState: session.SharedConfigEnable,
Profile: name,
AssumeRoleTokenProvider: stscreds.StdinTokenProvider,
})
if err != nil {
return nil, err
}
if aws.StringValue(sess.Config.Region) == "" {
return nil, &errMissingRegion{}
}
if _, err := p.sessionValidator.ValidateCredentials(sess); err != nil {
if isCredRetrievalErr(err) {
return nil, &errCredRetrieval{profile: name, parentErr: err}
}
return nil, err
}
sess.Handlers.Build.PushBackNamed(p.userAgentHandler())
return sess, nil
}
// FromRole returns a session configured against the input role and region.
func (p *Provider) FromRole(roleARN string, region string) (*session.Session, error) {
defaultSession, err := p.defaultSession()
if err != nil {
return nil, fmt.Errorf("create default session: %w", err)
}
creds := stscreds.NewCredentials(defaultSession, roleARN)
sess, err := session.NewSession(
newConfig().
WithCredentials(creds).
WithRegion(region),
)
if err != nil {
return nil, err
}
sess.Handlers.Build.PushBackNamed(p.userAgentHandler())
return sess, nil
}
// FromStaticCreds returns a session from static credentials.
func (p *Provider) FromStaticCreds(accessKeyID, secretAccessKey, sessionToken string) (*session.Session, error) {
conf := newConfig()
conf.Credentials = credentials.NewStaticCredentials(accessKeyID, secretAccessKey, sessionToken)
sess, err := session.NewSessionWithOptions(session.Options{
Config: *conf,
})
if err != nil {
return nil, fmt.Errorf("create session from static credentials: %w", err)
}
sess.Handlers.Build.PushBackNamed(p.userAgentHandler())
return sess, nil
}
func (p *Provider) defaultSession() (*session.Session, error) {
if p.defaultSess != nil {
return p.defaultSess, nil
}
sess, err := session.NewSessionWithOptions(session.Options{
Config: *newConfig(),
SharedConfigState: session.SharedConfigEnable,
AssumeRoleTokenProvider: stscreds.StdinTokenProvider,
})
if err != nil {
return nil, err
}
if _, err = p.sessionValidator.ValidateCredentials(sess); err != nil {
if isCredRetrievalErr(err) {
return nil, &errCredRetrieval{parentErr: err}
}
return nil, err
}
sess.Handlers.Build.PushBackNamed(p.userAgentHandler())
p.defaultSess = sess
return sess, nil
}
// AreCredsFromEnvVars returns true if the session's credentials provider is environment variables, false otherwise.
// An error is returned if the credentials are invalid or the request times out.
func AreCredsFromEnvVars(sess *session.Session) (bool, error) {
v, err := Creds(sess)
if err != nil {
return false, err
}
return v.ProviderName == session.EnvProviderName, nil
}
// Creds returns the credential values from a session.
func Creds(sess *session.Session) (credentials.Value, error) {
ctx, cancel := context.WithTimeout(context.Background(), credsTimeout)
defer cancel()
v, err := sess.Config.Credentials.GetWithContext(ctx)
if err != nil {
return credentials.Value{}, fmt.Errorf("get credentials of session: %w", err)
}
return v, nil
}
// newConfig returns a config with an end-to-end request timeout and verbose credentials errors.
func newConfig() *aws.Config {
c := &http.Client{
Timeout: clientTimeout,
}
return aws.NewConfig().
WithHTTPClient(c).
WithCredentialsChainVerboseErrors(true).
WithMaxRetries(maxRetriesOnRecoverableFailures)
}
// userAgentHandler returns a http request handler that sets the AWS Copilot custom user agent to all aws requests.
// The User-Agent is of the format "product/version (extra1; extra2; ...; extraN)".
func (p *Provider) userAgentHandler() request.NamedHandler {
extras := append([]string{runtime.GOOS}, p.userAgentExtras...)
return request.NamedHandler{
Name: "UserAgentHandler",
Fn: request.MakeAddToUserAgentHandler(userAgentProductName, version.Version, extras...),
}
}
type validator struct{}
func (v *validator) ValidateCredentials(sess *session.Session) (credentials.Value, error) {
ctx, cancel := context.WithTimeout(context.Background(), credsTimeout)
defer cancel()
return sess.Config.Credentials.GetWithContext(ctx)
}
| 241 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package sessions
import (
"context"
"errors"
"os"
"testing"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions/mocks"
"github.com/golang/mock/gomock"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/stretchr/testify/require"
)
// mockProvider implements the AWS SDK's credentials.Provider interface.
type mockProvider struct {
value credentials.Value
err error
}
func (m mockProvider) Retrieve() (credentials.Value, error) {
if m.err != nil {
return credentials.Value{}, m.err
}
return m.value, nil
}
func (m mockProvider) IsExpired() bool {
return false
}
func TestAreCredsFromEnvVars(t *testing.T) {
testCases := map[string]struct {
inSess *session.Session
wantedOk bool
wantedErr error
}{
"returns true if the credentials come from environment variables": {
inSess: &session.Session{
Config: &aws.Config{
Credentials: credentials.NewCredentials(mockProvider{
value: credentials.Value{
ProviderName: session.EnvProviderName,
},
err: nil,
}),
},
},
wantedOk: true,
},
"returns false if credentials are provided from a named profile": {
inSess: &session.Session{
Config: &aws.Config{
Credentials: credentials.NewCredentials(mockProvider{
value: credentials.Value{
ProviderName: credentials.SharedCredsProviderName,
},
err: nil,
}),
},
},
wantedOk: false,
},
"returns a wrapped error if fails to fetch credentials": {
inSess: &session.Session{
Config: &aws.Config{
Credentials: credentials.NewCredentials(mockProvider{
value: credentials.Value{},
err: errors.New("some error"),
}),
},
},
wantedErr: errors.New("get credentials of session: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ok, err := AreCredsFromEnvVars(tc.inSess)
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.Equal(t, tc.wantedOk, ok)
}
})
}
}
func TestCreds(t *testing.T) {
testCases := map[string]struct {
inSess *session.Session
wantedCreds credentials.Value
wantedErr error
}{
"returns values if provider is valid": {
inSess: &session.Session{
Config: &aws.Config{
Credentials: credentials.NewCredentials(mockProvider{
value: credentials.Value{
AccessKeyID: "abc",
SecretAccessKey: "def",
},
err: nil,
}),
},
},
wantedCreds: credentials.Value{
AccessKeyID: "abc",
SecretAccessKey: "def",
},
},
"returns a wrapped error if fails to fetch credentials": {
inSess: &session.Session{
Config: &aws.Config{
Credentials: credentials.NewCredentials(mockProvider{
value: credentials.Value{},
err: errors.New("some error"),
}),
},
},
wantedErr: errors.New("get credentials of session: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
creds, err := Creds(tc.inSess)
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.Equal(t, tc.wantedCreds, creds)
}
})
}
}
func TestProvider_FromProfile(t *testing.T) {
t.Run("error if region is missing", func(t *testing.T) {
ogRegion := os.Getenv("AWS_REGION")
ogDefaultRegion := os.Getenv("AWS_DEFAULT_REGION")
defer func() {
err := restoreEnvVar("AWS_REGION", ogRegion)
require.NoError(t, err)
err = restoreEnvVar("AWS_DEFAULT_REGION", ogDefaultRegion)
require.NoError(t, err)
}()
// Since "walk-like-an-egyptian" is (very likely) a non-existent profile, whether the region information
// is missing depends on whether the `AWS_REGION` environment variable is set.
err := os.Unsetenv("AWS_REGION")
require.NoError(t, err)
err = os.Unsetenv("AWS_DEFAULT_REGION")
require.NoError(t, err)
// When
sess, err := ImmutableProvider().FromProfile("walk-like-an-egyptian")
// THEN
require.NotNil(t, err)
require.EqualError(t, errors.New("missing region configuration"), err.Error())
require.Nil(t, sess)
})
t.Run("region information present", func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := mocks.NewMocksessionValidator(ctrl)
m.EXPECT().ValidateCredentials(gomock.Any()).Return(credentials.Value{}, nil)
ogRegion := os.Getenv("AWS_REGION")
defer func() {
err := restoreEnvVar("AWS_REGION", ogRegion)
require.NoError(t, err)
}()
// Since "walk-like-an-egyptian" is (very likely) a non-existent profile, whether the region information
// is missing depends on whether the `AWS_REGION` environment variable is set.
err := os.Setenv("AWS_REGION", "us-west-2")
require.NoError(t, err)
// WHEN
provider := &Provider{
sessionValidator: m,
}
sess, err := provider.FromProfile("walk-like-an-egyptian")
// THEN
require.NoError(t, err)
require.Equal(t, "us-west-2", *sess.Config.Region)
})
t.Run("session credentials are incorrect", func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := mocks.NewMocksessionValidator(ctrl)
m.EXPECT().ValidateCredentials(gomock.Any()).Return(credentials.Value{}, context.DeadlineExceeded)
ogRegion := os.Getenv("AWS_REGION")
defer func() {
err := restoreEnvVar("AWS_REGION", ogRegion)
require.NoError(t, err)
}()
// Since "walk-like-an-egyptian" is (very likely) a non-existent profile, whether the region information
// is missing depends on whether the `AWS_REGION` environment variable is set.
err := os.Setenv("AWS_REGION", "us-west-2")
require.NoError(t, err)
// WHEN
provider := &Provider{
sessionValidator: m,
}
sess, err := provider.FromProfile("walk-like-an-egyptian")
// THEN
require.EqualError(t, err, "context deadline exceeded")
require.Nil(t, sess)
})
}
func restoreEnvVar(key string, originalValue string) error {
if originalValue == "" {
return os.Unsetenv(key)
}
return os.Setenv(key, originalValue)
}
| 246 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/sessions/sessions.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
credentials "github.com/aws/aws-sdk-go/aws/credentials"
session "github.com/aws/aws-sdk-go/aws/session"
gomock "github.com/golang/mock/gomock"
)
// MocksessionValidator is a mock of sessionValidator interface.
type MocksessionValidator struct {
ctrl *gomock.Controller
recorder *MocksessionValidatorMockRecorder
}
// MocksessionValidatorMockRecorder is the mock recorder for MocksessionValidator.
type MocksessionValidatorMockRecorder struct {
mock *MocksessionValidator
}
// NewMocksessionValidator creates a new mock instance.
func NewMocksessionValidator(ctrl *gomock.Controller) *MocksessionValidator {
mock := &MocksessionValidator{ctrl: ctrl}
mock.recorder = &MocksessionValidatorMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MocksessionValidator) EXPECT() *MocksessionValidatorMockRecorder {
return m.recorder
}
// ValidateCredentials mocks base method.
func (m *MocksessionValidator) ValidateCredentials(sess *session.Session) (credentials.Value, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateCredentials", sess)
ret0, _ := ret[0].(credentials.Value)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ValidateCredentials indicates an expected call of ValidateCredentials.
func (mr *MocksessionValidatorMockRecorder) ValidateCredentials(sess interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateCredentials", reflect.TypeOf((*MocksessionValidator)(nil).ValidateCredentials), sess)
}
| 52 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package ssm
import "fmt"
// ErrParameterAlreadyExists occurs when the parameter with name already existed.
type ErrParameterAlreadyExists struct {
name string
}
func (e *ErrParameterAlreadyExists) Error() string {
return fmt.Sprintf("parameter %s already exists", e.name)
}
| 16 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package ssm provides a client to make API requests to Amazon Systems Manager.
package ssm
import (
"errors"
"fmt"
"sort"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
)
type api interface {
PutParameter(input *ssm.PutParameterInput) (*ssm.PutParameterOutput, error)
AddTagsToResource(input *ssm.AddTagsToResourceInput) (*ssm.AddTagsToResourceOutput, error)
}
// SSM wraps an AWS SSM client.
type SSM struct {
client api
}
// New returns a SSM service configured against the input session.
func New(s *session.Session) *SSM {
return &SSM{
client: ssm.New(s),
}
}
// PutSecretInput contains fields needed to create or update a secret.
type PutSecretInput struct {
Name string
Value string
Overwrite bool
Tags map[string]string
}
// PutSecretOutput wraps an ssm PutParameterOutput struct.
type PutSecretOutput ssm.PutParameterOutput
// PutSecret tries to create the secret, and overwrites it if the secret exists and that `Overwrite` is true.
// ErrParameterAlreadyExists is returned if the secret exists and `Overwrite` is false.
func (s *SSM) PutSecret(in PutSecretInput) (*PutSecretOutput, error) {
// First try to create the secret with the tags.
out, err := s.createSecret(in)
if err == nil {
return out, nil
}
// If the parameter already exists and we want to overwrite, we try to overwrite it.
var errParameterExists *ErrParameterAlreadyExists
if errors.As(err, &errParameterExists) && in.Overwrite {
return s.overwriteSecret(in)
}
return nil, err
}
func (s *SSM) createSecret(in PutSecretInput) (*PutSecretOutput, error) {
// Create a secret while adding the tags in a single call instead of separate calls to `PutParameter` and
// `AddTagsToResource` so that there won't be a case where the parameter is created while the tags are not added.
tags := convertTags(in.Tags)
input := &ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(in.Name),
Value: aws.String(in.Value),
Tags: tags,
}
output, err := s.client.PutParameter(input)
if err == nil {
return (*PutSecretOutput)(output), nil
}
if awsErr, ok := err.(awserr.Error); ok {
if awsErr.Code() == ssm.ErrCodeParameterAlreadyExists {
return nil, &ErrParameterAlreadyExists{in.Name}
}
}
return nil, fmt.Errorf("create parameter %s: %w", in.Name, err)
}
func (s *SSM) overwriteSecret(in PutSecretInput) (*PutSecretOutput, error) {
// SSM API does not allow `Overwrite` to be true while `Tags` are not nil, so we have to overwrite the resource and
// add the tags in two separate calls.
input := &ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(in.Name),
Value: aws.String(in.Value),
Overwrite: aws.Bool(in.Overwrite),
}
output, err := s.client.PutParameter(input)
if err != nil {
return nil, fmt.Errorf("update parameter %s: %w", in.Name, err)
}
tags := convertTags(in.Tags)
_, err = s.client.AddTagsToResource(&ssm.AddTagsToResourceInput{
ResourceType: aws.String(ssm.ResourceTypeForTaggingParameter),
ResourceId: aws.String(in.Name),
Tags: tags,
})
if err != nil {
return nil, fmt.Errorf("add tags to resource %s: %w", in.Name, err)
}
return (*PutSecretOutput)(output), nil
}
func convertTags(inTags map[string]string) []*ssm.Tag {
// Sort the map so that the unit test won't be flaky.
keys := make([]string, 0, len(inTags))
for k := range inTags {
keys = append(keys, k)
}
sort.Strings(keys)
var tags []*ssm.Tag
for _, key := range keys {
tags = append(tags, &ssm.Tag{
Key: aws.String(key),
Value: aws.String(inTags[key]),
})
}
return tags
}
| 135 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package ssm
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/ssm/mocks"
"github.com/golang/mock/gomock"
)
func TestSSM_PutSecret(t *testing.T) {
const (
mockApp = "myapp"
mockEnv = "myenv"
)
testCases := map[string]struct {
inPutSecretInput PutSecretInput
mockClient func(*mocks.Mockapi)
wantedOut *PutSecretOutput
wantedError error
}{
"attempt to create a new secret": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
},
mockClient: func(m *mocks.Mockapi) {
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(&ssm.PutParameterOutput{
Tier: aws.String("Standard"),
Version: aws.Int64(1),
}, nil)
},
wantedOut: &PutSecretOutput{
Tier: aws.String("Standard"),
Version: aws.Int64(1),
},
},
"attempt to create a new secret even if overwrite is true": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
Overwrite: true,
},
mockClient: func(m *mocks.Mockapi) {
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(&ssm.PutParameterOutput{
Tier: aws.String("Standard"),
Version: aws.Int64(1),
}, nil)
},
wantedOut: &PutSecretOutput{
Tier: aws.String("Standard"),
Version: aws.Int64(1),
},
},
"no overwrite attempt when overwrite is false and creation fails because the secret exists": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
},
mockClient: func(m *mocks.Mockapi) {
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(nil, awserr.New(ssm.ErrCodeParameterAlreadyExists, "parameter already exists", fmt.Errorf("parameter already exists")))
},
wantedError: &ErrParameterAlreadyExists{"/copilot/myapp/myenv/secrets/db-password"},
},
"no overwrite attempt when overwrite is false and creation fails because of other errors": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
},
mockClient: func(m *mocks.Mockapi) {
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(nil, errors.New("some error"))
},
wantedError: errors.New("create parameter /copilot/myapp/myenv/secrets/db-password: some error"),
},
"no overwrite attempt when overwrite is true and creation fails because of other errors": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
Overwrite: true,
},
mockClient: func(m *mocks.Mockapi) {
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(nil, errors.New("some error"))
},
wantedError: errors.New("create parameter /copilot/myapp/myenv/secrets/db-password: some error"),
},
"attempt to overwrite only when overwrite is true and creation fails because the secret exists": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
Overwrite: true,
},
mockClient: func(m *mocks.Mockapi) {
gomock.InOrder(
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(nil, awserr.New(ssm.ErrCodeParameterAlreadyExists, "parameter already exists", fmt.Errorf("parameter already exists"))),
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Overwrite: aws.Bool(true),
}).Return(&ssm.PutParameterOutput{
Tier: aws.String("Standard"),
Version: aws.Int64(3),
}, nil),
m.EXPECT().AddTagsToResource(&ssm.AddTagsToResourceInput{
ResourceType: aws.String(ssm.ResourceTypeForTaggingParameter),
ResourceId: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Tags: convertTags(map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
}),
}).Return(nil, nil),
)
},
wantedOut: &PutSecretOutput{
Tier: aws.String("Standard"),
Version: aws.Int64(3),
},
},
"failed to add tags during an overwrite operation": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
Overwrite: true,
},
mockClient: func(m *mocks.Mockapi) {
gomock.InOrder(
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(nil, awserr.New(ssm.ErrCodeParameterAlreadyExists, "parameter already exists", fmt.Errorf("parameter already exists"))),
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Overwrite: aws.Bool(true),
}).Return(&ssm.PutParameterOutput{
Tier: aws.String("Standard"),
Version: aws.Int64(3),
}, nil),
m.EXPECT().AddTagsToResource(&ssm.AddTagsToResourceInput{
ResourceType: aws.String(ssm.ResourceTypeForTaggingParameter),
ResourceId: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Tags: convertTags(map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
}),
}).Return(nil, errors.New("some error")),
)
},
wantedError: errors.New("add tags to resource /copilot/myapp/myenv/secrets/db-password: some error"),
},
"fail to overwrite": {
inPutSecretInput: PutSecretInput{
Name: fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv),
Value: "super secure password",
Tags: map[string]string{
deploy.AppTagKey: mockApp,
deploy.EnvTagKey: mockEnv,
},
Overwrite: true,
},
mockClient: func(m *mocks.Mockapi) {
gomock.InOrder(
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Tags: []*ssm.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockApp),
},
{
Key: aws.String(deploy.EnvTagKey),
Value: aws.String(mockEnv),
},
},
}).Return(nil, awserr.New(ssm.ErrCodeParameterAlreadyExists, "parameter already exists", fmt.Errorf("parameter already exists"))),
m.EXPECT().PutParameter(&ssm.PutParameterInput{
DataType: aws.String("text"),
Type: aws.String("SecureString"),
Name: aws.String(fmt.Sprintf("/copilot/%s/%s/secrets/db-password", mockApp, mockEnv)),
Value: aws.String("super secure password"),
Overwrite: aws.Bool(true),
}).Return(nil, errors.New("some error")),
)
},
wantedError: errors.New("update parameter /copilot/myapp/myenv/secrets/db-password: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSSMClient := mocks.NewMockapi(ctrl)
client := SSM{
client: mockSSMClient,
}
tc.mockClient(mockSSMClient)
got, err := client.PutSecret(tc.inPutSecretInput)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedOut, got)
}
})
}
}
| 364 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/ssm/ssm.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
ssm "github.com/aws/aws-sdk-go/service/ssm"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// AddTagsToResource mocks base method.
func (m *Mockapi) AddTagsToResource(input *ssm.AddTagsToResourceInput) (*ssm.AddTagsToResourceOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddTagsToResource", input)
ret0, _ := ret[0].(*ssm.AddTagsToResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AddTagsToResource indicates an expected call of AddTagsToResource.
func (mr *MockapiMockRecorder) AddTagsToResource(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResource", reflect.TypeOf((*Mockapi)(nil).AddTagsToResource), input)
}
// PutParameter mocks base method.
func (m *Mockapi) PutParameter(input *ssm.PutParameterInput) (*ssm.PutParameterOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PutParameter", input)
ret0, _ := ret[0].(*ssm.PutParameterOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PutParameter indicates an expected call of PutParameter.
func (mr *MockapiMockRecorder) PutParameter(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutParameter", reflect.TypeOf((*Mockapi)(nil).PutParameter), input)
}
| 66 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package stepfunctions provides a client to make API requests to Amazon Step Functions.
package stepfunctions
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/sfn"
)
type api interface {
DescribeStateMachine(input *sfn.DescribeStateMachineInput) (*sfn.DescribeStateMachineOutput, error)
StartExecution(input *sfn.StartExecutionInput) (*sfn.StartExecutionOutput, error)
}
// StepFunctions wraps an AWS StepFunctions client.
type StepFunctions struct {
client api
}
// New returns StepFunctions configured against the input session.
func New(s *session.Session) *StepFunctions {
return &StepFunctions{
client: sfn.New(s),
}
}
// StateMachineDefinition returns the JSON-based state machine definition.
func (s *StepFunctions) StateMachineDefinition(stateMachineARN string) (string, error) {
out, err := s.client.DescribeStateMachine(&sfn.DescribeStateMachineInput{
StateMachineArn: aws.String(stateMachineARN),
})
if err != nil {
return "", fmt.Errorf("describe state machine: %w", err)
}
return aws.StringValue(out.Definition), nil
}
//Execute starts a state machine execution.
func (s *StepFunctions) Execute(arn string) error {
_, err := s.client.StartExecution(&sfn.StartExecutionInput{
StateMachineArn: aws.String(arn),
})
if err != nil {
return fmt.Errorf("execute state machine %s: %w", arn, err)
}
return nil
}
| 54 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package stepfunctions provides a client to make API requests to Amazon Step Functions.
package stepfunctions
import (
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/sfn"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/aws/stepfunctions/mocks"
"github.com/golang/mock/gomock"
)
func TestStepFunctions_StateMachineDefinition(t *testing.T) {
testCases := map[string]struct {
inStateMachineARN string
mockStepFunctionsClient func(m *mocks.Mockapi)
wantedError error
wantedDefinition string
}{
"fail to describe state machine": {
inStateMachineARN: "ninth inning",
mockStepFunctionsClient: func(m *mocks.Mockapi) {
m.EXPECT().DescribeStateMachine(&sfn.DescribeStateMachineInput{
StateMachineArn: aws.String("ninth inning"),
}).Return(nil, errors.New("some error"))
},
wantedError: errors.New("describe state machine: some error"),
},
"success": {
inStateMachineARN: "ninth inning",
mockStepFunctionsClient: func(m *mocks.Mockapi) {
m.EXPECT().DescribeStateMachine(&sfn.DescribeStateMachineInput{
StateMachineArn: aws.String("ninth inning"),
}).Return(&sfn.DescribeStateMachineOutput{
Definition: aws.String("{\n \"Version\": \"42\",\n \"Comment\": \"very important comment\"\n}"),
}, nil)
},
wantedDefinition: "{\n \"Version\": \"42\",\n \"Comment\": \"very important comment\"\n}",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStepFunctionsClient := mocks.NewMockapi(ctrl)
tc.mockStepFunctionsClient(mockStepFunctionsClient)
sfn := StepFunctions{
client: mockStepFunctionsClient,
}
out, err := sfn.StateMachineDefinition(tc.inStateMachineARN)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
} else {
require.Equal(t, tc.wantedDefinition, out)
}
})
}
}
func TestStepFunctions_Execute(t *testing.T) {
testCases := map[string]struct {
inStateMachineARN string
mockStepFunctionsClient func(m *mocks.Mockapi)
wantedError error
}{
"fail to execute state machine": {
inStateMachineARN: "forca barca",
mockStepFunctionsClient: func(m *mocks.Mockapi) {
m.EXPECT().StartExecution(&sfn.StartExecutionInput{
StateMachineArn: aws.String("forca barca"),
}).Return(nil, errors.New("some error"))
},
wantedError: errors.New("execute state machine forca barca: some error"),
},
"success": {
inStateMachineARN: "forca barca",
mockStepFunctionsClient: func(m *mocks.Mockapi) {
m.EXPECT().StartExecution(&sfn.StartExecutionInput{
StateMachineArn: aws.String("forca barca"),
}).Return(&sfn.StartExecutionOutput{
ExecutionArn: aws.String("forca barca"),
StartDate: func() *time.Time { t := time.Now(); return &t }(),
}, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStepFunctionsClient := mocks.NewMockapi(ctrl)
tc.mockStepFunctionsClient(mockStepFunctionsClient)
sfn := StepFunctions{
client: mockStepFunctionsClient,
}
err := sfn.Execute(tc.inStateMachineARN)
if tc.wantedError != nil {
require.EqualError(t, tc.wantedError, err.Error())
}
})
}
}
| 122 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/aws/stepfunctions/stepfunctions.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
sfn "github.com/aws/aws-sdk-go/service/sfn"
gomock "github.com/golang/mock/gomock"
)
// Mockapi is a mock of api interface.
type Mockapi struct {
ctrl *gomock.Controller
recorder *MockapiMockRecorder
}
// MockapiMockRecorder is the mock recorder for Mockapi.
type MockapiMockRecorder struct {
mock *Mockapi
}
// NewMockapi creates a new mock instance.
func NewMockapi(ctrl *gomock.Controller) *Mockapi {
mock := &Mockapi{ctrl: ctrl}
mock.recorder = &MockapiMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockapi) EXPECT() *MockapiMockRecorder {
return m.recorder
}
// DescribeStateMachine mocks base method.
func (m *Mockapi) DescribeStateMachine(input *sfn.DescribeStateMachineInput) (*sfn.DescribeStateMachineOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeStateMachine", input)
ret0, _ := ret[0].(*sfn.DescribeStateMachineOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeStateMachine indicates an expected call of DescribeStateMachine.
func (mr *MockapiMockRecorder) DescribeStateMachine(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStateMachine", reflect.TypeOf((*Mockapi)(nil).DescribeStateMachine), input)
}
// StartExecution mocks base method.
func (m *Mockapi) StartExecution(input *sfn.StartExecutionInput) (*sfn.StartExecutionOutput, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StartExecution", input)
ret0, _ := ret[0].(*sfn.StartExecutionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StartExecution indicates an expected call of StartExecution.
func (mr *MockapiMockRecorder) StartExecution(input interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartExecution", reflect.TypeOf((*Mockapi)(nil).StartExecution), input)
}
| 66 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package tags implements simple functions to manipulate AWS resource tags.
package tags
// Merge creates and returns a new map by adding tags in the order provided.
func Merge(tags ...map[string]string) map[string]string {
merged := make(map[string]string)
for _, t := range tags {
for k, v := range t {
merged[k] = v
}
}
return merged
}
| 17 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package tags
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestMerge(t *testing.T) {
// GIVEN
projectTags := map[string]string{
"owner": "boss",
}
envTags := map[string]string{
"owner": "boss2",
"stage": "test",
}
appTags := map[string]string{
"owner": "boss3",
"stage": "test2",
"service": "gateway",
}
// WHEN
out := Merge(projectTags, envTags, appTags)
// THEN
require.Equal(t, map[string]string{
"owner": "boss3",
"stage": "test2",
"service": "gateway",
}, out)
// Ensure original tags are not modified.
require.Equal(t, map[string]string{
"owner": "boss",
}, projectTags)
require.Equal(t, map[string]string{
"owner": "boss2",
"stage": "test",
}, envTags)
}
| 45 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"github.com/spf13/cobra"
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
)
// BuildAppCmd builds the top level app command and related subcommands.
func BuildAppCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "app",
Short: `Commands for applications.
Applications are a collection of services and environments.`,
Long: `Commands for applications.
Applications are a collection of services and environments.`,
}
cmd.AddCommand(buildAppInitCommand())
cmd.AddCommand(buildAppListCommand())
cmd.AddCommand(buildAppShowCmd())
cmd.AddCommand(buildAppDeleteCommand())
cmd.AddCommand(buildAppUpgradeCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Develop,
}
return cmd
}
| 36 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
const (
appDeleteNamePrompt = "Which application would you like to delete?"
fmtDeleteAppConfirmPrompt = "Are you sure you want to delete application %s?"
deleteAppConfirmHelp = "This will delete all resources in your application: including services, environments, and pipelines."
deleteAppCleanResourcesStartMsg = "Cleaning up deployment resources."
deleteAppCleanResourcesStopMsg = "Cleaned up deployment resources.\n"
deleteAppConfigStartMsg = "Deleting application configuration."
deleteAppConfigStopMsg = "Deleted application configuration.\n"
fmtDeleteAppWsStartMsg = "Deleting local %s file."
fmtDeleteAppWsStopMsg = "Deleted local %s file.\n"
)
var (
errOperationCancelled = errors.New("operation cancelled")
)
type deleteAppVars struct {
name string
skipConfirmation bool
}
type deleteAppOpts struct {
deleteAppVars
spinner progress
store store
sessProvider sessionProvider
cfn deployer
prompt prompter
pipelineLister deployedPipelineLister
sel appSelector
s3 func(session *session.Session) bucketEmptier
svcDeleteExecutor func(svcName string) (executor, error)
jobDeleteExecutor func(jobName string) (executor, error)
envDeleteExecutor func(envName string) (executeAsker, error)
taskDeleteExecutor func(envName, taskName string) (executor, error)
pipelineDeleteExecutor func(pipelineName string) (executor, error)
existingWorkSpace func() (wsAppManagerDeleter, error)
}
func newDeleteAppOpts(vars deleteAppVars) (*deleteAppOpts, error) {
provider := sessions.ImmutableProvider(sessions.UserAgentExtras("app delete"))
defaultSession, err := provider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %w", err)
}
prompter := prompt.New()
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
return &deleteAppOpts{
deleteAppVars: vars,
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
store: store,
sessProvider: provider,
cfn: cloudformation.New(defaultSession, cloudformation.WithProgressTracker(os.Stderr)),
prompt: prompter,
s3: func(session *session.Session) bucketEmptier {
return s3.New(session)
},
pipelineLister: deploy.NewPipelineStore(rg.New(defaultSession)),
sel: selector.NewAppEnvSelector(prompter, store),
svcDeleteExecutor: func(svcName string) (executor, error) {
opts, err := newDeleteSvcOpts(deleteSvcVars{
skipConfirmation: true, // always skip sub-confirmations
name: svcName,
appName: vars.name,
})
if err != nil {
return nil, err
}
return opts, nil
},
jobDeleteExecutor: func(jobName string) (executor, error) {
opts, err := newDeleteJobOpts(deleteJobVars{
skipConfirmation: true,
name: jobName,
appName: vars.name,
})
if err != nil {
return nil, err
}
return opts, nil
},
envDeleteExecutor: func(envName string) (executeAsker, error) {
opts, err := newDeleteEnvOpts(deleteEnvVars{
skipConfirmation: true,
appName: vars.name,
name: envName,
})
if err != nil {
return nil, err
}
return opts, nil
},
taskDeleteExecutor: func(envName, taskName string) (executor, error) {
opts, err := newDeleteTaskOpts(deleteTaskVars{
app: vars.name,
env: envName,
name: taskName,
skipConfirmation: true,
})
if err != nil {
return nil, err
}
return opts, nil
},
pipelineDeleteExecutor: func(pipelineName string) (executor, error) {
opts, err := newDeletePipelineOpts(deletePipelineVars{
appName: vars.name,
name: pipelineName,
skipConfirmation: true,
shouldDeleteSecret: true,
})
if err != nil {
return nil, err
}
return opts, nil
},
existingWorkSpace: func() (wsAppManagerDeleter, error) {
return workspace.Use(afero.NewOsFs())
},
}, nil
}
// Validate is a no-op for this command.
func (o *deleteAppOpts) Validate() error {
return nil
}
// Ask prompts the user for any required flags that they didn't provide.
func (o *deleteAppOpts) Ask() error {
if err := o.validateOrAskAppName(); err != nil {
return err
}
if o.skipConfirmation {
return nil
}
manualConfirm, err := o.prompt.Confirm(
fmt.Sprintf(fmtDeleteAppConfirmPrompt, o.name),
deleteAppConfirmHelp,
prompt.WithTrueDefault(),
prompt.WithConfirmFinalMessage())
if err != nil {
return fmt.Errorf("confirm app deletion: %w", err)
}
if !manualConfirm {
return errOperationCancelled
}
return nil
}
// Execute deletes the application.
// It removes all the services from each environment, the environments, the pipeline S3 buckets,
// the pipeline, the application, removes the variables from the config store, and deletes the local workspace.
func (o *deleteAppOpts) Execute() error {
if err := o.deleteSvcs(); err != nil {
return err
}
if err := o.deleteJobs(); err != nil {
return err
}
if err := o.deleteEnvs(); err != nil {
return err
}
if err := o.emptyS3Bucket(); err != nil {
return err
}
// deletePipelines must happen before deleteAppResources and deleteWs, since the pipeline delete command relies
// on the application stackset as well as the workspace directory to still exist.
if err := o.deletePipelines(); err != nil {
return err
}
if err := o.deleteAppResources(); err != nil {
return err
}
if err := o.deleteAppConfigs(); err != nil {
return err
}
if err := o.deleteWs(); err != nil {
return err
}
return nil
}
func (o *deleteAppOpts) validateOrAskAppName() error {
if o.name != "" {
_, err := o.store.GetApplication(o.name)
return err
}
name, err := o.sel.Application(appDeleteNamePrompt, "")
if err != nil {
return fmt.Errorf("select application name: %w", err)
}
o.name = name
return nil
}
func (o *deleteAppOpts) deleteSvcs() error {
svcs, err := o.store.ListServices(o.name)
if err != nil {
return fmt.Errorf("list services for application %s: %w", o.name, err)
}
for _, svc := range svcs {
cmd, err := o.svcDeleteExecutor(svc.Name)
if err != nil {
return err
}
if err := cmd.Execute(); err != nil {
return fmt.Errorf("execute svc delete: %w", err)
}
}
return nil
}
func (o *deleteAppOpts) deleteJobs() error {
jobs, err := o.store.ListJobs(o.name)
if err != nil {
return fmt.Errorf("list jobs for application %s: %w", o.name, err)
}
for _, job := range jobs {
cmd, err := o.jobDeleteExecutor(job.Name)
if err != nil {
return err
}
if err := cmd.Execute(); err != nil {
return fmt.Errorf("execute job delete: %w", err)
}
}
return nil
}
func (o *deleteAppOpts) deleteEnvs() error {
envs, err := o.store.ListEnvironments(o.name)
if err != nil {
return fmt.Errorf("list environments for application %s: %w", o.name, err)
}
for _, env := range envs {
// Delete tasks from each environment.
tasks, err := o.cfn.ListTaskStacks(o.name, env.Name)
if err != nil {
return err
}
for _, task := range tasks {
taskCmd, err := o.taskDeleteExecutor(env.Name, task.TaskName())
if err != nil {
return err
}
if err := taskCmd.Execute(); err != nil {
return fmt.Errorf("execute task delete")
}
}
cmd, err := o.envDeleteExecutor(env.Name)
if err != nil {
return err
}
if err := cmd.Ask(); err != nil {
return fmt.Errorf("ask env delete: %w", err)
}
if err := cmd.Execute(); err != nil {
return fmt.Errorf("execute env delete: %w", err)
}
}
return nil
}
func (o *deleteAppOpts) emptyS3Bucket() error {
app, err := o.store.GetApplication(o.name)
if err != nil {
return fmt.Errorf("get application %s: %w", o.name, err)
}
appResources, err := o.cfn.GetRegionalAppResources(app)
if err != nil {
return fmt.Errorf("get regional application resources for %s: %w", app.Name, err)
}
o.spinner.Start(deleteAppCleanResourcesStartMsg)
for _, resource := range appResources {
sess, err := o.sessProvider.DefaultWithRegion(resource.Region)
if err != nil {
return fmt.Errorf("default session with region %s: %w", resource.Region, err)
}
// Empty pipeline buckets.
s3Client := o.s3(sess)
if err := s3Client.EmptyBucket(resource.S3Bucket); err != nil {
o.spinner.Stop(log.Serrorln("Error cleaning up deployment resources."))
return fmt.Errorf("empty bucket %s: %w", resource.S3Bucket, err)
}
}
o.spinner.Stop(log.Ssuccess(deleteAppCleanResourcesStopMsg))
return nil
}
func (o *deleteAppOpts) deletePipelines() error {
pipelines, err := o.pipelineLister.ListDeployedPipelines(o.name)
if err != nil {
return fmt.Errorf("list pipelines for application %s: %w", o.name, err)
}
for _, pipeline := range pipelines {
cmd, err := o.pipelineDeleteExecutor(pipeline.Name)
if err != nil {
return err
}
if err := cmd.Execute(); err != nil {
return fmt.Errorf("execute pipeline delete: %w", err)
}
}
return nil
}
func (o *deleteAppOpts) deleteAppResources() error {
if err := o.cfn.DeleteApp(o.name); err != nil {
return fmt.Errorf("delete app resources: %w", err)
}
return nil
}
func (o *deleteAppOpts) deleteAppConfigs() error {
o.spinner.Start(deleteAppConfigStartMsg)
if err := o.store.DeleteApplication(o.name); err != nil {
o.spinner.Stop(log.Serrorln("Error deleting application configuration."))
return fmt.Errorf("delete application %s configuration: %w", o.name, err)
}
o.spinner.Stop(log.Ssuccess(deleteAppConfigStopMsg))
return nil
}
func (o *deleteAppOpts) deleteWs() error {
ws, err := o.existingWorkSpace()
if err != nil {
return nil
}
// When there's a local application summary.
summary, err := ws.Summary()
if err != nil || summary.Application != o.name {
return nil
}
o.spinner.Start(fmt.Sprintf(fmtDeleteAppWsStartMsg, workspace.SummaryFileName))
if err := ws.DeleteWorkspaceFile(); err != nil {
o.spinner.Stop(log.Serrorf("Error deleting %s file.\n", workspace.SummaryFileName))
return fmt.Errorf("delete %s file: %w", workspace.SummaryFileName, err)
}
o.spinner.Stop(log.Ssuccessf(fmt.Sprintf(fmtDeleteAppWsStopMsg, workspace.SummaryFileName)))
return nil
}
// buildAppDeleteCommand builds the `app delete` subcommand.
func buildAppDeleteCommand() *cobra.Command {
vars := deleteAppVars{}
cmd := &cobra.Command{
Use: "delete",
Short: "Delete all resources associated with the application.",
Example: `
Force delete the application with environments "test" and "prod".
/code $ copilot app delete --yes`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeleteAppOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
return cmd
}
| 416 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type deleteAppMocks struct {
spinner *mocks.Mockprogress
store *mocks.Mockstore
codepipeline *mocks.MockdeployedPipelineLister
ws *mocks.MockwsAppManagerDeleter
sessProvider *sessions.Provider
deployer *mocks.Mockdeployer
svcDeleter *mocks.Mockexecutor
jobDeleter *mocks.Mockexecutor
envDeleter *mocks.MockexecuteAsker
taskDeleter *mocks.Mockexecutor
bucketEmptier *mocks.MockbucketEmptier
pipelineDeleter *mocks.Mockexecutor
prompt *mocks.Mockprompter
sel *mocks.MockappSelector
}
func TestDeleteAppOpts_Ask(t *testing.T) {
mockError := errors.New("some error")
tests := map[string]struct {
inAppName string
skipConfirmation bool
setUpMocks func(m *deleteAppMocks)
want error
}{
"return nil if skipConfirmation is enabled and appName is provided": {
inAppName: "phonetool",
skipConfirmation: true,
setUpMocks: func(m *deleteAppMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
},
"return an error if user provided app doesn't exist in SSM": {
inAppName: "phonetool",
skipConfirmation: true,
setUpMocks: func(m *deleteAppMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(nil, errors.New("couldn't find an application named phonetool in account 555555555 and region us-west-2"))
},
want: fmt.Errorf("couldn't find an application named phonetool in account 555555555 and region us-west-2"),
},
"wrap error returned from prompting": {
inAppName: "phonetool",
setUpMocks: func(m *deleteAppMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.prompt.EXPECT().
Confirm(fmt.Sprintf(fmtDeleteAppConfirmPrompt, "phonetool"),
deleteAppConfirmHelp,
gomock.Any()).
Return(false, mockError)
},
want: fmt.Errorf("confirm app deletion: %w", mockError),
},
"return error if user cancels operation": {
setUpMocks: func(m *deleteAppMocks) {
m.sel.EXPECT().Application(appDeleteNamePrompt, "").Return("phonetool", nil)
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtDeleteAppConfirmPrompt, "phonetool"),
deleteAppConfirmHelp,
gomock.Any()).
Return(false, nil)
},
want: errOperationCancelled,
},
"select from list of apps and user confirms": {
setUpMocks: func(m *deleteAppMocks) {
m.sel.EXPECT().Application(appDeleteNamePrompt, "").Return("phonetool", nil)
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtDeleteAppConfirmPrompt, "phonetool"),
deleteAppConfirmHelp,
gomock.Any()).
Return(true, nil)
},
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockPrompter := mocks.NewMockprompter(ctrl)
mockSel := mocks.NewMockappSelector(ctrl)
mockStore := mocks.NewMockstore(ctrl)
m := &deleteAppMocks{
sel: mockSel,
prompt: mockPrompter,
store: mockStore,
}
test.setUpMocks(m)
opts := deleteAppOpts{
deleteAppVars: deleteAppVars{
name: test.inAppName,
skipConfirmation: test.skipConfirmation,
},
prompt: mockPrompter,
sel: mockSel,
store: mockStore,
}
got := opts.Ask()
require.Equal(t, test.want, got)
})
}
}
func TestDeleteAppOpts_Execute(t *testing.T) {
const mockAppName = "phonetool"
mockServices := []*config.Workload{
{
Name: "webapp",
},
{
Name: "backend",
},
}
mockJobs := []*config.Workload{
{
Name: "mailer",
},
{
Name: "bailer",
},
}
mockEnvs := []*config.Environment{
{
Name: "staging",
},
}
mockApp := &config.Application{
Name: "badgoose",
}
mockPipelines := []deploy.Pipeline{
{
AppName: "badgoose",
ResourceName: "pipeline1",
IsLegacy: false,
},
{
AppName: "badgoose",
ResourceName: "pipeline2",
IsLegacy: false,
},
}
mockResources := []*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "goose-bucket",
},
}
mockTaskStacks := []deploy.TaskStackInfo{
{
StackName: "task-db-migrate",
App: "badgoose",
Env: "staging",
},
}
tests := map[string]struct {
appName string
setupMocks func(mocks deleteAppMocks)
wantedError error
}{
"success deleting all the resources along with workspace summary": {
appName: mockAppName,
setupMocks: func(mocks deleteAppMocks) {
gomock.InOrder(
// deleteSvcs
mocks.store.EXPECT().ListServices(mockAppName).Return(mockServices, nil),
mocks.svcDeleter.EXPECT().Execute().Return(nil).Times(2),
// deleteJobs
mocks.store.EXPECT().ListJobs(mockAppName).Return(mockJobs, nil),
mocks.jobDeleter.EXPECT().Execute().Return(nil).Times(2),
// listEnvs
mocks.store.EXPECT().ListEnvironments(mockAppName).Return(mockEnvs, nil),
// deleteTasks
mocks.deployer.EXPECT().ListTaskStacks(mockAppName, mockEnvs[0].Name).Return(mockTaskStacks, nil),
mocks.taskDeleter.EXPECT().Execute().Return(nil),
// deleteEnvs
mocks.envDeleter.EXPECT().Ask().Return(nil),
mocks.envDeleter.EXPECT().Execute().Return(nil),
// emptyS3bucket
mocks.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil),
mocks.deployer.EXPECT().GetRegionalAppResources(mockApp).Return(mockResources, nil),
mocks.spinner.EXPECT().Start(deleteAppCleanResourcesStartMsg),
mocks.bucketEmptier.EXPECT().EmptyBucket(mockResources[0].S3Bucket).Return(nil),
mocks.spinner.EXPECT().Stop(log.Ssuccess(deleteAppCleanResourcesStopMsg)),
// delete pipelines
mocks.codepipeline.EXPECT().ListDeployedPipelines(mockAppName).Return(mockPipelines, nil),
mocks.pipelineDeleter.EXPECT().Execute().Return(nil).Times(2),
// deleteAppResources
mocks.deployer.EXPECT().DeleteApp(mockAppName).Return(nil),
// deleteAppConfigs
mocks.spinner.EXPECT().Start(deleteAppConfigStartMsg),
mocks.store.EXPECT().DeleteApplication(mockAppName).Return(nil),
mocks.spinner.EXPECT().Stop(log.Ssuccess(deleteAppConfigStopMsg)),
// deleteWs
mocks.ws.EXPECT().Summary().Return(&workspace.Summary{Application: mockAppName}, nil),
mocks.spinner.EXPECT().Start(fmt.Sprintf(fmtDeleteAppWsStartMsg, workspace.SummaryFileName)),
mocks.ws.EXPECT().DeleteWorkspaceFile().Return(nil),
mocks.spinner.EXPECT().Stop(log.Ssuccess(fmt.Sprintf(fmtDeleteAppWsStopMsg, workspace.SummaryFileName))),
)
},
},
"skip deleting if failed to fetch workspace summary": {
appName: mockAppName,
setupMocks: func(mocks deleteAppMocks) {
gomock.InOrder(
// deleteSvcs
mocks.store.EXPECT().ListServices(mockAppName).Return(mockServices, nil),
mocks.svcDeleter.EXPECT().Execute().Return(nil).Times(2),
// deleteJobs
mocks.store.EXPECT().ListJobs(mockAppName).Return(mockJobs, nil),
mocks.jobDeleter.EXPECT().Execute().Return(nil).Times(2),
// listEnvs
mocks.store.EXPECT().ListEnvironments(mockAppName).Return(mockEnvs, nil),
// deleteTasks
mocks.deployer.EXPECT().ListTaskStacks(mockAppName, mockEnvs[0].Name).Return(mockTaskStacks, nil),
mocks.taskDeleter.EXPECT().Execute().Return(nil),
// deleteEnvs
mocks.envDeleter.EXPECT().Ask().Return(nil),
mocks.envDeleter.EXPECT().Execute().Return(nil),
// emptyS3bucket
mocks.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil),
mocks.deployer.EXPECT().GetRegionalAppResources(mockApp).Return(mockResources, nil),
mocks.spinner.EXPECT().Start(deleteAppCleanResourcesStartMsg),
mocks.bucketEmptier.EXPECT().EmptyBucket(mockResources[0].S3Bucket).Return(nil),
mocks.spinner.EXPECT().Stop(log.Ssuccess(deleteAppCleanResourcesStopMsg)),
// delete pipelines
mocks.codepipeline.EXPECT().ListDeployedPipelines(mockAppName).Return(mockPipelines, nil),
mocks.pipelineDeleter.EXPECT().Execute().Return(nil).Times(2),
// deleteAppResources
mocks.deployer.EXPECT().DeleteApp(mockAppName).Return(nil),
// deleteAppConfigs
mocks.spinner.EXPECT().Start(deleteAppConfigStartMsg),
mocks.store.EXPECT().DeleteApplication(mockAppName).Return(nil),
mocks.spinner.EXPECT().Stop(log.Ssuccess(deleteAppConfigStopMsg)),
// deleteWs
mocks.ws.EXPECT().Summary().Return(nil, errors.New("some error")),
)
},
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSpinner := mocks.NewMockprogress(ctrl)
mockStore := mocks.NewMockstore(ctrl)
mockWorkspace := mocks.NewMockwsAppManagerDeleter(ctrl)
mockSession := sessions.ImmutableProvider()
mockDeployer := mocks.NewMockdeployer(ctrl)
mockPipelineLister := mocks.NewMockdeployedPipelineLister(ctrl)
mockBucketEmptier := mocks.NewMockbucketEmptier(ctrl)
mockGetBucketEmptier := func(session *session.Session) bucketEmptier {
return mockBucketEmptier
}
// The following three sets of mocks are to avoid having to go through
// mocking all the intermediary steps in calling Execute on DeleteAppOpts,
// DeleteEnvOpts, and DeletePipelineOpts. It allows us to instead simply
// test if the deletion of those resources succeeded or failed.
mockSvcDeleteExecutor := mocks.NewMockexecutor(ctrl)
mockSvcExecutorProvider := func(svcName string) (executor, error) {
return mockSvcDeleteExecutor, nil
}
mockJobDeleteExecutor := mocks.NewMockexecutor(ctrl)
mockJobExecutorProvider := func(jobName string) (executor, error) {
return mockJobDeleteExecutor, nil
}
mockTaskDeleteExecutor := mocks.NewMockexecutor(ctrl)
mockTaskDeleteProvider := func(envName, taskName string) (executor, error) {
return mockTaskDeleteExecutor, nil
}
mockEnvDeleteExecutor := mocks.NewMockexecuteAsker(ctrl)
mockAskExecutorProvider := func(envName string) (executeAsker, error) {
return mockEnvDeleteExecutor, nil
}
mockPipelineDeleteExecutor := mocks.NewMockexecutor(ctrl)
mockPipelineExecutorProvider := func(pipelineName string) (executor, error) {
return mockPipelineDeleteExecutor, nil
}
mocks := deleteAppMocks{
spinner: mockSpinner,
store: mockStore,
ws: mockWorkspace,
sessProvider: mockSession,
deployer: mockDeployer,
codepipeline: mockPipelineLister,
svcDeleter: mockSvcDeleteExecutor,
jobDeleter: mockJobDeleteExecutor,
envDeleter: mockEnvDeleteExecutor,
taskDeleter: mockTaskDeleteExecutor,
bucketEmptier: mockBucketEmptier,
pipelineDeleter: mockPipelineDeleteExecutor,
}
test.setupMocks(mocks)
opts := deleteAppOpts{
deleteAppVars: deleteAppVars{
name: mockAppName,
},
spinner: mockSpinner,
store: mockStore,
existingWorkSpace: func() (wsAppManagerDeleter, error) {
return mockWorkspace, nil
},
pipelineLister: mockPipelineLister,
sessProvider: mockSession,
cfn: mockDeployer,
s3: mockGetBucketEmptier,
svcDeleteExecutor: mockSvcExecutorProvider,
jobDeleteExecutor: mockJobExecutorProvider,
envDeleteExecutor: mockAskExecutorProvider,
taskDeleteExecutor: mockTaskDeleteProvider,
pipelineDeleteExecutor: mockPipelineExecutorProvider,
}
// WHEN
err := opts.Execute()
// THEN
require.Equal(t, test.wantedError, err)
})
}
}
| 371 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"strings"
"github.com/aws/copilot-cli/internal/pkg/aws/iam"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/spf13/afero"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/spf13/cobra"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/route53"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/workspace"
)
const (
fmtAppInitNamePrompt = "What would you like to %s your application?"
fmtAppInitNewNamePrompt = `Ok, let's create a new application then.
What would you like to %s your application?`
appInitNameHelpPrompt = "Services and jobs in the same application share the same VPC and ECS Cluster and services are discoverable via service discovery."
)
type initAppVars struct {
name string
permissionsBoundary string
domainName string
resourceTags map[string]string
}
type initAppOpts struct {
initAppVars
identity identityService
store applicationStore
route53 domainHostedZoneGetter
cfn appDeployer
prompt prompter
prog progress
iam policyLister
iamRoleManager roleManager
isSessionFromEnvVars func() (bool, error)
existingWorkspace func() (wsAppManager, error)
newWorkspace func(appName string) (wsAppManager, error)
// Cached variables.
cachedHostedZoneID string
}
func newInitAppOpts(vars initAppVars) (*initAppOpts, error) {
sess, err := sessions.ImmutableProvider(sessions.UserAgentExtras("app init")).Default()
if err != nil {
return nil, fmt.Errorf("default session: %w", err)
}
fs := afero.NewOsFs()
identity := identity.New(sess)
iamClient := iam.New(sess)
return &initAppOpts{
initAppVars: vars,
identity: identity,
store: config.NewSSMStore(identity, ssm.New(sess), aws.StringValue(sess.Config.Region)),
route53: route53.New(sess),
cfn: cloudformation.New(sess, cloudformation.WithProgressTracker(os.Stderr)),
prompt: prompt.New(),
prog: termprogress.NewSpinner(log.DiagnosticWriter),
iam: iamClient,
iamRoleManager: iamClient,
isSessionFromEnvVars: func() (bool, error) {
return sessions.AreCredsFromEnvVars(sess)
},
existingWorkspace: func() (wsAppManager, error) {
return workspace.Use(fs)
},
newWorkspace: func(appName string) (wsAppManager, error) {
return workspace.Create(appName, fs)
},
}, nil
}
// Validate returns an error if the user's input is invalid.
func (o *initAppOpts) Validate() error {
if o.name != "" {
if err := o.validateAppName(o.name); err != nil {
return err
}
}
if o.permissionsBoundary != "" {
// Best effort to get the permission boundary name if ARN
// (for example: arn:aws:iam::1234567890:policy/myPermissionsBoundaryPolicy).
if arn.IsARN(o.permissionsBoundary) {
parsed, err := arn.Parse(o.permissionsBoundary)
if err != nil {
return fmt.Errorf("parse permission boundary ARN: %w", err)
}
o.permissionsBoundary = strings.TrimPrefix(parsed.Resource, "policy/")
}
if err := o.validatePermBound(o.permissionsBoundary); err != nil {
return err
}
}
if o.domainName != "" {
o.prog.Start(fmt.Sprintf("Validating ownership of %q", o.domainName))
defer o.prog.Stop("")
if err := validateDomainName(o.domainName); err != nil {
return fmt.Errorf("domain name %s is invalid: %w", o.domainName, err)
}
o.warnIfDomainIsNotOwned()
id, err := o.domainHostedZoneID(o.domainName)
if err != nil {
return err
}
o.cachedHostedZoneID = id
}
return nil
}
// Ask prompts the user for any required arguments that they didn't provide.
func (o *initAppOpts) Ask() error {
ok, err := o.isSessionFromEnvVars()
if err != nil {
return err
}
if ok {
log.Warningln(`Looks like you're creating an application using credentials set by environment variables.
Copilot will store your application metadata in this account.
We recommend using credentials from named profiles. To learn more:
https://aws.github.io/copilot-cli/docs/credentials/`)
log.Infoln()
}
ws, err := o.existingWorkspace()
if err == nil {
// When there's a local application.
summary, err := ws.Summary()
if err == nil {
if o.name == "" {
log.Infoln(fmt.Sprintf(
"Your workspace is registered to application %s.",
color.HighlightUserInput(summary.Application)))
if err := o.validateAppName(summary.Application); err != nil {
return err
}
o.name = summary.Application
return nil
}
if o.name != summary.Application {
summaryPath := displayPath(summary.Path)
if summaryPath == "" {
summaryPath = summary.Path
}
log.Errorf(`Workspace is already registered with application %s instead of %s.
If you'd like to delete the application locally, you can delete the file at %s.
If you'd like to delete the application and all of its resources, run %s.
`,
summary.Application,
o.name,
summaryPath,
color.HighlightCode("copilot app delete"))
return fmt.Errorf("workspace already registered with %s", summary.Application)
}
}
var errNoAppSummary *workspace.ErrNoAssociatedApplication
if !errors.As(err, &errNoAppSummary) {
return err
}
}
if !workspace.IsEmptyErr(err) {
return err
}
// Flag is set by user.
if o.name != "" {
return nil
}
existingApps, _ := o.store.ListApplications()
if len(existingApps) == 0 {
return o.askAppName(fmtAppInitNamePrompt)
}
useExistingApp, err := o.prompt.Confirm(
"Would you like to use one of your existing applications?", "", prompt.WithTrueDefault(), prompt.WithFinalMessage("Use existing application:"))
if err != nil {
return fmt.Errorf("prompt to confirm using existing application: %w", err)
}
if useExistingApp {
return o.askSelectExistingAppName(existingApps)
}
return o.askAppName(fmtAppInitNewNamePrompt)
}
// Execute creates a new managed empty application.
func (o *initAppOpts) Execute() error {
caller, err := o.identity.Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
_, err = o.newWorkspace(o.name)
if err != nil {
return fmt.Errorf("create new workspace with application name %s: %w", o.name, err)
}
var hostedZoneID string
if o.domainName != "" {
hostedZoneID, err = o.domainHostedZoneID(o.domainName)
if err != nil {
return err
}
}
err = o.cfn.DeployApp(&deploy.CreateAppInput{
Name: o.name,
AccountID: caller.Account,
DomainName: o.domainName,
DomainHostedZoneID: hostedZoneID,
PermissionsBoundary: o.permissionsBoundary,
AdditionalTags: o.resourceTags,
Version: version.LatestTemplateVersion(),
})
if err != nil {
return err
}
if err := o.store.CreateApplication(&config.Application{
AccountID: caller.Account,
Name: o.name,
Domain: o.domainName,
DomainHostedZoneID: hostedZoneID,
PermissionsBoundary: o.permissionsBoundary,
Tags: o.resourceTags,
}); err != nil {
return err
}
log.Successf("The directory %s will hold service manifests for application %s.\n", color.HighlightResource(workspace.CopilotDirName), color.HighlightUserInput(o.name))
log.Infoln()
return nil
}
func (o *initAppOpts) validateAppName(name string) error {
if err := validateAppNameString(name); err != nil {
return err
}
app, err := o.store.GetApplication(name)
if err == nil {
if o.domainName != "" && app.Domain != o.domainName {
return fmt.Errorf("application named %s already exists with a different domain name %s", name, app.Domain)
}
return nil
}
var noSuchAppErr *config.ErrNoSuchApplication
if errors.As(err, &noSuchAppErr) {
roleName := fmt.Sprintf("%s-adminrole", name)
tags, err := o.iamRoleManager.ListRoleTags(roleName)
// NOTE: This is a best-effort attempt to check if the app exists in other regions.
// The error either indicates that the role does not exist, or not.
// In the first case, it means that this is a valid app name, hence we don't error out.
// In the second case, since this is a best-effort, we don't need to surface the error either.
if err != nil {
return nil
}
if _, hasTag := tags[deploy.AppTagKey]; hasTag {
return &errAppAlreadyExistsInAccount{appName: name}
}
return &errStackSetAdminRoleExistsInAccount{
appName: name,
roleName: roleName,
}
}
return fmt.Errorf("get application %s: %w", name, err)
}
func (o *initAppOpts) validatePermBound(policyName string) error {
IAMPolicies, err := o.iam.ListPolicyNames()
if err != nil {
return fmt.Errorf("list permissions boundary policies: %w", err)
}
for _, policy := range IAMPolicies {
if policy == policyName {
return nil
}
}
return fmt.Errorf("IAM policy %q not found in this account", policyName)
}
func (o *initAppOpts) warnIfDomainIsNotOwned() {
err := o.route53.ValidateDomainOwnership(o.domainName)
if err == nil {
return
}
var nsRecordsErr *route53.ErrUnmatchedNSRecords
if errors.As(err, &nsRecordsErr) {
o.prog.Stop("")
log.Warningln(nsRecordsErr.RecommendActions())
}
}
func (o *initAppOpts) domainHostedZoneID(domainName string) (string, error) {
if o.cachedHostedZoneID != "" {
return o.cachedHostedZoneID, nil
}
hostedZoneID, err := o.route53.DomainHostedZoneID(domainName)
if err != nil {
return "", fmt.Errorf("get hosted zone ID for domain %s: %w", domainName, err)
}
return hostedZoneID, nil
}
// RecommendActions returns a list of suggested additional commands users can run after successfully executing this command.
func (o *initAppOpts) RecommendActions() error {
logRecommendedActions([]string{
fmt.Sprintf("Run %s to add a new service or job to your application.", color.HighlightCode("copilot init")),
})
return nil
}
func (o *initAppOpts) askAppName(formatMsg string) error {
appName, err := o.prompt.Get(
fmt.Sprintf(formatMsg, color.Emphasize("name")),
appInitNameHelpPrompt,
validateAppNameString,
prompt.WithFinalMessage("Application name:"))
if err != nil {
return fmt.Errorf("prompt get application name: %w", err)
}
if err := o.validateAppName(appName); err != nil {
return err
}
o.name = appName
return nil
}
func (o *initAppOpts) askSelectExistingAppName(existingApps []*config.Application) error {
var names []string
for _, p := range existingApps {
names = append(names, p.Name)
}
name, err := o.prompt.SelectOne(
fmt.Sprintf("Which %s do you want to add a new service or job to?", color.Emphasize("existing application")),
appInitNameHelpPrompt,
names,
prompt.WithFinalMessage("Application name:"))
if err != nil {
return fmt.Errorf("prompt select application name: %w", err)
}
o.name = name
return nil
}
type errAppAlreadyExistsInAccount struct {
appName string
}
type errStackSetAdminRoleExistsInAccount struct {
appName string
roleName string
}
func (e *errAppAlreadyExistsInAccount) Error() string {
return fmt.Sprintf("application named %q already exists in another region", e.appName)
}
func (e *errAppAlreadyExistsInAccount) RecommendActions() string {
return fmt.Sprintf(`If you want to create a new workspace reusing the existing application %s, please switch to the region where you created the application, and run %s.
If you'd like to recreate the application and all of its resources, please switch to the region where you created the application, and run %s.`, e.appName, color.HighlightCode("copilot app init"), color.HighlightCode("copilot app delete"))
}
func (e *errStackSetAdminRoleExistsInAccount) Error() string {
return fmt.Sprintf("IAM admin role %q already exists in this account", e.roleName)
}
func (e *errStackSetAdminRoleExistsInAccount) RecommendActions() string {
return fmt.Sprintf(`Copilot will create an IAM admin role named %s to manage the stack set of the application %s.
You have an existing role with the exact same name in your account, which will collide with the role that Copilot creates.
Please create the application with a different name, so that the IAM role name does not collide.`, e.roleName, e.appName)
}
// buildAppInitCommand builds the command for creating a new application.
func buildAppInitCommand() *cobra.Command {
vars := initAppVars{}
cmd := &cobra.Command{
Use: "init [name]",
Short: "Creates a new empty application.",
Long: `Creates a new empty application.
An application is a collection of containerized services that operate together.`,
Example: `
Create a new application named "test".
/code $ copilot app init test
Create a new application with an existing domain name in Amazon Route53.
/code $ copilot app init --domain example.com
Create a new application with an existing IAM policy as the permissions boundary for roles.
/code $ copilot app init --permissions-boundary myPermissionsBoundaryPolicy
Create a new application with resource tags.
/code $ copilot app init --resource-tags department=MyDept,team=MyTeam`,
Args: reservedArgs,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newInitAppOpts(vars)
if err != nil {
return err
}
if len(args) == 1 {
opts.name = args[0]
}
return run(opts)
}),
}
cmd.Flags().StringVar(&vars.domainName, domainNameFlag, "", domainNameFlagDescription)
cmd.Flags().StringVar(&vars.permissionsBoundary, permissionsBoundaryFlag, "", permissionsBoundaryFlagDescription)
cmd.Flags().StringToStringVar(&vars.resourceTags, resourceTagsFlag, nil, resourceTagsFlagDescription)
return cmd
}
| 432 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/route53"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type initAppMocks struct {
mockRoute53Svc *mocks.MockdomainHostedZoneGetter
mockStore *mocks.Mockstore
mockPolicyLister *mocks.MockpolicyLister
mockRoleManager *mocks.MockroleManager
mockProg *mocks.Mockprogress
}
func TestInitAppOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inAppName string
inDomainName string
inPBPolicyName string
mock func(m *initAppMocks)
wantedError error
}{
"skip everything": {
mock: func(m *initAppMocks) {},
},
"valid app name without application in SSM and without IAM adminrole": {
inAppName: "metrics",
mock: func(m *initAppMocks) {
m.mockStore.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.mockRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(nil, errors.New("role not found"))
},
},
"valid app name without application in SSM and with IAM adminrole with copliot tag": {
inAppName: "metrics",
mock: func(m *initAppMocks) {
m.mockStore.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.mockRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(
map[string]string{
"copilot-application": "metrics",
}, nil)
},
wantedError: errors.New("application named \"metrics\" already exists in another region"),
},
"valid app name without application in SSM and with IAM adminrole without copilot tag": {
inAppName: "metrics",
mock: func(m *initAppMocks) {
m.mockStore.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.mockRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(
map[string]string{
"mock-application": "metrics",
}, nil)
},
wantedError: errors.New("IAM admin role \"metrics-adminrole\" already exists in this account"),
},
"valid app name without application in SSM and with IAM adminrole without any tag": {
inAppName: "metrics",
mock: func(m *initAppMocks) {
m.mockStore.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.mockRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(nil, nil)
},
wantedError: errors.New("IAM admin role \"metrics-adminrole\" already exists in this account"),
},
"invalid app name": {
inAppName: "123chicken",
mock: func(m *initAppMocks) {},
wantedError: fmt.Errorf("application name 123chicken is invalid: %w", errBasicNameRegexNotMatched),
},
"errors if application with different domain already exists": {
inAppName: "metrics",
inDomainName: "badDomain.com",
mock: func(m *initAppMocks) {
m.mockStore.EXPECT().GetApplication("metrics").Return(&config.Application{
Name: "metrics",
Domain: "domain.com",
}, nil)
},
wantedError: errors.New("application named metrics already exists with a different domain name domain.com"),
},
"skip checking if domain name is not set": {
inAppName: "metrics",
inDomainName: "",
mock: func(m *initAppMocks) {
m.mockStore.EXPECT().GetApplication("metrics").Return(nil, nil)
},
},
"errors if failed to get application": {
inAppName: "metrics",
mock: func(m *initAppMocks) {
m.mockStore.EXPECT().GetApplication("metrics").Return(nil, errors.New("some error"))
},
wantedError: errors.New("get application metrics: some error"),
},
"invalid domain name not containing a dot": {
inDomainName: "hello_website",
mock: func(m *initAppMocks) {
m.mockProg.EXPECT().Start(gomock.Any())
m.mockProg.EXPECT().Stop(gomock.Any())
},
wantedError: fmt.Errorf("domain name hello_website is invalid: %w", errDomainInvalid),
},
"ignore unexpected errors from checking domain ownership": {
inDomainName: "something.com",
mock: func(m *initAppMocks) {
m.mockProg.EXPECT().Start(gomock.Any())
m.mockProg.EXPECT().Stop(gomock.Any()).AnyTimes()
m.mockRoute53Svc.EXPECT().ValidateDomainOwnership("something.com").Return(errors.New("some error"))
m.mockRoute53Svc.EXPECT().DomainHostedZoneID("something.com").Return("mockHostedZoneID", nil)
},
},
"wrap error from ListPolicies": {
inPBPolicyName: "nonexistentPolicyName",
mock: func(m *initAppMocks) {
m.mockPolicyLister.EXPECT().ListPolicyNames().Return(nil, errors.New("some error"))
},
wantedError: errors.New("list permissions boundary policies: some error"),
},
"invalid permissions boundary policy name": {
inPBPolicyName: "nonexistentPolicyName",
mock: func(m *initAppMocks) {
m.mockPolicyLister.EXPECT().ListPolicyNames().Return(
[]string{"existentPolicyName"}, nil)
},
wantedError: errors.New("IAM policy \"nonexistentPolicyName\" not found in this account"),
},
"invalid domain name that doesn't have a hosted zone": {
inDomainName: "badMockDomain.com",
mock: func(m *initAppMocks) {
m.mockProg.EXPECT().Start(gomock.Any())
m.mockProg.EXPECT().Stop(gomock.Any()).AnyTimes()
m.mockRoute53Svc.EXPECT().ValidateDomainOwnership("badMockDomain.com").Return(nil)
m.mockRoute53Svc.EXPECT().DomainHostedZoneID("badMockDomain.com").Return("", &route53.ErrDomainHostedZoneNotFound{})
},
wantedError: fmt.Errorf("get hosted zone ID for domain badMockDomain.com: %w", &route53.ErrDomainHostedZoneNotFound{}),
},
"errors if failed to validate that domain has a hosted zone": {
inDomainName: "mockDomain.com",
mock: func(m *initAppMocks) {
m.mockProg.EXPECT().Start(gomock.Any())
m.mockProg.EXPECT().Stop(gomock.Any()).AnyTimes()
m.mockRoute53Svc.EXPECT().ValidateDomainOwnership("mockDomain.com").Return(&route53.ErrUnmatchedNSRecords{})
m.mockRoute53Svc.EXPECT().DomainHostedZoneID("mockDomain.com").Return("", errors.New("some error"))
},
wantedError: errors.New("get hosted zone ID for domain mockDomain.com: some error"),
},
"valid": {
inPBPolicyName: "arn:aws:iam::1234567890:policy/myPermissionsBoundaryPolicy",
inDomainName: "mockDomain.com",
mock: func(m *initAppMocks) {
m.mockProg.EXPECT().Start(`Validating ownership of "mockDomain.com"`)
m.mockProg.EXPECT().Stop("")
m.mockRoute53Svc.EXPECT().ValidateDomainOwnership("mockDomain.com").Return(nil)
m.mockPolicyLister.EXPECT().ListPolicyNames().Return(
[]string{"myPermissionsBoundaryPolicy"}, nil)
m.mockRoute53Svc.EXPECT().DomainHostedZoneID("mockDomain.com").Return("mockHostedZoneID", nil)
},
},
"valid domain name containing multiple dots": {
inDomainName: "hello.dog.com",
mock: func(m *initAppMocks) {
m.mockProg.EXPECT().Start(gomock.Any())
m.mockProg.EXPECT().Stop(gomock.Any()).AnyTimes()
m.mockRoute53Svc.EXPECT().ValidateDomainOwnership("hello.dog.com").Return(nil)
m.mockRoute53Svc.EXPECT().DomainHostedZoneID("hello.dog.com").Return("mockHostedZoneID", nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &initAppMocks{
mockStore: mocks.NewMockstore(ctrl),
mockRoute53Svc: mocks.NewMockdomainHostedZoneGetter(ctrl),
mockPolicyLister: mocks.NewMockpolicyLister(ctrl),
mockRoleManager: mocks.NewMockroleManager(ctrl),
mockProg: mocks.NewMockprogress(ctrl),
}
tc.mock(m)
opts := &initAppOpts{
route53: m.mockRoute53Svc,
store: m.mockStore,
iam: m.mockPolicyLister,
iamRoleManager: m.mockRoleManager,
prog: m.mockProg,
initAppVars: initAppVars{
name: tc.inAppName,
domainName: tc.inDomainName,
permissionsBoundary: tc.inPBPolicyName,
},
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
type initAppAskMocks struct {
store *mocks.Mockstore
ws *mocks.MockwsAppManager
existingWorkspace func() (wsAppManager, error)
prompt *mocks.Mockprompter
iamRoleManager *mocks.MockroleManager
}
func TestInitAppOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inAppName string
setupMocks func(m *initAppAskMocks)
wantedAppName string
wantedErr string
}{
"if summary exists and without application in SSM and without IAM adminrole": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
m.ws.EXPECT().Summary().Return(&workspace.Summary{Application: "metrics", Path: "/test"}, nil)
return m.ws, nil
}
m.store.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(nil, errors.New("role not found"))
},
wantedAppName: "metrics",
},
"if summary exists and with application in SSM and with IAM admin with copilot tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
m.ws.EXPECT().Summary().Return(&workspace.Summary{Application: "metrics", Path: "/test"}, nil)
return m.ws, nil
}
m.store.EXPECT().GetApplication("metrics").Return(&config.Application{Name: "metrics"}, nil)
},
wantedAppName: "metrics",
},
"errors if summary exists and without application in SSM and with IAM adminrole with copliot tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
m.ws.EXPECT().Summary().Return(&workspace.Summary{Application: "metrics", Path: "/test"}, nil)
return m.ws, nil
}
m.store.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(
map[string]string{
"copilot-application": "metrics",
}, nil)
},
wantedErr: "application named \"metrics\" already exists in another region",
},
"errors if summary exists and without application in SSM and with IAM adminrole without copliot tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
m.ws.EXPECT().Summary().Return(&workspace.Summary{Application: "metrics", Path: "/test"}, nil)
return m.ws, nil
}
m.store.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(
map[string]string{
"mock-application": "metrics",
}, nil)
},
wantedErr: "IAM admin role \"metrics-adminrole\" already exists in this account",
},
"getting an unknown error when trying to use an existing workspace": {
inAppName: "metrics",
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, errors.New("some error")
}
m.store.EXPECT().ListApplications().Times(0)
},
wantedErr: "some error",
},
"use argument if there is no workspace": {
inAppName: "metrics",
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Times(0)
},
wantedAppName: "metrics",
},
"use argument if there is a workspace but no summary": {
inAppName: "metrics",
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
m.ws.EXPECT().Summary().Return(nil, &workspace.ErrNoAssociatedApplication{})
return m.ws, nil
}
m.store.EXPECT().ListApplications().Times(0)
},
wantedAppName: "metrics",
},
"getting an unknown error when trying to read the summary": {
inAppName: "testname",
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
m.ws.EXPECT().Summary().Return(nil, errors.New("some error"))
return m.ws, nil
}
m.store.EXPECT().ListApplications().Times(0)
},
wantedErr: "some error",
},
"errors if summary exists and differs from app argument": {
inAppName: "testname",
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
m.ws.EXPECT().Summary().Return(&workspace.Summary{Application: "metrics", Path: "/test"}, nil)
return m.ws, nil
}
m.store.EXPECT().ListApplications().Times(0)
},
wantedErr: "workspace already registered with metrics",
},
"return error from new app name": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{}, nil)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("", errors.New("my error"))
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedErr: "prompt get application name: my error",
},
"enter new app name if no existing apps and without application in SSM and without IAM adminrole": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{}, nil)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("metrics", nil)
m.store.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(nil, errors.New("role not found"))
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedAppName: "metrics",
},
"enter new app name if no existing apps and without application in SSM and with IAM adminrole with copilot tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{}, nil)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("metrics", nil)
m.store.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(
map[string]string{
"copilot-application": "metrics",
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedErr: "application named \"metrics\" already exists in another region",
},
"enter new app name if no existing apps and without application in SSM and with IAM adminrole without copilot tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{}, nil)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("metrics", nil)
m.store.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(
map[string]string{
"mock-application": "metrics",
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedErr: "IAM admin role \"metrics-adminrole\" already exists in this account",
},
"enter new app name if no existing apps and without application in SSM and with IAM adminrole without any tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{}, nil)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("metrics", nil)
m.store.EXPECT().GetApplication("metrics").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "metrics",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("metrics-adminrole")).Return(nil, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedErr: "IAM admin role \"metrics-adminrole\" already exists in this account",
},
"return error from app selection": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{
{
Name: "metrics",
},
{
Name: "payments",
},
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Return(true, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("", errors.New("my error"))
},
wantedErr: "prompt select application name: my error",
},
"use from existing apps": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{
{
Name: "metrics",
},
{
Name: "payments",
},
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Return(true, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("metrics", nil)
},
wantedAppName: "metrics",
},
"enter new app name if user opts out of selection and application does exists in SSM and IAM admin role does not exist": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{
{
Name: "metrics",
},
{
Name: "payments",
},
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("mock-app", nil)
m.store.EXPECT().GetApplication("mock-app").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "mock-app",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("mock-app-adminrole")).Return(nil, errors.New("role not found"))
},
wantedAppName: "mock-app",
},
"enter new app name if user opts out of selection and application does exists in SSM and IAM admin role does exist with copilot tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{
{
Name: "metrics",
},
{
Name: "payments",
},
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("mock-app", nil)
m.store.EXPECT().GetApplication("mock-app").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "mock-app",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("mock-app-adminrole")).Return(
map[string]string{
"copilot-application": "mock-app",
}, nil)
},
wantedErr: "application named \"mock-app\" already exists in another region",
},
"enter new app name if user opts out of selection and application does exists in SSM and IAM admin role does exist without copilot tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{
{
Name: "metrics",
},
{
Name: "payments",
},
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("mock-app", nil)
m.store.EXPECT().GetApplication("mock-app").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "mock-app",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("mock-app-adminrole")).Return(
map[string]string{
"mock-application": "mock-app",
}, nil)
},
wantedErr: "IAM admin role \"mock-app-adminrole\" already exists in this account",
},
"enter new app name if user opts out of selection and application does exists in SSM and IAM admin role does exist without any tag": {
setupMocks: func(m *initAppAskMocks) {
m.existingWorkspace = func() (wsAppManager, error) {
return nil, &workspace.ErrWorkspaceNotFound{}
}
m.store.EXPECT().ListApplications().Return([]*config.Application{
{
Name: "metrics",
},
{
Name: "payments",
},
}, nil)
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("mock-app", nil)
m.store.EXPECT().GetApplication("mock-app").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "mock-app",
})
m.iamRoleManager.EXPECT().ListRoleTags(gomock.Eq("mock-app-adminrole")).Return(nil, nil)
},
wantedErr: "IAM admin role \"mock-app-adminrole\" already exists in this account",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &initAppAskMocks{
store: mocks.NewMockstore(ctrl),
ws: mocks.NewMockwsAppManager(ctrl),
prompt: mocks.NewMockprompter(ctrl),
iamRoleManager: mocks.NewMockroleManager(ctrl),
}
tc.setupMocks(m)
opts := &initAppOpts{
initAppVars: initAppVars{
name: tc.inAppName,
},
store: m.store,
prompt: m.prompt,
iamRoleManager: m.iamRoleManager,
isSessionFromEnvVars: func() (bool, error) {
return false, nil
},
existingWorkspace: m.existingWorkspace,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedErr != "" {
require.EqualError(t, err, tc.wantedErr)
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedAppName, opts.name)
}
})
}
}
type initAppExecuteMocks struct {
store *mocks.Mockstore
ws *mocks.MockwsAppManager
identityService *mocks.MockidentityService
deployer *mocks.MockappDeployer
progress *mocks.Mockprogress
newWorkspace func(appName string) (wsAppManager, error)
}
func TestInitAppOpts_Execute(t *testing.T) {
mockError := fmt.Errorf("error")
testCases := map[string]struct {
inDomainName string
inDomainHostedZoneID string
inPermissionsBoundaryPolicy string
expectedError error
mocking func(m *initAppExecuteMocks)
}{
"with a successful call to add app": {
inDomainName: "amazon.com",
inDomainHostedZoneID: "mockID",
inPermissionsBoundaryPolicy: "mockPolicy",
mocking: func(m *initAppExecuteMocks) {
m.identityService.EXPECT().Get().Return(identity.Caller{
Account: "12345",
}, nil)
m.store.EXPECT().CreateApplication(&config.Application{
AccountID: "12345",
Name: "myapp",
Domain: "amazon.com",
DomainHostedZoneID: "mockID",
PermissionsBoundary: "mockPolicy",
Tags: map[string]string{
"owner": "boss",
},
})
m.newWorkspace = func(appName string) (wsAppManager, error) {
return m.ws, nil
}
m.deployer.EXPECT().DeployApp(&deploy.CreateAppInput{
Name: "myapp",
AccountID: "12345",
DomainName: "amazon.com",
DomainHostedZoneID: "mockID",
AdditionalTags: map[string]string{
"owner": "boss",
},
Version: version.LatestTemplateVersion(),
PermissionsBoundary: "mockPolicy",
}).Return(nil)
},
},
"should return error from workspace.Create": {
expectedError: mockError,
mocking: func(m *initAppExecuteMocks) {
m.identityService.EXPECT().Get().Return(identity.Caller{
Account: "12345",
}, nil)
m.newWorkspace = func(appName string) (wsAppManager, error) {
return nil, mockError
}
},
},
"with an error while deploying myapp": {
expectedError: mockError,
mocking: func(m *initAppExecuteMocks) {
m.identityService.EXPECT().Get().Return(identity.Caller{
Account: "12345",
}, nil)
m.newWorkspace = func(appName string) (wsAppManager, error) {
return m.ws, nil
}
m.deployer.EXPECT().DeployApp(gomock.Any()).Return(mockError)
},
},
"should return error from CreateApplication": {
expectedError: mockError,
mocking: func(m *initAppExecuteMocks) {
m.identityService.EXPECT().Get().Return(identity.Caller{
Account: "12345",
}, nil)
m.store.EXPECT().CreateApplication(gomock.Any()).Return(mockError)
m.newWorkspace = func(appName string) (wsAppManager, error) {
return m.ws, nil
}
m.deployer.EXPECT().DeployApp(gomock.Any()).Return(nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &initAppExecuteMocks{
store: mocks.NewMockstore(ctrl),
ws: mocks.NewMockwsAppManager(ctrl),
identityService: mocks.NewMockidentityService(ctrl),
deployer: mocks.NewMockappDeployer(ctrl),
progress: mocks.NewMockprogress(ctrl),
}
tc.mocking(m)
opts := &initAppOpts{
initAppVars: initAppVars{
name: "myapp",
domainName: tc.inDomainName,
permissionsBoundary: tc.inPermissionsBoundaryPolicy,
resourceTags: map[string]string{
"owner": "boss",
},
},
store: m.store,
identity: m.identityService,
cfn: m.deployer,
// ws: m.ws,
prog: m.progress,
cachedHostedZoneID: tc.inDomainHostedZoneID,
newWorkspace: m.newWorkspace,
}
// WHEN
err := opts.Execute()
// THEN
if tc.expectedError == nil {
require.NoError(t, err)
} else {
require.True(t, errors.Is(err, tc.expectedError))
}
})
}
}
| 759 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"io"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/spf13/cobra"
)
type listAppOpts struct {
store applicationLister
w io.Writer
}
// Execute writes the existing applications.
func (o *listAppOpts) Execute() error {
apps, err := o.store.ListApplications()
if err != nil {
return fmt.Errorf("list applications: %w", err)
}
for _, app := range apps {
fmt.Fprintln(o.w, app.Name)
}
return nil
}
// buildAppListCommand builds the command to list existing applications.
func buildAppListCommand() *cobra.Command {
cmd := &cobra.Command{
Use: "ls",
Short: "Lists all the applications in your account.",
Example: `
List all the applications in your account and region.
/code $ copilot app ls`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts := listAppOpts{
w: os.Stdout,
}
sess, err := sessions.ImmutableProvider(sessions.UserAgentExtras("app ls")).Default()
if err != nil {
return fmt.Errorf("default session: %v", err)
}
opts.store = config.NewSSMStore(identity.New(sess), ssm.New(sess), aws.StringValue(sess.Config.Region))
return opts.Execute()
}),
}
return cmd
}
| 62 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestListAppOpts_Execute(t *testing.T) {
ctrl := gomock.NewController(t)
mockstore := mocks.NewMockstore(ctrl)
defer ctrl.Finish()
testError := errors.New("error fetching apps")
testCases := map[string]struct {
listOpts listAppOpts
mocking func()
want error
}{
"with applications": {
listOpts: listAppOpts{
store: mockstore,
w: io.Discard,
},
mocking: func() {
mockstore.
EXPECT().
ListApplications().
Return([]*config.Application{
{Name: "app1"},
{Name: "app2"},
}, nil).
Times(1)
},
},
"with an error": {
listOpts: listAppOpts{
store: mockstore,
w: io.Discard,
},
mocking: func() {
mockstore.
EXPECT().
ListApplications().
Return(nil, testError).
Times(1)
},
want: fmt.Errorf("list applications: %w", testError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
tc.mocking()
got := tc.listOpts.Execute()
require.Equal(t, tc.want, got)
})
}
}
| 71 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"io"
"sort"
"sync"
"time"
"github.com/aws/copilot-cli/internal/pkg/aws/codepipeline"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"golang.org/x/sync/errgroup"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/spf13/cobra"
)
const (
appShowNamePrompt = "Which application would you like to show?"
appShowNameHelpPrompt = "An application is a collection of related services."
waitForStackTimeout = 30 * time.Second
)
type showAppVars struct {
name string
shouldOutputJSON bool
}
type showAppOpts struct {
showAppVars
store store
w io.Writer
sel appSelector
deployStore deployedEnvironmentLister
codepipeline pipelineGetter
pipelineLister deployedPipelineLister
newVersionGetter func(string) (versionGetter, error)
}
func newShowAppOpts(vars showAppVars) (*showAppOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("app show"))
defaultSession, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %w", err)
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, store)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
return &showAppOpts{
showAppVars: vars,
store: store,
w: log.OutputWriter,
sel: selector.NewAppEnvSelector(prompt.New(), store),
deployStore: deployStore,
codepipeline: codepipeline.New(defaultSession),
pipelineLister: deploy.NewPipelineStore(rg.New(defaultSession)),
newVersionGetter: func(s string) (versionGetter, error) {
d, err := describe.NewAppDescriber(s)
if err != nil {
return d, fmt.Errorf("new app describer for application %s: %v", s, err)
}
return d, nil
},
}, nil
}
// Validate returns an error if the values provided by the user are invalid.
func (o *showAppOpts) Validate() error {
if o.name != "" {
_, err := o.store.GetApplication(o.name)
if err != nil {
return fmt.Errorf("get application %s: %w", o.name, err)
}
}
return nil
}
// Ask asks for fields that are required but not passed in.
func (o *showAppOpts) Ask() error {
if err := o.askName(); err != nil {
return err
}
return nil
}
// Execute writes the application's description.
func (o *showAppOpts) Execute() error {
description, err := o.description()
if err != nil {
return err
}
if !o.shouldOutputJSON {
fmt.Fprint(o.w, description.HumanString())
return nil
}
data, err := description.JSONString()
if err != nil {
return fmt.Errorf("get JSON string: %w", err)
}
fmt.Fprint(o.w, data)
return nil
}
func (o *showAppOpts) populateDeployedWorkloads(listWorkloads func(app, env string) ([]string, error), deployedEnvsFor map[string][]string, env string, lock sync.Locker) error {
deployedworkload, err := listWorkloads(o.name, env)
if err != nil {
return fmt.Errorf("list services/jobs deployed to %s: %w", env, err)
}
lock.Lock()
defer lock.Unlock()
for _, wkld := range deployedworkload {
deployedEnvsFor[wkld] = append(deployedEnvsFor[wkld], env)
}
return nil
}
func (o *showAppOpts) description() (*describe.App, error) {
app, err := o.store.GetApplication(o.name)
if err != nil {
return nil, fmt.Errorf("get application %s: %w", o.name, err)
}
envs, err := o.store.ListEnvironments(o.name)
if err != nil {
return nil, fmt.Errorf("list environments in application %s: %w", o.name, err)
}
svcs, err := o.store.ListServices(o.name)
if err != nil {
return nil, fmt.Errorf("list services in application %s: %w", o.name, err)
}
jobs, err := o.store.ListJobs(o.name)
if err != nil {
return nil, fmt.Errorf("list jobs in application %s: %w", o.name, err)
}
wkldDeployedtoEnvs := make(map[string][]string)
ctx, cancelWait := context.WithTimeout(context.Background(), waitForStackTimeout)
defer cancelWait()
g, _ := errgroup.WithContext(ctx)
var mux sync.Mutex
for i := range envs {
env := envs[i]
g.Go(func() error {
return o.populateDeployedWorkloads(o.deployStore.ListDeployedJobs, wkldDeployedtoEnvs, env.Name, &mux)
})
g.Go(func() error {
return o.populateDeployedWorkloads(o.deployStore.ListDeployedServices, wkldDeployedtoEnvs, env.Name, &mux)
})
}
if err := g.Wait(); err != nil {
return nil, err
}
// Sort the map values so that `output` is consistent and the unit test won't be flaky.
for k := range wkldDeployedtoEnvs {
sort.Strings(wkldDeployedtoEnvs[k])
}
pipelines, err := o.pipelineLister.ListDeployedPipelines(o.name)
if err != nil {
return nil, fmt.Errorf("list pipelines in application %s: %w", o.name, err)
}
var pipelineInfo []*codepipeline.Pipeline
for _, pipeline := range pipelines {
info, err := o.codepipeline.GetPipeline(pipeline.ResourceName)
if err != nil {
return nil, fmt.Errorf("get info for pipeline %s: %w", pipeline.Name, err)
}
pipelineInfo = append(pipelineInfo, info)
}
var trimmedEnvs []*config.Environment
for _, env := range envs {
trimmedEnvs = append(trimmedEnvs, &config.Environment{
Name: env.Name,
AccountID: env.AccountID,
Region: env.Region,
})
}
var trimmedSvcs []*config.Workload
for _, svc := range svcs {
trimmedSvcs = append(trimmedSvcs, &config.Workload{
Name: svc.Name,
Type: svc.Type,
})
}
var trimmedJobs []*config.Workload
for _, job := range jobs {
trimmedJobs = append(trimmedJobs, &config.Workload{
Name: job.Name,
Type: job.Type,
})
}
versionGetter, err := o.newVersionGetter(o.name)
if err != nil {
return nil, err
}
version, err := versionGetter.Version()
if err != nil {
return nil, fmt.Errorf("get version for application %s: %w", o.name, err)
}
return &describe.App{
Name: app.Name,
Version: version,
URI: app.Domain,
PermissionsBoundary: app.PermissionsBoundary,
Envs: trimmedEnvs,
Services: trimmedSvcs,
Jobs: trimmedJobs,
Pipelines: pipelineInfo,
WkldDeployedtoEnvs: wkldDeployedtoEnvs,
}, nil
}
func (o *showAppOpts) askName() error {
if o.name != "" {
return nil
}
name, err := o.sel.Application(appShowNamePrompt, appShowNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.name = name
return nil
}
// buildAppShowCmd builds the command for showing details of an application.
func buildAppShowCmd() *cobra.Command {
vars := showAppVars{}
cmd := &cobra.Command{
Use: "show",
Short: "Shows info about an application.",
Long: "Shows configuration, environments and services for an application.",
Example: `
Shows info about the application "my-app"
/code $ copilot app show -n my-app`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newShowAppOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
// The flags bound by viper are available to all sub-commands through viper.GetString({flagName})
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, tryReadingAppName(), appFlagDescription)
return cmd
}
| 267 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/aws/codepipeline"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type showAppMocks struct {
storeSvc *mocks.Mockstore
sel *mocks.MockappSelector
deployStore *mocks.MockdeployedEnvironmentLister
pipelineGetter *mocks.MockpipelineGetter
pipelineLister *mocks.MockdeployedPipelineLister
versionGetter *mocks.MockversionGetter
}
func TestShowAppOpts_Validate(t *testing.T) {
testError := errors.New("some error")
testCases := map[string]struct {
inAppName string
setupMocks func(mocks showAppMocks)
wantedError error
}{
"valid app name": {
inAppName: "my-app",
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
}, nil)
},
wantedError: nil,
},
"invalid app name": {
inAppName: "my-app",
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(nil, testError)
},
wantedError: fmt.Errorf("get application %s: %w", "my-app", testError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mocks := showAppMocks{
storeSvc: mockStoreReader,
}
tc.setupMocks(mocks)
opts := &showAppOpts{
showAppVars: showAppVars{
name: tc.inAppName,
},
store: mockStoreReader,
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestShowAppOpts_Ask(t *testing.T) {
testError := errors.New("some error")
testCases := map[string]struct {
inApp string
setupMocks func(mocks showAppMocks)
wantedApp string
wantedError error
}{
"with all flags": {
inApp: "my-app",
setupMocks: func(m showAppMocks) {},
wantedApp: "my-app",
wantedError: nil,
},
"prompt for all input": {
inApp: "",
setupMocks: func(m showAppMocks) {
m.sel.EXPECT().Application(appShowNamePrompt, appShowNameHelpPrompt).Return("my-app", nil)
},
wantedApp: "my-app",
wantedError: nil,
},
"returns error if failed to select application": {
inApp: "",
setupMocks: func(m showAppMocks) {
m.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Return("", testError)
},
wantedError: fmt.Errorf("select application: %w", testError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := showAppMocks{
sel: mocks.NewMockappSelector(ctrl),
}
tc.setupMocks(mocks)
opts := &showAppOpts{
showAppVars: showAppVars{
name: tc.inApp,
},
sel: mocks.sel,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, opts.name, "expected app names to match")
}
})
}
}
func TestShowAppOpts_Execute(t *testing.T) {
const (
mockAppName = "my-app"
mockPipelineName = "my-pipeline-repo"
mockLegacyPipelineName = "bad-goose"
mockTemplateVersion = "v1.29.0"
)
mockPipeline := deploy.Pipeline{
AppName: mockAppName,
ResourceName: fmt.Sprintf("pipeline-%s-%s", mockAppName, mockPipelineName),
Name: mockPipelineName,
IsLegacy: false,
}
mockLegacyPipeline := deploy.Pipeline{
AppName: mockAppName,
ResourceName: mockLegacyPipelineName,
IsLegacy: true,
}
testError := errors.New("some error")
testCases := map[string]struct {
shouldOutputJSON bool
setupMocks func(mocks showAppMocks)
wantedContent string
wantedError error
}{
"correctly shows json output": {
shouldOutputJSON: true,
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{"my-job"}, nil).AnyTimes()
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{"my-job"}, nil).AnyTimes()
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{"my-svc"}, nil).AnyTimes()
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{"my-svc"}, nil).AnyTimes()
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline, mockLegacyPipeline}, nil)
m.pipelineGetter.EXPECT().
GetPipeline("pipeline-my-app-my-pipeline-repo").Return(&codepipeline.Pipeline{
Name: "my-pipeline-repo",
}, nil)
m.pipelineGetter.EXPECT().
GetPipeline("bad-goose").Return(&codepipeline.Pipeline{
Name: "bad-goose",
}, nil)
m.versionGetter.EXPECT().Version().Return("v0.0.0", nil)
},
wantedContent: "{\"name\":\"my-app\",\"version\":\"v0.0.0\",\"uri\":\"example.com\",\"permissionsBoundary\":\"examplePermissionsBoundaryPolicy\",\"environments\":[{\"app\":\"\",\"name\":\"test\",\"region\":\"us-west-2\",\"accountID\":\"123456789\",\"registryURL\":\"\",\"executionRoleARN\":\"\",\"managerRoleARN\":\"\"},{\"app\":\"\",\"name\":\"prod\",\"region\":\"us-west-1\",\"accountID\":\"123456789\",\"registryURL\":\"\",\"executionRoleARN\":\"\",\"managerRoleARN\":\"\"}],\"services\":[{\"app\":\"\",\"name\":\"my-svc\",\"type\":\"lb-web-svc\"}],\"jobs\":[{\"app\":\"\",\"name\":\"my-job\",\"type\":\"Scheduled Job\"}],\"pipelines\":[{\"pipelineName\":\"my-pipeline-repo\",\"region\":\"\",\"accountId\":\"\",\"stages\":null,\"createdAt\":\"0001-01-01T00:00:00Z\",\"updatedAt\":\"0001-01-01T00:00:00Z\"},{\"pipelineName\":\"bad-goose\",\"region\":\"\",\"accountId\":\"\",\"stages\":null,\"createdAt\":\"0001-01-01T00:00:00Z\",\"updatedAt\":\"0001-01-01T00:00:00Z\"}]}\n",
},
"correctly shows human output": {
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{"my-svc"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline, mockLegacyPipeline}, nil)
m.pipelineGetter.EXPECT().
GetPipeline("pipeline-my-app-my-pipeline-repo").Return(&codepipeline.Pipeline{
Name: "my-pipeline-repo",
}, nil)
m.pipelineGetter.EXPECT().
GetPipeline("bad-goose").Return(&codepipeline.Pipeline{
Name: "bad-goose",
}, nil)
m.versionGetter.EXPECT().Version().Return("v0.0.0", nil)
},
wantedContent: `About
Name my-app
Version v0.0.0
URI example.com
Permissions Boundary examplePermissionsBoundaryPolicy
Environments
Name AccountID Region
---- --------- ------
test 123456789 us-west-2
prod 123456789 us-west-1
Workloads
Name Type Environments
---- ---- ------------
my-svc lb-web-svc test
my-job Scheduled Job prod, test
Pipelines
Name
----
my-pipeline-repo
bad-goose
`,
},
"correctly shows human output with latest version": {
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{"my-svc"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{"my-svc"}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.versionGetter.EXPECT().Version().Return(mockTemplateVersion, nil)
},
wantedContent: `About
Name my-app
Version v1.29.0
URI example.com
Permissions Boundary examplePermissionsBoundaryPolicy
Environments
Name AccountID Region
---- --------- ------
test 123456789 us-west-2
prod 123456789 us-west-1
Workloads
Name Type Environments
---- ---- ------------
my-svc lb-web-svc prod, test
my-job Scheduled Job prod, test
Pipelines
Name
----
`,
},
"correctly shows human output when URI and Permissions Boundary are empty": {
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "",
PermissionsBoundary: "",
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{"my-svc"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{"my-svc"}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.versionGetter.EXPECT().Version().Return(mockTemplateVersion, nil)
},
wantedContent: `About
Name my-app
Version v1.29.0
URI N/A
Permissions Boundary N/A
Environments
Name AccountID Region
---- --------- ------
test 123456789 us-west-2
prod 123456789 us-west-1
Workloads
Name Type Environments
---- ---- ------------
my-svc lb-web-svc prod, test
my-job Scheduled Job prod, test
Pipelines
Name
----
`,
},
"when service/job is not deployed": {
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline}, nil)
m.pipelineGetter.EXPECT().
GetPipeline("pipeline-my-app-my-pipeline-repo").Return(&codepipeline.Pipeline{
Name: "my-pipeline-repo",
}, nil)
m.versionGetter.EXPECT().Version().Return(mockTemplateVersion, nil)
},
wantedContent: `About
Name my-app
Version v1.29.0
URI example.com
Permissions Boundary examplePermissionsBoundaryPolicy
Environments
Name AccountID Region
---- --------- ------
test 123456789 us-west-2
prod 123456789 us-west-1
Workloads
Name Type Environments
---- ---- ------------
my-svc lb-web-svc -
my-job Scheduled Job -
Pipelines
Name
----
my-pipeline-repo
`,
},
"when multiple services/jobs are deployed": {
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test1",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod1",
AccountID: "123456789",
Region: "us-west-1",
},
{
Name: "test2",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod2",
AccountID: "123456789",
Region: "us-west-1",
},
{
Name: "staging",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test1").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod1").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod2").Return([]string{}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test2").Return([]string{}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "staging").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test1").Return([]string{}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod1").Return([]string{}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod2").Return([]string{"my-svc"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test2").Return([]string{"my-svc"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "staging").Return([]string{"my-svc"}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline}, nil)
m.pipelineGetter.EXPECT().
GetPipeline("pipeline-my-app-my-pipeline-repo").Return(&codepipeline.Pipeline{
Name: "my-pipeline-repo",
}, nil)
m.versionGetter.EXPECT().Version().Return(mockTemplateVersion, nil)
},
wantedContent: `About
Name my-app
Version v1.29.0
URI example.com
Permissions Boundary examplePermissionsBoundaryPolicy
Environments
Name AccountID Region
---- --------- ------
test1 123456789 us-west-2
prod1 123456789 us-west-1
test2 123456789 us-west-2
prod2 123456789 us-west-1
staging 123456789 us-west-1
Workloads
Name Type Environments
---- ---- ------------
my-svc lb-web-svc prod2, staging, test2
my-job Scheduled Job prod1, staging, test1
Pipelines
Name
----
my-pipeline-repo
`,
},
"returns error if fail to get application": {
shouldOutputJSON: false,
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(nil, testError)
},
wantedError: fmt.Errorf("get application %s: %w", "my-app", testError),
},
"returns error if fail to list environment": {
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return(nil, testError)
},
wantedError: fmt.Errorf("list environments in application %s: %w", "my-app", testError),
},
"returns error if fail to list services": {
shouldOutputJSON: false,
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return(nil, testError)
},
wantedError: fmt.Errorf("list services in application %s: %w", "my-app", testError),
},
"returns error if fail to list jobs": {
shouldOutputJSON: false,
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return(nil, testError)
},
wantedError: fmt.Errorf("list jobs in application %s: %w", "my-app", testError),
},
"returns error if fail to list pipelines": {
shouldOutputJSON: false,
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{"my-svc"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{"my-svc"}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return(nil, testError)
},
wantedError: fmt.Errorf("list pipelines in application %s: %w", "my-app", testError),
},
"returns error if fail to get pipeline info": {
shouldOutputJSON: false,
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{"my-job"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{"my-svc"}, nil)
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{"my-svc"}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline}, nil)
m.pipelineGetter.EXPECT().
GetPipeline("pipeline-my-app-my-pipeline-repo").Return(nil, testError)
},
wantedError: fmt.Errorf("get info for pipeline %s: %w", mockPipelineName, testError),
},
"returns error if fail to get app version": {
shouldOutputJSON: false,
setupMocks: func(m showAppMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
Domain: "example.com",
PermissionsBoundary: "examplePermissionsBoundaryPolicy",
}, nil)
m.storeSvc.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
Region: "us-west-2",
AccountID: "123456789",
},
{
Name: "prod",
AccountID: "123456789",
Region: "us-west-1",
},
}, nil)
m.storeSvc.EXPECT().ListServices("my-app").Return([]*config.Workload{
{
Name: "my-svc",
Type: "lb-web-svc",
},
}, nil)
m.storeSvc.EXPECT().ListJobs("my-app").Return([]*config.Workload{
{
Name: "my-job",
Type: "Scheduled Job",
},
}, nil)
m.deployStore.EXPECT().ListDeployedJobs("my-app", "test").Return([]string{"my-job"}, nil).AnyTimes()
m.deployStore.EXPECT().ListDeployedJobs("my-app", "prod").Return([]string{"my-job"}, nil).AnyTimes()
m.deployStore.EXPECT().ListDeployedServices("my-app", "test").Return([]string{"my-svc"}, nil).AnyTimes()
m.deployStore.EXPECT().ListDeployedServices("my-app", "prod").Return([]string{"my-svc"}, nil).AnyTimes()
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.versionGetter.EXPECT().Version().Return("", testError)
},
wantedError: fmt.Errorf("get version for application %s: %w", "my-app", testError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
b := &bytes.Buffer{}
mockStoreReader := mocks.NewMockstore(ctrl)
mockPLSvc := mocks.NewMockpipelineGetter(ctrl)
mockVersionGetter := mocks.NewMockversionGetter(ctrl)
mockPipelineLister := mocks.NewMockdeployedPipelineLister(ctrl)
mockDeployStore := mocks.NewMockdeployedEnvironmentLister(ctrl)
mocks := showAppMocks{
storeSvc: mockStoreReader,
pipelineGetter: mockPLSvc,
versionGetter: mockVersionGetter,
pipelineLister: mockPipelineLister,
deployStore: mockDeployStore,
}
tc.setupMocks(mocks)
opts := &showAppOpts{
showAppVars: showAppVars{
shouldOutputJSON: tc.shouldOutputJSON,
name: mockAppName,
},
store: mockStoreReader,
w: b,
codepipeline: mockPLSvc,
pipelineLister: mockPipelineLister,
deployStore: mockDeployStore,
newVersionGetter: func(s string) (versionGetter, error) {
return mockVersionGetter, nil
},
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedContent, b.String(), "expected output content match")
}
})
}
}
| 869 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/route53"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/spf13/cobra"
"golang.org/x/mod/semver"
)
const (
fmtAppUpgradeStart = "Upgrading application %s from version %s to version %s.\n"
fmtAppUpgradeFailed = "Failed to upgrade application %s's template to version %s.\n"
fmtAppUpgradeComplete = "Upgraded application %s's template to version %s.\n"
appUpgradeNamePrompt = "Which application would you like to upgrade?"
appUpgradeNameHelpPrompt = "An application is a collection of related services."
)
// appUpgradeVars holds flag values.
type appUpgradeVars struct {
name string
}
// appUpgradeOpts represents the app upgrade command and holds the necessary data
// and clients to execute the command.
type appUpgradeOpts struct {
appUpgradeVars
store store
route53 domainHostedZoneGetter
sel appSelector
identity identityService
upgrader appUpgrader
newVersionGetter func(string) (versionGetter, error)
templateVersion string // Overridden in tests.
}
func newAppUpgradeOpts(vars appUpgradeVars) (*appUpgradeOpts, error) {
sess, err := sessions.ImmutableProvider(sessions.UserAgentExtras("app upgrade")).Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(sess), ssm.New(sess), aws.StringValue(sess.Config.Region))
return &appUpgradeOpts{
appUpgradeVars: vars,
store: store,
identity: identity.New(sess),
route53: route53.New(sess),
sel: selector.NewAppEnvSelector(prompt.New(), store),
upgrader: cloudformation.New(sess, cloudformation.WithProgressTracker(os.Stderr)),
newVersionGetter: func(appName string) (versionGetter, error) {
d, err := describe.NewAppDescriber(appName)
if err != nil {
return d, fmt.Errorf("new describer for application %q: %w", appName, err)
}
return d, nil
},
templateVersion: version.LatestTemplateVersion(),
}, nil
}
// Validate returns an error if the values provided by the user are invalid.
func (o *appUpgradeOpts) Validate() error {
if o.name != "" {
_, err := o.store.GetApplication(o.name)
if err != nil {
return fmt.Errorf("get application %s: %w", o.name, err)
}
}
return nil
}
// Ask asks for fields that are required but not passed in.
func (o *appUpgradeOpts) Ask() error {
if err := o.askName(); err != nil {
return err
}
return nil
}
// Execute updates the cloudformation stack as well as the stackset of an application to the latest version.
// If any stack is busy updating, it spins and waits until the stack can be updated.
func (o *appUpgradeOpts) Execute() error {
vg, err := o.newVersionGetter(o.name)
if err != nil {
return err
}
appVersion, err := vg.Version()
if err != nil {
return fmt.Errorf("get template version of application %s: %v", o.name, err)
}
if !o.shouldUpgradeApp(appVersion) {
return nil
}
app, err := o.store.GetApplication(o.name)
if err != nil {
return fmt.Errorf("get application %s: %w", o.name, err)
}
log.Infof(fmtAppUpgradeStart, color.HighlightUserInput(o.name), color.Emphasize(appVersion), color.Emphasize(o.templateVersion))
defer func() {
if err != nil {
log.Errorf(fmtAppUpgradeFailed, color.HighlightUserInput(o.name), color.Emphasize(o.templateVersion))
return
}
log.Successf(fmtAppUpgradeComplete, color.HighlightUserInput(o.name), color.Emphasize(o.templateVersion))
}()
err = o.upgradeApplication(app, appVersion, o.templateVersion)
if err != nil {
return err
}
return nil
}
func (o *appUpgradeOpts) askName() error {
if o.name != "" {
return nil
}
name, err := o.sel.Application(appUpgradeNamePrompt, appUpgradeNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.name = name
return nil
}
func (o *appUpgradeOpts) shouldUpgradeApp(appVersion string) bool {
diff := semver.Compare(appVersion, o.templateVersion)
if diff < 0 {
// Newer version available.
return true
}
msg := fmt.Sprintf("Application %s is already on the latest version %s, skip upgrade.", o.name, o.templateVersion)
if diff > 0 {
// It's possible that a teammate used a different version of the CLI to upgrade the application
// to a newer version. And the current user is on an older version of the CLI.
// In this situation we notify them they should update the CLI.
msg = fmt.Sprintf(`Skip upgrading application %s to version %s since it's on version %s.
Are you using the latest version of AWS Copilot?`, o.name, o.templateVersion, appVersion)
}
log.Debugln(msg)
return false
}
func (o *appUpgradeOpts) upgradeApplication(app *config.Application, fromVersion, toVersion string) error {
caller, err := o.identity.Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
// Upgrade SSM Parameter Store record.
if err := o.upgradeAppSSMStore(app); err != nil {
return err
}
// Upgrade app CloudFormation resources.
if err := o.upgrader.UpgradeApplication(&deploy.CreateAppInput{
Name: o.name,
AccountID: caller.Account,
DomainName: app.Domain,
DomainHostedZoneID: app.DomainHostedZoneID,
Version: toVersion,
}); err != nil {
return fmt.Errorf("upgrade application %s from version %s to version %s: %v", app.Name, fromVersion, toVersion, err)
}
return nil
}
func (o *appUpgradeOpts) upgradeAppSSMStore(app *config.Application) error {
if app.Domain != "" && app.DomainHostedZoneID == "" {
hostedZoneID, err := o.route53.DomainHostedZoneID(app.Domain)
if err != nil {
return fmt.Errorf("get hosted zone ID for domain %s: %w", app.Domain, err)
}
app.DomainHostedZoneID = hostedZoneID
}
if err := o.store.UpdateApplication(app); err != nil {
return fmt.Errorf("update application %s: %w", app.Name, err)
}
return nil
}
// buildAppUpgradeCmd builds the command to update an application to the latest version.
func buildAppUpgradeCmd() *cobra.Command {
vars := appUpgradeVars{}
cmd := &cobra.Command{
Use: "upgrade",
Short: "Upgrades the template of an application to the latest version.",
Example: `
Upgrade the application "my-app" to the latest version
/code $ copilot app upgrade -n my-app`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newAppUpgradeOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, tryReadingAppName(), appFlagDescription)
return cmd
}
| 223 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type versionGetterDouble struct {
VersionFn func() (string, error)
}
func (d *versionGetterDouble) Version() (string, error) {
return d.VersionFn()
}
type appUpgradeMocks struct {
storeSvc *mocks.Mockstore
sel *mocks.MockappSelector
}
func TestAppUpgradeOpts_Validate(t *testing.T) {
testError := errors.New("some error")
testCases := map[string]struct {
inAppName string
setupMocks func(mocks appUpgradeMocks)
wantedError error
}{
"valid app name": {
inAppName: "my-app",
setupMocks: func(m appUpgradeMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
}, nil)
},
wantedError: nil,
},
"invalid app name": {
inAppName: "my-app",
setupMocks: func(m appUpgradeMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(nil, testError)
},
wantedError: fmt.Errorf("get application %s: %w", "my-app", testError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mocks := appUpgradeMocks{
storeSvc: mockStoreReader,
}
tc.setupMocks(mocks)
opts := &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: tc.inAppName,
},
store: mockStoreReader,
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestAppUpgradeOpts_Ask(t *testing.T) {
testError := errors.New("some error")
testCases := map[string]struct {
inApp string
setupMocks func(mocks appUpgradeMocks)
wantedApp string
wantedError error
}{
"with all flags": {
inApp: "my-app",
setupMocks: func(m appUpgradeMocks) {},
wantedApp: "my-app",
wantedError: nil,
},
"prompt for all input": {
inApp: "",
setupMocks: func(m appUpgradeMocks) {
m.sel.EXPECT().Application(appUpgradeNamePrompt, appUpgradeNameHelpPrompt).Return("my-app", nil)
},
wantedApp: "my-app",
wantedError: nil,
},
"returns error if failed to select application": {
inApp: "",
setupMocks: func(m appUpgradeMocks) {
m.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Return("", testError)
},
wantedError: fmt.Errorf("select application: %w", testError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := appUpgradeMocks{
sel: mocks.NewMockappSelector(ctrl),
}
tc.setupMocks(mocks)
opts := &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: tc.inApp,
},
sel: mocks.sel,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, opts.name, "expected app names to match")
}
})
}
}
func TestAppUpgradeOpts_Execute(t *testing.T) {
const mockTemplateVersion = "v1.29.0"
versionGetterLegacy := func(string) (versionGetter, error) {
return &versionGetterDouble{
VersionFn: func() (string, error) {
return version.LegacyAppTemplate, nil
},
}, nil
}
testCases := map[string]struct {
given func(ctrl *gomock.Controller) *appUpgradeOpts
wantedErr error
}{
"should return error if fail to get template version": {
given: func(ctrl *gomock.Controller) *appUpgradeOpts {
return &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: "phonetool",
},
newVersionGetter: func(string) (versionGetter, error) {
return &versionGetterDouble{
VersionFn: func() (string, error) {
return "", errors.New("some error")
},
}, nil
},
}
},
wantedErr: fmt.Errorf("get template version of application phonetool: some error"),
},
"should return if app is up-to-date": {
given: func(ctrl *gomock.Controller) *appUpgradeOpts {
return &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: "phonetool",
},
newVersionGetter: func(string) (versionGetter, error) {
return &versionGetterDouble{
VersionFn: func() (string, error) {
return mockTemplateVersion, nil
},
}, nil
},
}
},
},
"should return error if fail to get application": {
given: func(ctrl *gomock.Controller) *appUpgradeOpts {
mockStore := mocks.NewMockstore(ctrl)
mockStore.EXPECT().GetApplication("phonetool").Return(nil, errors.New("some error"))
return &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: "phonetool",
},
newVersionGetter: versionGetterLegacy,
store: mockStore,
}
},
wantedErr: fmt.Errorf("get application phonetool: some error"),
},
"should return error if fail to get identity": {
given: func(ctrl *gomock.Controller) *appUpgradeOpts {
mockIdentity := mocks.NewMockidentityService(ctrl)
mockIdentity.EXPECT().Get().Return(identity.Caller{}, errors.New("some error"))
mockStore := mocks.NewMockstore(ctrl)
mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
return &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: "phonetool",
},
newVersionGetter: versionGetterLegacy,
identity: mockIdentity,
store: mockStore,
}
},
wantedErr: fmt.Errorf("get identity: some error"),
},
"should return error if fail to get hostedzone id": {
given: func(ctrl *gomock.Controller) *appUpgradeOpts {
mockIdentity := mocks.NewMockidentityService(ctrl)
mockIdentity.EXPECT().Get().Return(identity.Caller{Account: "1234"}, nil)
mockStore := mocks.NewMockstore(ctrl)
mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{
Name: "phonetool",
Domain: "foobar.com",
}, nil)
mockRoute53 := mocks.NewMockdomainHostedZoneGetter(ctrl)
mockRoute53.EXPECT().DomainHostedZoneID("foobar.com").Return("", errors.New("some error"))
return &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: "phonetool",
},
newVersionGetter: versionGetterLegacy,
identity: mockIdentity,
store: mockStore,
route53: mockRoute53,
}
},
wantedErr: fmt.Errorf("get hosted zone ID for domain foobar.com: some error"),
},
"should return error if fail to upgrade application": {
given: func(ctrl *gomock.Controller) *appUpgradeOpts {
mockIdentity := mocks.NewMockidentityService(ctrl)
mockIdentity.EXPECT().Get().Return(identity.Caller{Account: "1234"}, nil)
mockStore := mocks.NewMockstore(ctrl)
mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
mockStore.EXPECT().UpdateApplication(&config.Application{Name: "phonetool"}).Return(nil)
mockUpgrader := mocks.NewMockappUpgrader(ctrl)
mockUpgrader.EXPECT().UpgradeApplication(gomock.Any()).Return(errors.New("some error"))
return &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: "phonetool",
},
newVersionGetter: versionGetterLegacy,
identity: mockIdentity,
store: mockStore,
upgrader: mockUpgrader,
}
},
wantedErr: fmt.Errorf("upgrade application phonetool from version v0.0.0 to version %s: some error", mockTemplateVersion),
},
"success": {
given: func(ctrl *gomock.Controller) *appUpgradeOpts {
mockIdentity := mocks.NewMockidentityService(ctrl)
mockIdentity.EXPECT().Get().Return(identity.Caller{Account: "1234"}, nil)
mockStore := mocks.NewMockstore(ctrl)
mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{
Name: "phonetool",
Domain: "hello.com",
}, nil)
mockStore.EXPECT().UpdateApplication(&config.Application{
Name: "phonetool",
Domain: "hello.com",
DomainHostedZoneID: "2klfqok3",
}).Return(nil)
mockRoute53 := mocks.NewMockdomainHostedZoneGetter(ctrl)
mockRoute53.EXPECT().DomainHostedZoneID("hello.com").Return("2klfqok3", nil)
mockUpgrader := mocks.NewMockappUpgrader(ctrl)
mockUpgrader.EXPECT().UpgradeApplication(&deploy.CreateAppInput{
Name: "phonetool",
AccountID: "1234",
DomainName: "hello.com",
DomainHostedZoneID: "2klfqok3",
Version: mockTemplateVersion,
}).Return(nil)
return &appUpgradeOpts{
appUpgradeVars: appUpgradeVars{
name: "phonetool",
},
newVersionGetter: versionGetterLegacy,
identity: mockIdentity,
store: mockStore,
upgrader: mockUpgrader,
route53: mockRoute53,
}
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
opts := tc.given(ctrl)
opts.templateVersion = mockTemplateVersion
err := opts.Execute()
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 354 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package cli contains the copilot subcommands.
package cli
import (
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"github.com/dustin/go-humanize/english"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/cobra"
)
const (
svcAppNamePrompt = "Which application does your service belong to?"
wkldAppNameHelpPrompt = "An application groups all of your services and jobs together."
)
// tryReadingAppName retrieves the application's name from the workspace if it exists and returns it.
// If there is an error while retrieving the workspace summary, returns the empty string.
func tryReadingAppName() string {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return ""
}
summary, err := ws.Summary()
if err != nil {
return ""
}
return summary.Application
}
type errReservedArg struct {
val string
}
func (e *errReservedArg) Error() string {
return fmt.Sprintf(`argument %s is a reserved keyword, please use a different value`, color.HighlightUserInput(e.val))
}
// reservedArgs returns an error if the arguments contain any reserved keywords.
func reservedArgs(cmd *cobra.Command, args []string) error {
if len(args) != 1 {
return nil
}
if args[0] == "local" {
return &errReservedArg{val: "local"}
}
return nil
}
// runCmdE wraps one of the run error methods, PreRunE, RunE, of a cobra command so that if a user
// types "help" in the arguments the usage string is printed instead of running the command.
func runCmdE(f func(cmd *cobra.Command, args []string) error) func(cmd *cobra.Command, args []string) error {
return func(cmd *cobra.Command, args []string) error {
if len(args) == 1 && args[0] == "help" {
_ = cmd.Help() // Help always returns nil.
os.Exit(0)
}
return f(cmd, args)
}
}
// returns true if error type is stack set not exist.
func isStackSetNotExistsErr(err error) bool {
if err == nil {
return false
}
aerr, ok := err.(awserr.Error)
if !ok {
return isStackSetNotExistsErr(errors.Unwrap(err))
}
if aerr.Code() != "StackSetNotFoundException" {
return isStackSetNotExistsErr(errors.Unwrap(err))
}
return true
}
func run(cmd cmd) error {
if err := cmd.Validate(); err != nil {
return err
}
if err := cmd.Ask(); err != nil {
return err
}
if err := cmd.Execute(); err != nil {
return err
}
if actionCmd, ok := cmd.(actionCommand); ok {
if err := actionCmd.RecommendActions(); err != nil {
return err
}
}
return nil
}
func logRecommendedActions(actions []string) {
if len(actions) == 0 {
return
}
log.Infoln(fmt.Sprintf("Recommended follow-up %s:", english.PluralWord(len(actions), "action", "actions")))
for _, followup := range actions {
log.Infof("%s\n", indentListItem(followup))
}
}
func indentListItem(multiline string) string {
var prefixedLines []string
var inCodeBlock bool
for i, line := range strings.Split(multiline, "\n") {
if strings.Contains(line, "```") {
inCodeBlock = !inCodeBlock
}
var prefix string
switch {
case i == 0:
prefix = " - "
case inCodeBlock, strings.Contains(line, "```"):
prefix = ""
default:
prefix = " "
}
prefixedLines = append(prefixedLines, fmt.Sprintf("%s%s", prefix, line))
}
return strings.Join(prefixedLines, "\n")
}
func indentBy(multiline string, indentCount int) string {
var prefixedLines []string
for _, line := range strings.Split(multiline, "\n") {
prefix := strings.Repeat(" ", indentCount)
prefixedLines = append(prefixedLines, fmt.Sprintf("%s%s", prefix, line))
}
return strings.Join(prefixedLines, "\n")
}
func applyAll[T any](in []T, fn func(item T) T) []T {
out := make([]T, len(in))
for i, v := range in {
out[i] = fn(v)
}
return out
}
// displayPath takes any path and returns it in a form ready to be displayed to
// the user on the command line.
//
// No guarantees are given on the stability of the path across runs, all that is
// guaranteed is that the displayed path is visually pleasing & meaningful for a
// user.
//
// This path should not be stored in configuration files or used in any way except
// for being displayed to the user.
func displayPath(target string) string {
if !filepath.IsAbs(target) {
return filepath.Clean(target)
}
base, err := os.Getwd()
if err != nil {
return filepath.Clean(target)
}
rel, err := filepath.Rel(base, target)
if err != nil {
// No path from base to target available, return target as is.
return filepath.Clean(target)
}
return rel
}
| 183 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"io"
"os"
"github.com/spf13/cobra"
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
)
type shellCompleter interface {
GenBashCompletion(w io.Writer) error
GenZshCompletion(w io.Writer) error
GenFishCompletion(w io.Writer, includeDesc bool) error
}
type completionOpts struct {
Shell string // must be "bash" or "zsh" or "fish"
w io.Writer
completer shellCompleter
}
// Validate returns an error if the shell is not "bash" or "zsh" or "fish".
func (opts *completionOpts) Validate() error {
if opts.Shell == "bash" {
return nil
}
if opts.Shell == "zsh" {
return nil
}
if opts.Shell == "fish" {
return nil
}
return errors.New("shell must be bash, zsh or fish")
}
// Execute writes the completion code to the writer.
// This method assumes that Validate() was called prior to invocation.
func (opts *completionOpts) Execute() error {
if opts.Shell == "bash" {
return opts.completer.GenBashCompletion(opts.w)
}
if opts.Shell == "zsh" {
return opts.completer.GenZshCompletion(opts.w)
}
return opts.completer.GenFishCompletion(opts.w, true)
}
// BuildCompletionCmd returns the command to output shell completion code for the specified shell (bash or zsh or fish).
func BuildCompletionCmd(rootCmd *cobra.Command) *cobra.Command {
opts := &completionOpts{}
cmd := &cobra.Command{
Use: "completion [shell]",
Short: "Output shell completion code.",
Long: `Output shell completion code for bash, zsh or fish.
The code must be evaluated to provide interactive completion of commands.`,
Example: `
Install zsh completion
/code $ source <(copilot completion zsh)
/code $ copilot completion zsh > "${fpath[1]}/_copilot" # to autoload on startup
Install bash completion on macOS using homebrew
/code $ brew install bash-completion # if running 3.2
/code $ brew install bash-completion@2 # if running Bash 4.1+
/code $ copilot completion bash > /usr/local/etc/bash_completion.d
Install bash completion on linux
/code $ source <(copilot completion bash)
/code $ copilot completion bash > copilot.sh
/code $ sudo mv copilot.sh /etc/bash_completion.d/copilot
Install fish completion
/code$ copilot completion fish | source
To load completions for each session, execute once:
/code$ copilot completion fish > ~/.config/fish/completions/copilot.fish`,
Args: func(cmd *cobra.Command, args []string) error {
if len(args) != 1 {
return errors.New("requires a single shell argument (bash, zsh or fish)")
}
return nil
},
PreRunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts.Shell = args[0]
return opts.Validate()
}),
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts.w = os.Stdout
opts.completer = rootCmd
return opts.Execute()
}),
}
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Settings,
}
return cmd
}
| 106 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestCompletionOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inputShell string
wantedError error
}{
"zsh": {
inputShell: "zsh",
wantedError: nil,
},
"bash": {
inputShell: "bash",
wantedError: nil,
},
"fish": {
inputShell: "fish",
wantedError: nil,
},
"invalid shell": {
inputShell: "chicken",
wantedError: errors.New("shell must be bash, zsh or fish"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
opts := completionOpts{Shell: tc.inputShell}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedError == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
func TestCompletionOpts_Execute(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
testCases := map[string]struct {
inputShell string
mocking func(mock *mocks.MockshellCompleter)
wantedError error
}{
"bash": {
inputShell: "bash",
mocking: func(mock *mocks.MockshellCompleter) {
mock.EXPECT().GenBashCompletion(gomock.Any()).Times(1)
mock.EXPECT().GenZshCompletion(gomock.Any()).Times(0)
mock.EXPECT().GenFishCompletion(gomock.Any(), gomock.Any()).Times(0)
},
},
"zsh": {
inputShell: "zsh",
mocking: func(mock *mocks.MockshellCompleter) {
mock.EXPECT().GenBashCompletion(gomock.Any()).Times(0)
mock.EXPECT().GenZshCompletion(gomock.Any()).Times(1)
mock.EXPECT().GenFishCompletion(gomock.Any(), gomock.Any()).Times(0)
},
},
"fish": {
inputShell: "fish",
mocking: func(mock *mocks.MockshellCompleter) {
mock.EXPECT().GenBashCompletion(gomock.Any()).Times(0)
mock.EXPECT().GenZshCompletion(gomock.Any()).Times(0)
mock.EXPECT().GenFishCompletion(gomock.Any(), gomock.Any()).Times(1)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
mock := mocks.NewMockshellCompleter(ctrl)
tc.mocking(mock)
opts := completionOpts{Shell: tc.inputShell, completer: mock}
// WHEN
opts.Execute()
})
}
}
| 103 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/cobra"
)
const (
svcWkldType = "svc"
jobWkldType = "job"
)
type deployOpts struct {
deployWkldVars
deployWkld actionCommand
setupDeployCmd func(*deployOpts, string)
sel wsSelector
store store
ws wsWlDirReader
prompt prompter
// values for logging
wlType string
}
func newDeployOpts(vars deployWkldVars) (*deployOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("deploy"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
prompter := prompt.New()
return &deployOpts{
deployWkldVars: vars,
store: store,
sel: selector.NewLocalWorkloadSelector(prompter, store, ws),
ws: ws,
prompt: prompter,
setupDeployCmd: func(o *deployOpts, workloadType string) {
switch {
case contains(workloadType, manifestinfo.JobTypes()):
opts := &deployJobOpts{
deployWkldVars: o.deployWkldVars,
store: o.store,
ws: o.ws,
newInterpolator: newManifestInterpolator,
unmarshal: manifest.UnmarshalWorkload,
sel: selector.NewLocalWorkloadSelector(o.prompt, o.store, ws),
cmd: exec.NewCmd(),
sessProvider: sessProvider,
}
opts.newJobDeployer = func() (workloadDeployer, error) {
return newJobDeployer(opts)
}
o.deployWkld = opts
case contains(workloadType, manifestinfo.ServiceTypes()):
opts := &deploySvcOpts{
deployWkldVars: o.deployWkldVars,
store: o.store,
ws: o.ws,
newInterpolator: newManifestInterpolator,
unmarshal: manifest.UnmarshalWorkload,
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
sel: selector.NewLocalWorkloadSelector(o.prompt, o.store, ws),
prompt: o.prompt,
cmd: exec.NewCmd(),
sessProvider: sessProvider,
}
opts.newSvcDeployer = func() (workloadDeployer, error) {
return newSvcDeployer(opts)
}
o.deployWkld = opts
}
},
}, nil
}
func (o *deployOpts) Run() error {
if err := o.askName(); err != nil {
return err
}
if err := o.loadWkld(); err != nil {
return err
}
if err := o.deployWkld.Execute(); err != nil {
return fmt.Errorf("execute %s deploy: %w", o.wlType, err)
}
if err := o.deployWkld.RecommendActions(); err != nil {
return err
}
return nil
}
func (o *deployOpts) askName() error {
if o.name != "" {
return nil
}
name, err := o.sel.Workload("Select a service or job in your workspace", "")
if err != nil {
return fmt.Errorf("select service or job: %w", err)
}
o.name = name
return nil
}
func (o *deployOpts) loadWkld() error {
if err := o.loadWkldCmd(); err != nil {
return err
}
if err := o.deployWkld.Ask(); err != nil {
return fmt.Errorf("ask %s deploy: %w", o.wlType, err)
}
if err := o.deployWkld.Validate(); err != nil {
return fmt.Errorf("validate %s deploy: %w", o.wlType, err)
}
return nil
}
func (o *deployOpts) loadWkldCmd() error {
wl, err := o.store.GetWorkload(o.appName, o.name)
if err != nil {
return fmt.Errorf("retrieve %s from application %s: %w", o.appName, o.name, err)
}
o.setupDeployCmd(o, wl.Type)
if strings.Contains(strings.ToLower(wl.Type), jobWkldType) {
o.wlType = jobWkldType
return nil
}
o.wlType = svcWkldType
return nil
}
// BuildDeployCmd is the deploy command.
func BuildDeployCmd() *cobra.Command {
vars := deployWkldVars{}
cmd := &cobra.Command{
Use: "deploy",
Short: "Deploy a Copilot job or service.",
Long: "Deploy a Copilot job or service.",
Example: `
Deploys a service named "frontend" to a "test" environment.
/code $ copilot deploy --name frontend --env test
Deploys a job named "mailer" with additional resource tags to a "prod" environment.
/code $ copilot deploy -n mailer -e prod --resource-tags source/revision=bb133e7,deployment/initiator=manual`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeployOpts(vars)
if err != nil {
return err
}
if err := opts.Run(); err != nil {
return err
}
return nil
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", workloadFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVar(&vars.imageTag, imageTagFlag, "", imageTagFlagDescription)
cmd.Flags().StringToStringVar(&vars.resourceTags, resourceTagsFlag, nil, resourceTagsFlagDescription)
cmd.Flags().BoolVar(&vars.forceNewUpdate, forceFlag, false, forceFlagDescription)
cmd.Flags().BoolVar(&vars.disableRollback, noRollbackFlag, false, noRollbackFlagDescription)
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Release,
}
return cmd
}
| 203 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestDeployOpts_Run(t *testing.T) {
mockWl := config.Workload{
App: "app",
Name: "fe",
Type: "Load Balanced Web Service",
}
mockJob := config.Workload{
App: "app",
Name: "mailer",
Type: "Scheduled Job",
}
testCases := map[string]struct {
inAppName string
inName string
wantedErr string
mockSel func(m *mocks.MockwsSelector)
mockActionCommand func(m *mocks.MockactionCommand)
mockStore func(m *mocks.Mockstore)
}{
"prompts for workload": {
inAppName: "app",
mockSel: func(m *mocks.MockwsSelector) {
m.EXPECT().Workload("Select a service or job in your workspace", "").Return("fe", nil)
},
mockActionCommand: func(m *mocks.MockactionCommand) {
m.EXPECT().Ask()
m.EXPECT().Validate()
m.EXPECT().Execute()
m.EXPECT().RecommendActions()
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetWorkload("app", "fe").Return(&mockWl, nil)
},
},
"errors correctly if job returned": {
inAppName: "app",
wantedErr: "ask job deploy: some error",
mockSel: func(m *mocks.MockwsSelector) {
m.EXPECT().Workload("Select a service or job in your workspace", "").Return("mailer", nil)
},
mockActionCommand: func(m *mocks.MockactionCommand) {
m.EXPECT().Ask().Return(errors.New("some error"))
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetWorkload("app", "mailer").Return(&mockJob, nil)
},
},
"doesn't prompt if name is specified": {
inAppName: "app",
inName: "fe",
mockSel: func(m *mocks.MockwsSelector) {},
mockActionCommand: func(m *mocks.MockactionCommand) {
m.EXPECT().Ask()
m.EXPECT().Validate()
m.EXPECT().Execute()
m.EXPECT().RecommendActions()
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetWorkload("app", "fe").Return(&mockWl, nil)
},
},
"get name error": {
inAppName: "app",
wantedErr: "select service or job: some error",
mockSel: func(m *mocks.MockwsSelector) {
m.EXPECT().Workload(gomock.Any(), gomock.Any()).Return("", errors.New("some error"))
},
mockActionCommand: func(m *mocks.MockactionCommand) {},
mockStore: func(m *mocks.Mockstore) {},
},
"ask error": {
inAppName: "app",
inName: "fe",
wantedErr: "ask svc deploy: some error",
mockSel: func(m *mocks.MockwsSelector) {},
mockActionCommand: func(m *mocks.MockactionCommand) {
m.EXPECT().Ask().Return(errors.New("some error"))
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetWorkload("app", "fe").Return(&mockWl, nil)
},
},
"validate error": {
inAppName: "app",
inName: "fe",
wantedErr: "validate svc deploy: some error",
mockSel: func(m *mocks.MockwsSelector) {},
mockActionCommand: func(m *mocks.MockactionCommand) {
m.EXPECT().Ask()
m.EXPECT().Validate().Return(errors.New("some error"))
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetWorkload("app", "fe").Return(&mockWl, nil)
},
},
"execute error": {
inAppName: "app",
inName: "fe",
wantedErr: "execute svc deploy: some error",
mockSel: func(m *mocks.MockwsSelector) {},
mockActionCommand: func(m *mocks.MockactionCommand) {
m.EXPECT().Ask()
m.EXPECT().Validate()
m.EXPECT().Execute().Return(errors.New("some error"))
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetWorkload("app", "fe").Return(&mockWl, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSel := mocks.NewMockwsSelector(ctrl)
mockCmd := mocks.NewMockactionCommand(ctrl)
mockStore := mocks.NewMockstore(ctrl)
tc.mockStore(mockStore)
tc.mockSel(mockSel)
tc.mockActionCommand(mockCmd)
opts := &deployOpts{
deployWkldVars: deployWkldVars{
appName: tc.inAppName,
name: tc.inName,
envName: "test",
},
deployWkld: mockCmd,
sel: mockSel,
store: mockStore,
setupDeployCmd: func(o *deployOpts, wlType string) {},
}
// WHEN
err := opts.Run()
// THEN
if tc.wantedErr != "" {
require.EqualError(t, err, tc.wantedErr)
}
})
}
}
| 167 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"os/exec"
"runtime"
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
)
const (
docsURL = "https://aws.github.io/copilot-cli/"
)
// BuildDocsCmd builds the command for opening the documentation.
func BuildDocsCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "docs",
Short: "Open the copilot docs.",
Long: "Open the copilot docs.",
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
var err error
switch runtime.GOOS {
case "linux":
err = exec.Command("xdg-open", docsURL).Start()
case "windows":
err = exec.Command("rundll32", "url.dll,FileProtocolHandler", docsURL).Start()
case "darwin":
err = exec.Command("open", docsURL).Start()
default:
err = fmt.Errorf("unsupported platform")
}
if err != nil {
return fmt.Errorf("open docs: %w", err)
}
return nil
}),
Annotations: map[string]string{
"group": group.GettingStarted,
},
}
cmd.SetUsageTemplate(template.Usage)
return cmd
}
| 54 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
"golang.org/x/mod/semver"
)
func validateMinEnvVersion(ws wsEnvironmentsLister, checker versionCompatibilityChecker, app, env, minWantedVersion, friendlyFeatureName string) error {
version, err := checker.Version()
if err != nil {
return fmt.Errorf("retrieve version of environment stack %q in application %q: %v", env, app, err)
}
if semver.Compare(version, minWantedVersion) < 0 {
return &errFeatureIncompatibleWithEnvironment{
ws: ws,
missingFeature: friendlyFeatureName,
envName: env,
curVersion: version,
}
}
return nil
}
// BuildEnvCmd is the top level command for environments.
func BuildEnvCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "env",
Short: `Commands for environments.
Environments are deployment stages shared between services.`,
Long: `Commands for environments.
Environments are deployment stages shared between services.`,
}
cmd.AddCommand(buildEnvInitCmd())
cmd.AddCommand(buildEnvListCmd())
cmd.AddCommand(buildEnvShowCmd())
cmd.AddCommand(buildEnvUpgradeCmd())
cmd.AddCommand(buildEnvPkgCmd())
cmd.AddCommand(buildEnvOverrideCmd())
cmd.AddCommand(buildEnvDeployCmd())
cmd.AddCommand(buildEnvDeleteCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Develop,
}
return cmd
}
| 55 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"strings"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
awscfn "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/iam"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
"gopkg.in/yaml.v3"
)
const (
envDeleteAppNameHelpPrompt = "An environment will be deleted in the selected application."
envDeleteNamePrompt = "Which environment would you like to delete?"
fmtDeleteEnvPrompt = "Are you sure you want to delete environment %q from application %q?"
)
const (
fmtRetainEnvRolesStart = "Retain IAM roles before deleting the %q environment"
fmtRetainEnvRolesFailed = "Failed to retain IAM roles for the %q environment\n"
fmtRetainEnvRolesComplete = "Retained IAM roles for the %q environment\n"
fmtDeleteEnvStart = "Deleting IAM roles and deregistering environment %q from application %q."
fmtDeleteEnvIAMFailed = "Failed to delete IAM roles of environment %q from application %q.\n"
fmtDeleteEnvSSMFailed = "Failed to deregister environment %q from application %q.\n"
fmtDeleteEnvComplete = "Deleted environment %q from application %q.\n"
)
var (
envDeleteAppNamePrompt = fmt.Sprintf("In which %s would you like to delete the environment?", color.Emphasize("application"))
)
var (
errEnvDeleteCancelled = errors.New("env delete cancelled - no changes made")
)
type resourceGetter interface {
GetResources(*resourcegroupstaggingapi.GetResourcesInput) (*resourcegroupstaggingapi.GetResourcesOutput, error)
}
type deleteEnvVars struct {
appName string
name string
skipConfirmation bool
}
type deleteEnvOpts struct {
deleteEnvVars
// Interfaces for dependencies.
store environmentStore
rg resourceGetter
deployer environmentDeployer
iam roleDeleter
prog progress
prompt prompter
sel configSelector
// cached data to avoid fetching the same information multiple times.
envConfig *config.Environment
// initRuntimeClients is overridden in tests.
initRuntimeClients func(*deleteEnvOpts) error
}
func newDeleteEnvOpts(vars deleteEnvVars) (*deleteEnvOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("env delete"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompter := prompt.New()
return &deleteEnvOpts{
deleteEnvVars: vars,
store: store,
prog: termprogress.NewSpinner(log.DiagnosticWriter),
sel: selector.NewConfigSelector(prompter, store),
prompt: prompter,
initRuntimeClients: func(o *deleteEnvOpts) error {
env, err := o.getEnvConfig()
if err != nil {
return err
}
sess, err := sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return fmt.Errorf("create session from environment manager role %s in region %s: %w", env.ManagerRoleARN, env.Region, err)
}
o.rg = resourcegroupstaggingapi.New(sess)
o.iam = iam.New(sess)
o.deployer = cloudformation.New(sess, cloudformation.WithProgressTracker(os.Stderr))
return nil
},
}, nil
}
// Validate returns an error if the individual user inputs are invalid.
func (o *deleteEnvOpts) Validate() error {
if o.name != "" {
if err := o.validateEnvName(); err != nil {
return err
}
}
return nil
}
// Ask prompts for fields that are required but not passed in.
func (o *deleteEnvOpts) Ask() error {
if err := o.askAppName(); err != nil {
return err
}
if err := o.askEnvName(); err != nil {
return err
}
if o.skipConfirmation {
return nil
}
deleteConfirmed, err := o.prompt.Confirm(fmt.Sprintf(fmtDeleteEnvPrompt, o.name, o.appName), "", prompt.WithConfirmFinalMessage())
if err != nil {
return fmt.Errorf("confirm to delete environment %s: %w", o.name, err)
}
if !deleteConfirmed {
return errEnvDeleteCancelled
}
return nil
}
// Execute deletes the environment from the application by:
// 1. Deleting the cloudformation stack.
// 2. Deleting the EnvManagerRole and CFNExecutionRole.
// 3. Deleting the parameter from the SSM store.
// The environment is removed from the store only if other delete operations succeed.
// Execute assumes that Validate is invoked first.
func (o *deleteEnvOpts) Execute() error {
if err := o.initRuntimeClients(o); err != nil {
return err
}
if err := o.validateNoRunningServices(); err != nil {
return err
}
o.prog.Start(fmt.Sprintf(fmtRetainEnvRolesStart, o.name))
if err := o.ensureRolesAreRetained(); err != nil {
o.prog.Stop(log.Serrorf(fmtRetainEnvRolesFailed, o.name))
return err
}
o.prog.Stop(log.Ssuccessf(fmtRetainEnvRolesComplete, o.name))
if err := o.deleteStack(); err != nil {
return err
}
o.prog.Start(fmt.Sprintf(fmtDeleteEnvStart, o.name, o.appName))
if err := o.tryDeleteRoles(); err != nil {
o.prog.Stop(log.Serrorf(fmtDeleteEnvIAMFailed, o.name, o.appName))
return err
}
// Only remove from SSM if the stack and roles were deleted. Otherwise, the command will error when re-run.
if err := o.deleteFromStore(); err != nil {
o.prog.Stop(log.Serrorf(fmtDeleteEnvSSMFailed, o.name, o.appName))
return err
}
o.prog.Stop(log.Ssuccessf(fmtDeleteEnvComplete, o.name, o.appName))
return nil
}
// RecommendActions is a no-op for this command.
func (o *deleteEnvOpts) RecommendActions() error {
return nil
}
func (o *deleteEnvOpts) validateEnvName() error {
if _, err := o.getEnvConfig(); err != nil {
return err
}
return nil
}
func (o *deleteEnvOpts) askAppName() error {
if o.appName != "" {
return nil
}
app, err := o.sel.Application(envDeleteAppNamePrompt, envDeleteAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("ask for application: %w", err)
}
o.appName = app
return nil
}
func (o *deleteEnvOpts) askEnvName() error {
if o.name != "" {
return nil
}
env, err := o.sel.Environment(envDeleteNamePrompt, "", o.appName)
if err != nil {
return fmt.Errorf("select environment to delete: %w", err)
}
o.name = env
return nil
}
func (o *deleteEnvOpts) validateNoRunningServices() error {
stacks, err := o.rg.GetResources(&resourcegroupstaggingapi.GetResourcesInput{
ResourceTypeFilters: []*string{aws.String("cloudformation")},
TagFilters: []*resourcegroupstaggingapi.TagFilter{
{
Key: aws.String(deploy.ServiceTagKey),
Values: []*string{}, // Matches any service stack.
},
{
Key: aws.String(deploy.EnvTagKey),
Values: []*string{aws.String(o.name)},
},
{
Key: aws.String(deploy.AppTagKey),
Values: []*string{aws.String(o.appName)},
},
},
})
if err != nil {
return fmt.Errorf("find service cloudformation stacks: %w", err)
}
if len(stacks.ResourceTagMappingList) > 0 {
var svcNames []string
for _, cfnStack := range stacks.ResourceTagMappingList {
for _, t := range cfnStack.Tags {
if *t.Key != deploy.ServiceTagKey {
continue
}
svcNames = append(svcNames, *t.Value)
}
}
return fmt.Errorf("service '%s' still exist within the environment %s", strings.Join(svcNames, ", "), o.name)
}
return nil
}
// ensureRolesAreRetained guarantees that the CloudformationExecutionRole and the EnvironmentManagerRole
// are retained when the environment cloudformation stack is deleted.
//
// This method is needed because the environment stack is deleted using the CloudformationExecutionRole which means
// that the role has to be retained in order for us to delete the stack. Similarly, only the EnvironmentManagerRole
// has permissions to delete the CloudformationExecutionRole so it must be retained.
// In earlier versions of the CLI, pre-commit 7e5428a, environment stacks were created without these roles retained.
// In case we encounter a legacy stack, we need to first update the stack to make sure these roles are retained and then
// proceed with the regular flow.
func (o *deleteEnvOpts) ensureRolesAreRetained() error {
body, err := o.deployer.Template(stack.NameForEnv(o.appName, o.name))
if err != nil {
var stackDoesNotExist *awscfn.ErrStackNotFound
if errors.As(err, &stackDoesNotExist) {
return nil
}
return fmt.Errorf("get template body for environment %s in application %s: %v", o.name, o.appName, err)
}
// Check if the execution role and the manager role are retained by the stack.
tpl := struct {
Resources yaml.Node `yaml:"Resources"`
}{}
if err := yaml.Unmarshal([]byte(body), &tpl); err != nil {
return fmt.Errorf("unmarshal environment template body %s-%s to retrieve Resources: %w", o.appName, o.name, err)
}
roles := struct {
ExecRole yaml.Node `yaml:"CloudformationExecutionRole"`
ManagerRole yaml.Node `yaml:"EnvironmentManagerRole"`
}{}
if err := tpl.Resources.Decode(&roles); err != nil {
return fmt.Errorf("decode EnvironmentManagerRole and CloudformationExecutionRole from Resources: %w", err)
}
type roleProperties struct {
DeletionPolicy string `yaml:"DeletionPolicy"`
}
var execRoleProps roleProperties
if err := roles.ExecRole.Decode(&execRoleProps); err != nil {
return fmt.Errorf("decode CloudformationExecutionRole's deletion policy: %w", err)
}
var managerRoleProps roleProperties
if err := roles.ManagerRole.Decode(&managerRoleProps); err != nil {
return fmt.Errorf("decode EnvironmentManagerRole's deletion policy: %w", err)
}
const retainPolicy = "Retain"
retainsExecRole := execRoleProps.DeletionPolicy == retainPolicy
retainsManagerRole := managerRoleProps.DeletionPolicy == retainPolicy
if retainsExecRole && retainsManagerRole {
// Nothing to do, this is **not** a legacy environment stack. Exit successfully.
return nil
}
// Otherwise, update the body with the new deletion policies.
newBody := body
if !retainsExecRole {
parts := strings.Split(newBody, " CloudformationExecutionRole:\n")
newBody = parts[0] + " CloudformationExecutionRole:\n DeletionPolicy: Retain\n" + parts[1]
}
if !retainsManagerRole {
parts := strings.Split(newBody, " EnvironmentManagerRole:\n")
newBody = parts[0] + " EnvironmentManagerRole:\n DeletionPolicy: Retain\n" + parts[1]
}
env, err := o.getEnvConfig()
if err != nil {
return err
}
if err := o.deployer.UpdateEnvironmentTemplate(o.appName, o.name, newBody, env.ExecutionRoleARN); err != nil {
return fmt.Errorf("update environment stack to retain environment roles: %w", err)
}
return nil
}
// deleteStack returns nil if the stack was deleted successfully. Otherwise, returns the error.
func (o *deleteEnvOpts) deleteStack() error {
env, err := o.getEnvConfig()
if err != nil {
return err
}
if err := o.deployer.DeleteEnvironment(o.appName, o.name, env.ExecutionRoleARN); err != nil {
return fmt.Errorf("delete environment %s stack: %w", o.name, err)
}
return nil
}
// tryDeleteRoles attempts to delete the retained IAM roles part of an environment stack.
// The operation is best-effort because of the ManagerRole. Since the iam client is created with a
// session that assumes the ManagerRole, attempting to delete the same role can result in the following error:
// "AccessDenied: User: arn:aws:sts::1111:assumed-role/app-env-EnvManagerRole is not authorized to perform:
// iam:DeleteRole on resource: role app-env-EnvManagerRole"
// This error occurs because to delete a role you have to first remove all of its policies, so the role loses
// permission to delete itself and then attempts to delete itself. We think that due to eventual consistency this
// operation succeeds most of the time but on occasions we have observed it to fail.
func (o *deleteEnvOpts) tryDeleteRoles() error {
env, err := o.getEnvConfig()
if err != nil {
return err
}
_ = o.iam.DeleteRole(env.ExecutionRoleARN)
_ = o.iam.DeleteRole(env.ManagerRoleARN)
return nil
}
func (o *deleteEnvOpts) deleteFromStore() error {
if err := o.store.DeleteEnvironment(o.appName, o.name); err != nil {
return fmt.Errorf("delete environment %s configuration from application %s", o.name, o.appName)
}
return nil
}
func (o *deleteEnvOpts) getEnvConfig() (*config.Environment, error) {
if o.envConfig != nil {
// Already fetched once, return.
return o.envConfig, nil
}
env, err := o.store.GetEnvironment(o.appName, o.name)
if err != nil {
return nil, fmt.Errorf("get environment %s configuration from app %s: %v", o.name, o.appName, err)
}
o.envConfig = env
return env, nil
}
// buildEnvDeleteCmd builds the command to delete environment(s).
func buildEnvDeleteCmd() *cobra.Command {
vars := deleteEnvVars{}
cmd := &cobra.Command{
Use: "delete",
Short: "Deletes an environment from your application.",
Example: `
Delete the "test" environment.
/code $ copilot env delete --name test
Delete the "test" environment without prompting.
/code $ copilot env delete --name test --yes`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeleteEnvOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", envFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
return cmd
}
| 411 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
var noopInitRuntimeClients = func(opts *deleteEnvOpts) error {
return nil
}
func TestDeleteEnvOpts_Validate(t *testing.T) {
const (
testAppName = "phonetool"
testEnvName = "test"
)
testCases := map[string]struct {
inAppName string
inEnv string
mockStore func(ctrl *gomock.Controller) *mocks.MockenvironmentStore
wantedError error
}{
"failed to retrieve environment from store": {
inAppName: testAppName,
inEnv: testEnvName,
mockStore: func(ctrl *gomock.Controller) *mocks.MockenvironmentStore {
envStore := mocks.NewMockenvironmentStore(ctrl)
envStore.EXPECT().GetEnvironment(testAppName, testEnvName).Return(nil, errors.New("some error"))
return envStore
},
wantedError: errors.New("get environment test configuration from app phonetool: some error"),
},
"environment exists": {
inAppName: testAppName,
inEnv: testEnvName,
mockStore: func(ctrl *gomock.Controller) *mocks.MockenvironmentStore {
envStore := mocks.NewMockenvironmentStore(ctrl)
envStore.EXPECT().GetEnvironment(testAppName, testEnvName).Return(&config.Environment{}, nil)
return envStore
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
opts := &deleteEnvOpts{
deleteEnvVars: deleteEnvVars{
name: tc.inEnv,
appName: tc.inAppName,
},
store: tc.mockStore(ctrl),
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
func TestDeleteEnvOpts_Ask(t *testing.T) {
const (
testApp = "phonetool"
testEnv = "test"
)
testCases := map[string]struct {
inAppName string
inEnvName string
inSkipConfirmation bool
mockDependencies func(ctrl *gomock.Controller, o *deleteEnvOpts)
wantedEnvName string
wantedError error
}{
"prompts for all required flags": {
inSkipConfirmation: false,
mockDependencies: func(ctrl *gomock.Controller, o *deleteEnvOpts) {
mockSelector := mocks.NewMockconfigSelector(ctrl)
mockSelector.EXPECT().Application(envDeleteAppNamePrompt, envDeleteAppNameHelpPrompt, gomock.Any()).
Return(testApp, nil)
mockSelector.EXPECT().Environment(envDeleteNamePrompt, "", testApp).Return(testEnv, nil)
mockPrompter := mocks.NewMockprompter(ctrl)
mockPrompter.EXPECT().Confirm(fmt.Sprintf(fmtDeleteEnvPrompt, testEnv, testApp), gomock.Any(), gomock.Any()).Return(true, nil)
o.sel = mockSelector
o.prompt = mockPrompter
},
wantedEnvName: testEnv,
},
"error if fail to select applications": {
mockDependencies: func(ctrl *gomock.Controller, o *deleteEnvOpts) {
mockSelector := mocks.NewMockconfigSelector(ctrl)
mockSelector.EXPECT().Application(envDeleteAppNamePrompt, envDeleteAppNameHelpPrompt, gomock.Any()).
Return("", errors.New("some error"))
o.sel = mockSelector
},
wantedError: fmt.Errorf("ask for application: some error"),
},
"wraps error from prompting for confirmation": {
inSkipConfirmation: false,
inAppName: testApp,
inEnvName: testEnv,
mockDependencies: func(ctrl *gomock.Controller, o *deleteEnvOpts) {
mockPrompter := mocks.NewMockprompter(ctrl)
mockPrompter.EXPECT().Confirm(fmt.Sprintf(fmtDeleteEnvPrompt, testEnv, testApp), gomock.Any(), gomock.Any()).Return(false, errors.New("some error"))
o.prompt = mockPrompter
},
wantedError: errors.New("confirm to delete environment test: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
opts := &deleteEnvOpts{
deleteEnvVars: deleteEnvVars{
name: tc.inEnvName,
appName: tc.inAppName,
skipConfirmation: tc.inSkipConfirmation,
},
}
tc.mockDependencies(ctrl, opts)
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError == nil {
require.Equal(t, tc.wantedEnvName, opts.name)
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
func TestDeleteEnvOpts_Execute(t *testing.T) {
testCases := map[string]struct {
given func(t *testing.T, ctrl *gomock.Controller) *deleteEnvOpts
mockRG func(ctrl *gomock.Controller) *mocks.MockresourceGetter
mockProg func(ctrl *gomock.Controller) *mocks.Mockprogress
mockDeploy func(ctrl *gomock.Controller) *mocks.MockenvironmentDeployer
mockStore func(ctrl *gomock.Controller) *mocks.MockenvironmentStore
wantedError error
}{
"returns wrapped errors when failed to retrieve running services in the environment": {
given: func(t *testing.T, ctrl *gomock.Controller) *deleteEnvOpts {
m := mocks.NewMockresourceGetter(ctrl)
m.EXPECT().GetResources(gomock.Any()).Return(nil, errors.New("some error"))
return &deleteEnvOpts{
rg: m,
initRuntimeClients: noopInitRuntimeClients,
}
},
wantedError: errors.New("find service cloudformation stacks: some error"),
},
"returns error when there are running services": {
given: func(t *testing.T, ctrl *gomock.Controller) *deleteEnvOpts {
m := mocks.NewMockresourceGetter(ctrl)
m.EXPECT().GetResources(gomock.Any()).Return(&resourcegroupstaggingapi.GetResourcesOutput{
ResourceTagMappingList: []*resourcegroupstaggingapi.ResourceTagMapping{
{
Tags: []*resourcegroupstaggingapi.Tag{
{
Key: aws.String(deploy.ServiceTagKey),
Value: aws.String("frontend"),
},
{
Key: aws.String(deploy.ServiceTagKey),
Value: aws.String("backend"),
},
},
},
},
}, nil)
return &deleteEnvOpts{
deleteEnvVars: deleteEnvVars{
appName: "phonetool",
name: "test",
},
rg: m,
initRuntimeClients: noopInitRuntimeClients,
}
},
wantedError: errors.New("service 'frontend, backend' still exist within the environment test"),
},
"returns wrapped error when environment stack cannot be updated to retain roles": {
given: func(t *testing.T, ctrl *gomock.Controller) *deleteEnvOpts {
rg := mocks.NewMockresourceGetter(ctrl)
rg.EXPECT().GetResources(gomock.Any()).Return(&resourcegroupstaggingapi.GetResourcesOutput{
ResourceTagMappingList: []*resourcegroupstaggingapi.ResourceTagMapping{}}, nil)
prog := mocks.NewMockprogress(ctrl)
prog.EXPECT().Start(gomock.Any())
deployer := mocks.NewMockenvironmentDeployer(ctrl)
deployer.EXPECT().Template(gomock.Any()).Return(`
Resources:
EnableLongARNFormatAction:
Type: Custom::EnableLongARNFormatFunction
DependsOn:
- EnableLongARNFormatFunction
Properties:
ServiceToken: !GetAtt EnableLongARNFormatFunction.Arn
CloudformationExecutionRole:
Type: AWS::IAM::Role
EnvironmentManagerRole:
Type: AWS::IAM::Role
`, nil)
deployer.EXPECT().UpdateEnvironmentTemplate(
"phonetool",
"test",
`
Resources:
EnableLongARNFormatAction:
Type: Custom::EnableLongARNFormatFunction
DependsOn:
- EnableLongARNFormatFunction
Properties:
ServiceToken: !GetAtt EnableLongARNFormatFunction.Arn
CloudformationExecutionRole:
DeletionPolicy: Retain
Type: AWS::IAM::Role
EnvironmentManagerRole:
DeletionPolicy: Retain
Type: AWS::IAM::Role
`, "arn").Return(errors.New("some error"))
prog.EXPECT().Stop(log.Serror("Failed to retain IAM roles for the \"test\" environment\n"))
return &deleteEnvOpts{
deleteEnvVars: deleteEnvVars{
appName: "phonetool",
name: "test",
},
rg: rg,
deployer: deployer,
prog: prog,
envConfig: &config.Environment{
ExecutionRoleARN: "arn",
},
initRuntimeClients: noopInitRuntimeClients,
}
},
wantedError: errors.New("update environment stack to retain environment roles: some error"),
},
"returns wrapped error when stack cannot be deleted": {
given: func(t *testing.T, ctrl *gomock.Controller) *deleteEnvOpts {
rg := mocks.NewMockresourceGetter(ctrl)
rg.EXPECT().GetResources(gomock.Any()).Return(&resourcegroupstaggingapi.GetResourcesOutput{
ResourceTagMappingList: []*resourcegroupstaggingapi.ResourceTagMapping{}}, nil)
prog := mocks.NewMockprogress(ctrl)
prog.EXPECT().Start(gomock.Any())
deployer := mocks.NewMockenvironmentDeployer(ctrl)
deployer.EXPECT().Template(gomock.Any()).Return(`
Resources:
CloudformationExecutionRole:
DeletionPolicy: Retain
EnvironmentManagerRole:
# An IAM Role to manage resources in your environment
DeletionPolicy: Retain`, nil)
deployer.EXPECT().DeleteEnvironment(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New("some error"))
prog.EXPECT().Stop(gomock.Any())
return &deleteEnvOpts{
deleteEnvVars: deleteEnvVars{
appName: "phonetool",
name: "test",
},
rg: rg,
deployer: deployer,
prog: prog,
envConfig: &config.Environment{},
initRuntimeClients: noopInitRuntimeClients,
}
},
wantedError: errors.New("delete environment test stack: some error"),
},
"deletes the stack, then attempts a best-effort deletion of the IAM roles, and finally cleans up SSM on success": {
given: func(t *testing.T, ctrl *gomock.Controller) *deleteEnvOpts {
rg := mocks.NewMockresourceGetter(ctrl)
rg.EXPECT().GetResources(gomock.Any()).Return(&resourcegroupstaggingapi.GetResourcesOutput{
ResourceTagMappingList: []*resourcegroupstaggingapi.ResourceTagMapping{}}, nil)
prog := mocks.NewMockprogress(ctrl)
prog.EXPECT().Start(gomock.Any()).AnyTimes()
deployer := mocks.NewMockenvironmentDeployer(ctrl)
deployer.EXPECT().Template(stack.NameForEnv("phonetool", "test")).Return(`
Resources:
CloudformationExecutionRole:
DeletionPolicy: Retain
Type: AWS::IAM::Role
EnvironmentManagerRole:
# An IAM Role to manage resources in your environment
DeletionPolicy: Retain
Type: AWS::IAM::Role
`, nil)
deployer.EXPECT().DeleteEnvironment("phonetool", "test", "execARN").Return(nil)
iam := mocks.NewMockroleDeleter(ctrl)
iam.EXPECT().DeleteRole("execARN").Return(nil)
iam.EXPECT().DeleteRole("managerRoleARN").Return(nil)
store := mocks.NewMockenvironmentStore(ctrl)
store.EXPECT().DeleteEnvironment("phonetool", "test").Return(nil)
prog.EXPECT().Stop(gomock.Any()).AnyTimes()
return &deleteEnvOpts{
deleteEnvVars: deleteEnvVars{
appName: "phonetool",
name: "test",
},
rg: rg,
deployer: deployer,
prog: prog,
iam: iam,
store: store,
envConfig: &config.Environment{
ExecutionRoleARN: "execARN",
ManagerRoleARN: "managerRoleARN",
},
initRuntimeClients: noopInitRuntimeClients,
}
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
opts := tc.given(t, ctrl)
// WHEN
err := opts.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 389 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"path/filepath"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
awscfn "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
"golang.org/x/mod/semver"
)
const continueDeploymentPrompt = "Continue with the deployment?"
type deployEnvVars struct {
appName string
name string
forceNewUpdate bool
disableRollback bool
showDiff bool
skipDiffPrompt bool
allowEnvDowngrade bool
}
type deployEnvOpts struct {
deployEnvVars
// Dependencies.
store store
sessionProvider *sessions.Provider
// Dependencies to ask.
sel wsEnvironmentSelector
prompt prompter
// Dependencies to execute.
fs afero.Fs
ws wsEnvironmentReader
identity identityService
newInterpolator func(app, env string) interpolator
newEnvVersionGetter func(appName, envName string) (versionGetter, error)
newEnvDeployer func() (envDeployer, error)
// Cached variables.
targetApp *config.Application
targetEnv *config.Environment
// Overridden in tests.
templateVersion string
}
func newEnvDeployOpts(vars deployEnvVars) (*deployEnvOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("env deploy"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
prompter := prompt.New()
opts := &deployEnvOpts{
deployEnvVars: vars,
store: store,
sessionProvider: sessProvider,
sel: selector.NewLocalEnvironmentSelector(prompter, store, ws),
newEnvVersionGetter: func(appName, envName string) (versionGetter, error) {
return describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: store,
})
},
prompt: prompter,
fs: fs,
ws: ws,
identity: identity.New(defaultSess),
templateVersion: version.LatestTemplateVersion(),
newInterpolator: newManifestInterpolator,
}
opts.newEnvDeployer = func() (envDeployer, error) {
return newEnvDeployer(opts, ws)
}
return opts, nil
}
func newEnvDeployer(opts *deployEnvOpts, ws deploy.WorkspaceAddonsReaderPathGetter) (envDeployer, error) {
app, err := opts.cachedTargetApp()
if err != nil {
return nil, err
}
env, err := opts.cachedTargetEnv()
if err != nil {
return nil, err
}
ovrdr, err := deploy.NewOverrider(opts.ws.EnvOverridesPath(), env.App, env.Name, opts.fs, opts.sessionProvider)
if err != nil {
return nil, err
}
return deploy.NewEnvDeployer(&deploy.NewEnvDeployerInput{
App: app,
Env: env,
SessionProvider: opts.sessionProvider,
ConfigStore: opts.store,
Workspace: ws,
Overrider: ovrdr,
})
}
// Validate is a no-op for this command.
func (o *deployEnvOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *deployEnvOpts) Ask() error {
if o.appName == "" {
// NOTE: This command is required to be executed under a workspace. We don't prompt for it.
return errNoAppInWorkspace
}
if _, err := o.cachedTargetApp(); err != nil {
return err
}
return o.validateOrAskEnvName()
}
func validateEnvVersion(vg versionGetter, name, templateVersion string) error {
envVersion, err := vg.Version()
if err != nil {
return fmt.Errorf("get template version of environment %s: %w", name, err)
}
if envVersion == version.EnvTemplateBootstrap {
// Allow update to bootstrap env stack anyway.
return nil
}
if diff := semver.Compare(envVersion, templateVersion); diff > 0 {
return &errCannotDowngradeEnvVersion{
envName: name,
envVersion: envVersion,
templateVersion: templateVersion,
}
}
return nil
}
// Execute deploys an environment given a manifest.
func (o *deployEnvOpts) Execute() error {
if !o.allowEnvDowngrade {
envVersionGetter, err := o.newEnvVersionGetter(o.appName, o.name)
if err != nil {
return err
}
if err := validateEnvVersion(envVersionGetter, o.name, o.templateVersion); err != nil {
return err
}
}
rawMft, err := o.ws.ReadEnvironmentManifest(o.name)
if err != nil {
return fmt.Errorf("read manifest for environment %q: %w", o.name, err)
}
mft, err := environmentManifest(o.name, rawMft, o.newInterpolator(o.appName, o.name))
if err != nil {
return err
}
caller, err := o.identity.Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
deployer, err := o.newEnvDeployer()
if err != nil {
return err
}
if err := deployer.Validate(mft); err != nil {
return err
}
artifacts, err := deployer.UploadArtifacts()
if err != nil {
return fmt.Errorf("upload artifacts for environment %s: %w", o.name, err)
}
deployInput := &deploy.DeployEnvironmentInput{
RootUserARN: caller.RootUserARN,
AddonsURL: artifacts.AddonsURL,
CustomResourcesURLs: artifacts.CustomResourceURLs,
Manifest: mft,
RawManifest: rawMft,
PermissionsBoundary: o.targetApp.PermissionsBoundary,
ForceNewUpdate: o.forceNewUpdate,
DisableRollback: o.disableRollback,
Version: o.templateVersion,
}
if o.showDiff {
contd, err := o.showDiffAndConfirmDeployment(deployer, deployInput)
if err != nil {
return err
}
if !contd {
return nil
}
}
if err := deployer.DeployEnvironment(deployInput); err != nil {
var errEmptyChangeSet *awscfn.ErrChangeSetEmpty
if errors.As(err, &errEmptyChangeSet) {
log.Errorf(`Your update does not introduce immediate resource changes.
This may be because the resources are not created until they are deemed
necessary by a service deployment.
In this case, you can run %s to push a modified template, even if there are no immediate changes.
`, color.HighlightCode("copilot env deploy --force"))
}
if o.disableRollback {
stackName := stack.NameForEnv(o.targetApp.Name, o.targetEnv.Name)
rollbackCmd := fmt.Sprintf("aws cloudformation rollback-stack --stack-name %s --role-arn %s", stackName, o.targetEnv.ExecutionRoleARN)
log.Infof(`It seems like you have disabled automatic stack rollback for this deployment.
To debug, you can visit the AWS console to inspect the errors.
After fixing the deployment, you can:
1. Run %s to rollback the deployment.
2. Run %s to make a new deployment.
`, color.HighlightCode(rollbackCmd), color.HighlightCode("copilot env deploy"))
}
return fmt.Errorf("deploy environment %s: %w", o.name, err)
}
return nil
}
func environmentManifest(envName string, rawMft []byte, transformer interpolator) (*manifest.Environment, error) {
interpolated, err := transformer.Interpolate(string(rawMft))
if err != nil {
return nil, fmt.Errorf("interpolate environment variables for %q manifest: %w", envName, err)
}
mft, err := manifest.UnmarshalEnvironment([]byte(interpolated))
if err != nil {
return nil, fmt.Errorf("unmarshal environment manifest for %q: %w", envName, err)
}
if err := mft.Validate(); err != nil {
return nil, fmt.Errorf("validate environment manifest for %q: %w", envName, err)
}
return mft, nil
}
func (o *deployEnvOpts) showDiffAndConfirmDeployment(deployer envDeployer, input *deploy.DeployEnvironmentInput) (bool, error) {
output, err := deployer.GenerateCloudFormationTemplate(input)
if err != nil {
return false, fmt.Errorf("generate the template for environment %q: %w", o.name, err)
}
if err := diff(deployer, output.Template, os.Stdout); err != nil {
var errHasDiff *errHasDiff
if !errors.As(err, &errHasDiff) {
return false, fmt.Errorf("generate diff for environment %q: %w", o.name, err)
}
}
if o.skipDiffPrompt {
return true, nil
}
contd, err := o.prompt.Confirm(continueDeploymentPrompt, "")
if err != nil {
return false, fmt.Errorf("ask whether to continue with the deployment: %w", err)
}
return contd, nil
}
func (o *deployEnvOpts) validateOrAskEnvName() error {
if o.name != "" {
return o.validateEnvName()
}
name, err := o.sel.LocalEnvironment("Select an environment manifest from your workspace", "")
if err != nil {
var pathErr *os.PathError
if errors.As(err, &pathErr) || errors.Is(err, selector.ErrLocalEnvsNotFound) {
o.logManifestSuggestion("example")
}
return fmt.Errorf("select environment: %w", err)
}
o.name = name
return nil
}
func (o *deployEnvOpts) validateEnvName() error {
localEnvs, err := o.ws.ListEnvironments()
if err != nil {
o.logManifestSuggestion(o.name)
return fmt.Errorf("list environments in workspace: %w", err)
}
for _, localEnv := range localEnvs {
if o.name != localEnv {
continue
}
if _, err := o.cachedTargetEnv(); err != nil {
log.Errorf("It seems like environment %s is not added in application %s yet. Have you run %s?\n",
o.name, o.appName, color.HighlightCode("copilot env init"))
return err
}
return nil
}
o.logManifestSuggestion(o.name)
return fmt.Errorf("environment manifest for %q is not found", o.name)
}
func (o *deployEnvOpts) cachedTargetEnv() (*config.Environment, error) {
if o.targetEnv == nil {
env, err := o.store.GetEnvironment(o.appName, o.name)
if err != nil {
return nil, fmt.Errorf("get environment %s in application %s: %w", o.name, o.appName, err)
}
o.targetEnv = env
}
return o.targetEnv, nil
}
func (o *deployEnvOpts) cachedTargetApp() (*config.Application, error) {
if o.targetApp == nil {
app, err := o.store.GetApplication(o.appName)
if err != nil {
return nil, fmt.Errorf("get application %s: %w", o.appName, err)
}
o.targetApp = app
}
return o.targetApp, nil
}
func (o *deployEnvOpts) logManifestSuggestion(envName string) {
dir := filepath.Join("copilot", "environments", envName)
log.Infof(`It looks like there are no environment manifests in your workspace.
To create a new manifest for an environment %q, please run:
1. Create the directories to store the manifest file:
%s
2. Generate and write the manifest file:
%s
`,
envName,
color.HighlightCode(fmt.Sprintf("mkdir -p %s", dir)),
color.HighlightCode(fmt.Sprintf("copilot env show -n %s --manifest > %s", envName, filepath.Join(dir, "manifest.yml"))))
}
// buildEnvDeployCmd builds the command for deploying an environment given a manifest.
func buildEnvDeployCmd() *cobra.Command {
vars := deployEnvVars{}
cmd := &cobra.Command{
Use: "deploy",
Short: "Deploys an environment to an application.",
Long: "Deploys an environment to an application.",
Example: `
Deploy an environment named "test".
/code $copilot env deploy --name test`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newEnvDeployOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", envFlagDescription)
cmd.Flags().BoolVar(&vars.forceNewUpdate, forceFlag, false, forceEnvDeployFlagDescription)
cmd.Flags().BoolVar(&vars.disableRollback, noRollbackFlag, false, noRollbackFlagDescription)
cmd.Flags().BoolVar(&vars.showDiff, diffFlag, false, diffFlagDescription)
cmd.Flags().BoolVar(&vars.skipDiffPrompt, diffAutoApproveFlag, false, diffAutoApproveFlagDescription)
cmd.Flags().BoolVar(&vars.allowEnvDowngrade, allowDowngradeFlag, false, allowDowngradeFlagDescription)
return cmd
}
| 386 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type deployEnvAskMocks struct {
ws *mocks.MockwsEnvironmentReader
sel *mocks.MockwsEnvironmentSelector
store *mocks.Mockstore
}
func TestDeployEnvOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inAppName string
inName string
setUpMocks func(m *deployEnvAskMocks)
wantedEnvName string
wantedError error
}{
"fail to retrieve app from store when validating app": {
inAppName: "mockApp",
inName: "mockEnv",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Return(nil, errors.New("some error"))
},
wantedError: errors.New("get application mockApp: some error"),
},
"error if no app in workspace": {
inName: "mockEnv",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Times(0)
},
wantedError: errNoAppInWorkspace,
},
"fail to list environments in local workspace": {
inAppName: "mockApp",
inName: "mockEnv",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Return(&config.Application{}, nil)
m.ws.EXPECT().ListEnvironments().Return(nil, errors.New("some error"))
},
wantedError: errors.New("list environments in workspace: some error"),
},
"fail to find local environment manifest workspace": {
inAppName: "mockApp",
inName: "mockEnv",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Return(&config.Application{}, nil)
m.ws.EXPECT().ListEnvironments().Return([]string{"otherEnv"}, nil)
},
wantedError: errors.New(`environment manifest for "mockEnv" is not found`),
},
"fail to retrieve env from store when validating env": {
inAppName: "mockApp",
inName: "mockEnv",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Return(&config.Application{}, nil)
m.ws.EXPECT().ListEnvironments().Return([]string{"mockEnv"}, nil)
m.store.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(nil, errors.New("some error"))
},
wantedError: errors.New("get environment mockEnv in application mockApp: some error"),
},
"fail to ask for an env from workspace": {
inAppName: "mockApp",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Return(&config.Application{}, nil)
m.store.EXPECT().GetEnvironment("mockApp", "mockEnv").AnyTimes()
m.sel.EXPECT().LocalEnvironment(gomock.Any(), gomock.Any()).Return("", errors.New("some error"))
},
wantedError: errors.New("select environment: some error"),
},
"validate env instead of asking if it is passed in as a flag": {
inAppName: "mockApp",
inName: "mockEnv",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Return(&config.Application{}, nil)
m.ws.EXPECT().ListEnvironments().Return([]string{"mockEnv"}, nil)
m.store.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(&config.Environment{}, nil)
m.sel.EXPECT().LocalEnvironment(gomock.Any(), gomock.Any()).Times(0)
},
wantedEnvName: "mockEnv",
},
"ask for env": {
inAppName: "mockApp",
setUpMocks: func(m *deployEnvAskMocks) {
m.store.EXPECT().GetApplication("mockApp").Return(&config.Application{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.ws.EXPECT().ListEnvironments().Times(0)
m.sel.EXPECT().LocalEnvironment(gomock.Any(), gomock.Any()).Return("mockEnv", nil)
},
wantedEnvName: "mockEnv",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployEnvAskMocks{
ws: mocks.NewMockwsEnvironmentReader(ctrl),
sel: mocks.NewMockwsEnvironmentSelector(ctrl),
store: mocks.NewMockstore(ctrl),
}
tc.setUpMocks(m)
opts := deployEnvOpts{
deployEnvVars: deployEnvVars{
appName: tc.inAppName,
name: tc.inName,
},
ws: m.ws,
sel: m.sel,
store: m.store,
}
gotErr := opts.Ask()
if tc.wantedError != nil {
require.EqualError(t, gotErr, tc.wantedError.Error())
} else {
require.NoError(t, gotErr)
require.Equal(t, opts.name, tc.wantedEnvName)
}
})
}
}
type deployEnvExecuteMocks struct {
ws *mocks.MockwsEnvironmentReader
deployer *mocks.MockenvDeployer
identity *mocks.MockidentityService
interpolator *mocks.Mockinterpolator
prompter *mocks.Mockprompter
envVersionGetter *mocks.MockversionGetter
}
func TestDeployEnvOpts_Execute(t *testing.T) {
const (
mockEnvVersion = "v0.0.0"
mockCurrVersion = "v1.29.0"
mockFutureEnvVersion = "v2.0.0"
)
mockError := errors.New("some error")
testCases := map[string]struct {
inShowDiff bool
inSkipDiffPrompt bool
inAllowDowngrade bool
unmarshalManifest func(in []byte) (*manifest.Environment, error)
setUpMocks func(m *deployEnvExecuteMocks)
wantedDiff string
wantedErr error
}{
"fail to get env version": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return("", mockError)
},
wantedErr: errors.New(`get template version of environment mockEnv: some error`),
},
"error for downgrading": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockFutureEnvVersion, nil)
},
wantedErr: errors.New(`cannot downgrade environment "mockEnv" (currently in version v2.0.0) to version v1.29.0`),
},
"fail to read manifest": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return(nil, mockError)
},
wantedErr: errors.New(`read manifest for environment "mockEnv": some error`),
},
"fail to interpolate manifest": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: errors.New(`interpolate environment variables for "mockEnv" manifest: some error`),
},
"fail to unmarshal manifest": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("failing manifest format", nil)
},
wantedErr: errors.New(`unmarshal environment manifest for "mockEnv"`),
},
"fail to get caller identity": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{}, errors.New("some error"))
},
wantedErr: errors.New("get identity: some error"),
},
"fail to verify env": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\ncdn: true\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\ncdn: true\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(errors.New("mock error"))
},
wantedErr: errors.New("mock error"),
},
"fail to upload artifacts": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(nil, errors.New("some error"))
},
wantedErr: errors.New("upload artifacts for environment mockEnv: some error"),
},
"fail to generate the template to show diff": {
inShowDiff: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(nil, errors.New("some error"))
},
wantedErr: fmt.Errorf(`generate the template for environment "mockEnv": some error`),
},
"failed to generate the diff": {
inShowDiff: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.deployer.EXPECT().DeployDiff(gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: errors.New(`generate diff for environment "mockEnv": some error`),
},
"write 'no changes' if there is no diff": {
inShowDiff: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.deployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.prompter.EXPECT().Confirm(gomock.Eq(continueDeploymentPrompt), gomock.Any(), gomock.Any()).Return(false, nil)
},
wantedDiff: "No changes.\n",
},
"write the correct diff": {
inShowDiff: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.deployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.prompter.EXPECT().Confirm(gomock.Eq(continueDeploymentPrompt), gomock.Any(), gomock.Any()).Return(false, nil)
},
wantedDiff: "mock diff",
},
"error if fail to ask whether to continue the deployment": {
inShowDiff: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.deployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.prompter.EXPECT().Confirm(gomock.Eq(continueDeploymentPrompt), gomock.Any(), gomock.Any()).Return(false, errors.New("some error"))
},
wantedErr: errors.New("ask whether to continue with the deployment: some error"),
},
"do not deploy if asked to": {
inShowDiff: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.deployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.prompter.EXPECT().Confirm(gomock.Eq(continueDeploymentPrompt), gomock.Any(), gomock.Any()).Return(false, nil)
m.deployer.EXPECT().DeployEnvironment(gomock.Any()).Times(0)
},
},
"deploy if asked to": {
inShowDiff: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.deployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.prompter.EXPECT().Confirm(gomock.Eq(continueDeploymentPrompt), gomock.Any(), gomock.Any()).Return(true, nil)
m.deployer.EXPECT().DeployEnvironment(gomock.Any()).Times(1)
},
},
"skip prompt and deploy immediately after diff; also skip version check when downgrade is allowed": {
inShowDiff: true,
inSkipDiffPrompt: true,
inAllowDowngrade: true,
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Times(0)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.deployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.prompter.EXPECT().Confirm(gomock.Eq(continueDeploymentPrompt), gomock.Any(), gomock.Any()).Times(0)
m.deployer.EXPECT().DeployEnvironment(gomock.Any()).Times(1)
},
},
"fail to deploy the environment": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(mockEnvVersion, nil)
m.ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate(gomock.Any()).Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{}, nil)
m.deployer.EXPECT().DeployEnvironment(gomock.Any()).DoAndReturn(func(_ *deploy.DeployEnvironmentInput) error {
return errors.New("some error")
})
},
wantedErr: errors.New("deploy environment mockEnv: some error"),
},
"success": {
setUpMocks: func(m *deployEnvExecuteMocks) {
m.envVersionGetter.EXPECT().Version().Return(version.EnvTemplateBootstrap, nil)
m.ws.EXPECT().ReadEnvironmentManifest("mockEnv").Return([]byte("name: mockEnv\ntype: Environment\n"), nil)
m.interpolator.EXPECT().Interpolate("name: mockEnv\ntype: Environment\n").Return("name: mockEnv\ntype: Environment\n", nil)
m.identity.EXPECT().Get().Return(identity.Caller{
RootUserARN: "mockRootUserARN",
}, nil)
m.deployer.EXPECT().Validate(gomock.Any()).Return(nil)
m.deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{
AddonsURL: "mockAddonsURL",
CustomResourceURLs: map[string]string{
"mockResource": "mockURL",
},
}, nil)
m.deployer.EXPECT().DeployEnvironment(gomock.Any()).DoAndReturn(func(in *deploy.DeployEnvironmentInput) error {
require.Equal(t, in.RootUserARN, "mockRootUserARN")
require.Equal(t, in.AddonsURL, "mockAddonsURL")
require.Equal(t, in.CustomResourcesURLs, map[string]string{
"mockResource": "mockURL",
})
require.Equal(t, in.Manifest, &manifest.Environment{
Workload: manifest.Workload{
Name: aws.String("mockEnv"),
Type: aws.String("Environment"),
},
})
return nil
})
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployEnvExecuteMocks{
ws: mocks.NewMockwsEnvironmentReader(ctrl),
deployer: mocks.NewMockenvDeployer(ctrl),
identity: mocks.NewMockidentityService(ctrl),
interpolator: mocks.NewMockinterpolator(ctrl),
prompter: mocks.NewMockprompter(ctrl),
envVersionGetter: mocks.NewMockversionGetter(ctrl),
}
tc.setUpMocks(m)
opts := deployEnvOpts{
deployEnvVars: deployEnvVars{
name: "mockEnv",
showDiff: tc.inShowDiff,
skipDiffPrompt: tc.inSkipDiffPrompt,
allowEnvDowngrade: tc.inAllowDowngrade,
},
ws: m.ws,
identity: m.identity,
newEnvDeployer: func() (envDeployer, error) {
return m.deployer, nil
},
newEnvVersionGetter: func(appName, envName string) (versionGetter, error) {
return m.envVersionGetter, nil
},
templateVersion: mockCurrVersion,
newInterpolator: func(s string, s2 string) interpolator {
return m.interpolator
},
prompt: m.prompter,
targetApp: &config.Application{
Name: "mockApp",
Domain: "mockDomain",
},
targetEnv: &config.Environment{
Name: "mockEnv",
},
}
err := opts.Execute()
if tc.wantedErr != nil {
require.Contains(t, err.Error(), tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 469 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"net"
"os"
"path/filepath"
"strings"
"github.com/aws/copilot-cli/internal/pkg/aws/profile"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/dustin/go-humanize/english"
"github.com/spf13/afero"
"golang.org/x/mod/semver"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/ec2"
"github.com/aws/copilot-cli/internal/pkg/aws/iam"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
deploycfn "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
)
const (
envInitNamePrompt = "What is your environment's name?"
envInitNameHelpPrompt = "A unique identifier for an environment (e.g. dev, test, prod)."
envInitDefaultEnvConfirmPrompt = `Would you like to use the default configuration for a new environment?
- A new VPC with 2 AZs, 2 public subnets and 2 private subnets
- A new ECS Cluster
- New IAM Roles to manage services and jobs in your environment
`
envInitVPCSelectPrompt = "Which VPC would you like to use?"
envInitPublicSubnetsSelectPrompt = "Which public subnets would you like to use?\nYou may choose to press 'Enter' to skip this step if the services and/or jobs you'll deploy to this environment are not internet-facing."
envInitPrivateSubnetsSelectPrompt = "Which private subnets would you like to use?"
envInitVPCCIDRPrompt = "What VPC CIDR would you like to use?"
envInitVPCCIDRPromptHelp = "CIDR used for your VPC. For example: 10.1.0.0/16"
envInitAdjustAZPrompt = "Which availability zones would you like to use?"
envInitAdjustAZPromptHelp = "Availability zone names that span your resources. For example: us-east-1a,us-east1b,us-east-1c"
envInitPublicCIDRPrompt = "What CIDR would you like to use for your public subnets?"
envInitPublicCIDRPromptHelp = "CIDRs used for your public subnets. For example: 10.1.0.0/24,10.1.1.0/24"
envInitPrivateCIDRPrompt = "What CIDR would you like to use for your private subnets?"
envInitPrivateCIDRPromptHelp = "CIDRs used for your private subnets. For example: 10.1.2.0/24,10.1.3.0/24"
fmtEnvInitCredsPrompt = "Which credentials would you like to use to create %s?"
envInitCredsHelpPrompt = `The credentials are used to create your environment in an AWS account and region.
To learn more:
https://aws.github.io/copilot-cli/docs/credentials/#environment-credentials`
envInitRegionPrompt = "Which region?"
envInitDefaultRegionOption = "us-west-2"
fmtDNSDelegationStart = "Sharing DNS permissions for this application to account %s."
fmtDNSDelegationFailed = "Failed to grant DNS permissions to account %s.\n\n"
fmtDNSDelegationComplete = "Shared DNS permissions for this application to account %s.\n\n"
)
var (
envInitDefaultConfigSelectOption = "Yes, use default."
envInitAdjustEnvResourcesSelectOption = "Yes, but I'd like configure the default resources (CIDR ranges, AZs)."
envInitImportEnvResourcesSelectOption = "No, I'd like to import existing resources (VPC, subnets)."
envInitCustomizedEnvTypes = []string{envInitDefaultConfigSelectOption, envInitAdjustEnvResourcesSelectOption, envInitImportEnvResourcesSelectOption}
)
type importVPCVars struct {
ID string
PublicSubnetIDs []string
PrivateSubnetIDs []string
}
func (v importVPCVars) isSet() bool {
if v.ID != "" {
return true
}
return len(v.PublicSubnetIDs) > 0 || len(v.PrivateSubnetIDs) > 0
}
type adjustVPCVars struct {
CIDR net.IPNet
AZs []string
PublicSubnetCIDRs []string
PrivateSubnetCIDRs []string
}
func (v adjustVPCVars) isSet() bool {
if v.CIDR.String() != emptyIPNet.String() {
return true
}
for _, arr := range [][]string{v.AZs, v.PublicSubnetCIDRs, v.PrivateSubnetCIDRs} {
if len(arr) != 0 {
return true
}
}
return false
}
type tempCredsVars struct {
AccessKeyID string
SecretAccessKey string
SessionToken string
}
func (v tempCredsVars) isSet() bool {
return v.AccessKeyID != "" && v.SecretAccessKey != ""
}
type telemetryVars struct {
EnableContainerInsights bool
}
func (v telemetryVars) toConfig() *config.Telemetry {
return &config.Telemetry{
EnableContainerInsights: v.EnableContainerInsights,
}
}
type initEnvVars struct {
appName string
name string // Name for the environment.
profile string // The named profile to use for credential retrieval. Mutually exclusive with tempCreds.
isProduction bool // True means retain resources even after deletion.
defaultConfig bool // True means using default environment configuration.
allowAppDowngrade bool
importVPC importVPCVars // Existing VPC resources to use instead of creating new ones.
adjustVPC adjustVPCVars // Configure parameters for VPC resources generated while initializing an environment.
telemetry telemetryVars // Configure observability and monitoring settings.
importCerts []string // Additional existing ACM certificates to use.
internalALBSubnets []string // Subnets to be used for internal ALB placement.
allowVPCIngress bool // True means the env stack will create ingress to the internal ALB from ports 80/443.
tempCreds tempCredsVars // Temporary credentials to initialize the environment. Mutually exclusive with the profile.
region string // The region to create the environment in.
}
type initEnvOpts struct {
initEnvVars
// Interfaces to interact with dependencies.
sessProvider sessionProvider
store store
envDeployer deployer
appDeployer deployer
identity identityService
envIdentity identityService
ec2Client ec2Client
appVersionGetter versionGetter
iam roleManager
cfn stackExistChecker
prog progress
prompt prompter
selVPC ec2Selector
selCreds func() (credsSelector, error)
selApp appSelector
appCFN appResourcesGetter
manifestWriter environmentManifestWriter
sess *session.Session // Session pointing to environment's AWS account and region.
// Cached variables.
wsAppName string
mftDisplayedPath string
// Overridden in tests.
templateVersion string
}
func newInitEnvOpts(vars initEnvVars) (*initEnvOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("env init"))
defaultSession, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
return &initEnvOpts{
initEnvVars: vars,
sessProvider: sessProvider,
store: store,
appDeployer: deploycfn.New(defaultSession, deploycfn.WithProgressTracker(os.Stderr)),
identity: identity.New(defaultSession),
prog: termprogress.NewSpinner(log.DiagnosticWriter),
prompt: prompter,
selCreds: func() (credsSelector, error) {
cfg, err := profile.NewConfig()
if err != nil {
return nil, fmt.Errorf("read named profiles: %w", err)
}
return &selector.CredsSelect{
Session: sessProvider,
Profile: cfg,
Prompt: prompt.New(),
}, nil
},
selApp: selector.NewAppEnvSelector(prompt.New(), store),
appCFN: deploycfn.New(defaultSession, deploycfn.WithProgressTracker(os.Stderr)),
manifestWriter: ws,
wsAppName: tryReadingAppName(),
templateVersion: version.LatestTemplateVersion(),
}, nil
}
// Validate returns an error if the values passed by flags are invalid.
func (o *initEnvOpts) Validate() error {
if err := validateWorkspaceApp(o.wsAppName, o.appName, o.store); err != nil {
return err
}
o.appName = o.wsAppName
if o.name != "" {
if err := validateEnvironmentName(o.name); err != nil {
return err
}
if err := o.validateDuplicateEnv(); err != nil {
return err
}
}
if err := o.validateCustomizedResources(); err != nil {
return err
}
return o.validateCredentials()
}
// Ask asks for fields that are required but not passed in.
func (o *initEnvOpts) Ask() error {
if err := o.askEnvName(); err != nil {
return err
}
if err := o.askEnvSession(); err != nil {
return err
}
if err := o.askEnvRegion(); err != nil {
return err
}
return o.askCustomizedResources()
}
// Execute deploys a new environment with CloudFormation and adds it to SSM.
func (o *initEnvOpts) Execute() error {
if err := o.initRuntimeClients(); err != nil {
return err
}
if !o.allowAppDowngrade {
if err := validateAppVersion(o.appVersionGetter, o.appName, o.templateVersion); err != nil {
return err
}
}
app, err := o.store.GetApplication(o.appName)
if err != nil {
// Ensure the app actually exists before we write the manifest.
return err
}
envCaller, err := o.envIdentity.Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
// 1. Write environment manifest.
path, err := o.writeManifest()
if err != nil {
return err
}
o.mftDisplayedPath = path
// 2. Perform DNS delegation from app to env.
if app.Domain != "" {
if err := o.delegateDNSFromApp(app, envCaller.Account); err != nil {
return fmt.Errorf("granting DNS permissions: %w", err)
}
}
// 3. Attempt to create the service linked role if it doesn't exist.
// If the call fails because the role already exists, nothing to do.
// If the call fails because the user doesn't have permissions, then the role must be created outside of Copilot.
_ = o.iam.CreateECSServiceLinkedRole()
// 4. Add the stack set instance to the app stackset.
if err := o.addToStackset(&deploycfn.AddEnvToAppOpts{
App: app,
EnvName: o.name,
EnvRegion: aws.StringValue(o.sess.Config.Region),
EnvAccountID: envCaller.Account,
}); err != nil {
return err
}
// 5. Start creating the CloudFormation stack for the environment.
if err := o.deployEnv(app); err != nil {
return err
}
// 6. Store the environment in SSM with information about the deployed bootstrap roles.
env, err := o.envDeployer.GetEnvironment(o.appName, o.name)
if err != nil {
return fmt.Errorf("get environment struct for %s: %w", o.name, err)
}
if err := o.store.CreateEnvironment(env); err != nil {
return fmt.Errorf("store environment: %w", err)
}
log.Successf("Provisioned bootstrap resources for environment %s in region %s under application %s.\n",
color.HighlightUserInput(env.Name), color.Emphasize(env.Region), color.HighlightUserInput(env.App))
return nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *initEnvOpts) RecommendActions() error {
logRecommendedActions([]string{
fmt.Sprintf("Update your manifest %s to change the defaults.", color.HighlightResource(o.mftDisplayedPath)),
fmt.Sprintf("Run %s to deploy your environment.",
color.HighlightCode(fmt.Sprintf("copilot env deploy --name %s", o.name))),
})
return nil
}
func (o *initEnvOpts) initRuntimeClients() error {
// Initialize environment clients if not set.
if o.envIdentity == nil {
o.envIdentity = identity.New(o.sess)
}
if o.envDeployer == nil {
o.envDeployer = deploycfn.New(o.sess, deploycfn.WithProgressTracker(os.Stderr))
}
if o.cfn == nil {
o.cfn = cloudformation.New(o.sess)
}
if o.iam == nil {
o.iam = iam.New(o.sess)
}
if o.appVersionGetter == nil {
appDescriber, err := describe.NewAppDescriber(o.appName)
if err != nil {
return err
}
o.appVersionGetter = appDescriber
}
return nil
}
func (o *initEnvOpts) validateCustomizedResources() error {
if o.importVPC.isSet() && o.adjustVPC.isSet() {
return errors.New("cannot specify both import vpc flags and configure vpc flags")
}
if (o.importVPC.isSet() || o.adjustVPC.isSet()) && o.defaultConfig {
return fmt.Errorf("cannot import or configure vpc if --%s is set", defaultConfigFlag)
}
if o.internalALBSubnets != nil && (o.adjustVPC.isSet() || o.defaultConfig) {
log.Error(`To specify internal ALB subnet placement, you must import existing resources, including subnets.
For default config without subnet placement specification, Copilot will place the internal ALB in the generated private subnets.`)
return fmt.Errorf("subnets '%s' specified for internal ALB placement, but those subnets are not imported", strings.Join(o.internalALBSubnets, ", "))
}
if o.importVPC.isSet() {
// Allow passing in VPC without subnets, but error out early for too few subnets-- we won't prompt the user to select more of one type if they pass in any.
if len(o.importVPC.PublicSubnetIDs) == 1 {
return errors.New("at least two public subnets must be imported to enable Load Balancing")
}
if len(o.importVPC.PrivateSubnetIDs) == 1 {
return fmt.Errorf("at least two private subnets must be imported")
}
if err := o.validateInternalALBSubnets(); err != nil {
return err
}
}
if o.adjustVPC.isSet() {
if len(o.adjustVPC.AZs) == 1 {
return errors.New("at least two availability zones must be provided to enable Load Balancing")
}
}
return nil
}
func (o *initEnvOpts) askEnvName() error {
if o.name != "" {
return nil
}
envName, err := o.prompt.Get(envInitNamePrompt, envInitNameHelpPrompt, validateEnvironmentName, prompt.WithFinalMessage("Environment name:"))
if err != nil {
return fmt.Errorf("get environment name: %w", err)
}
o.name = envName
return o.validateDuplicateEnv()
}
func (o *initEnvOpts) askEnvSession() error {
if o.profile != "" {
sess, err := o.sessProvider.FromProfile(o.profile)
if err != nil {
return fmt.Errorf("create session from profile %s: %w", o.profile, err)
}
o.sess = sess
return nil
}
if o.tempCreds.isSet() {
sess, err := o.sessProvider.FromStaticCreds(o.tempCreds.AccessKeyID, o.tempCreds.SecretAccessKey, o.tempCreds.SessionToken)
if err != nil {
return err
}
o.sess = sess
return nil
}
selCreds, err := o.selCreds()
if err != nil {
return err
}
sess, err := selCreds.Creds(fmt.Sprintf(fmtEnvInitCredsPrompt, color.HighlightUserInput(o.name)), envInitCredsHelpPrompt)
if err != nil {
return fmt.Errorf("select creds: %w", err)
}
o.sess = sess
return nil
}
func (o *initEnvOpts) askEnvRegion() error {
region := aws.StringValue(o.sess.Config.Region)
if o.region != "" {
region = o.region
}
if region == "" {
v, err := o.prompt.Get(envInitRegionPrompt, "", nil, prompt.WithDefaultInput(envInitDefaultRegionOption), prompt.WithFinalMessage("Region:"))
if err != nil {
return fmt.Errorf("get environment region: %w", err)
}
region = v
}
o.sess.Config.Region = aws.String(region)
return nil
}
func (o *initEnvOpts) askCustomizedResources() error {
if o.defaultConfig {
return nil
}
if o.importVPC.isSet() {
return o.askImportResources()
}
if o.adjustVPC.isSet() {
return o.askAdjustResources()
}
if o.internalALBSubnets != nil {
log.Infoln("Because you have designated subnets on which to place an internal ALB, you must import VPC resources.")
return o.askImportResources()
}
adjustOrImport, err := o.prompt.SelectOne(
envInitDefaultEnvConfirmPrompt, "",
envInitCustomizedEnvTypes,
prompt.WithFinalMessage("Default environment configuration?"))
if err != nil {
return fmt.Errorf("select adjusting or importing resources: %w", err)
}
switch adjustOrImport {
case envInitImportEnvResourcesSelectOption:
return o.askImportResources()
case envInitAdjustEnvResourcesSelectOption:
return o.askAdjustResources()
case envInitDefaultConfigSelectOption:
return nil
}
return nil
}
func (o *initEnvOpts) askImportResources() error {
if o.selVPC == nil {
o.selVPC = selector.NewEC2Select(o.prompt, ec2.New(o.sess))
}
if o.importVPC.ID == "" {
vpcID, err := o.selVPC.VPC(envInitVPCSelectPrompt, "")
if err != nil {
if err == selector.ErrVPCNotFound {
log.Errorf(`No existing VPCs were found. You can either:
- Create a new VPC first and then import it.
- Use the default Copilot environment configuration.
`)
}
return fmt.Errorf("select VPC: %w", err)
}
o.importVPC.ID = vpcID
}
if o.ec2Client == nil {
o.ec2Client = ec2.New(o.sess)
}
dnsSupport, err := o.ec2Client.HasDNSSupport(o.importVPC.ID)
if err != nil {
return fmt.Errorf("check if VPC %s has DNS support enabled: %w", o.importVPC.ID, err)
}
if !dnsSupport {
log.Errorln(`Looks like you're creating an environment using a VPC with DNS support *disabled*.
Copilot cannot create services or jobs in VPCs without DNS support. We recommend enabling this property.
To learn more about the issue:
https://aws.amazon.com/premiumsupport/knowledge-center/ecs-pull-container-api-error-ecr/`)
return fmt.Errorf("VPC %s has no DNS support enabled", o.importVPC.ID)
}
if o.importVPC.PublicSubnetIDs == nil {
publicSubnets, err := o.selVPC.Subnets(selector.SubnetsInput{
Msg: envInitPublicSubnetsSelectPrompt,
Help: "",
VPCID: o.importVPC.ID,
IsPublic: true,
})
if err != nil {
if errors.Is(err, selector.ErrSubnetsNotFound) {
log.Warningf(`No existing public subnets were found in VPC %s.
`, o.importVPC.ID)
} else {
return fmt.Errorf("select public subnets: %w", err)
}
}
if len(publicSubnets) == 1 {
return errors.New("select public subnets: at least two public subnets must be selected to enable Load Balancing")
}
if len(publicSubnets) == 0 {
log.Warningf(`If you proceed without public subnets, you will not be able to deploy
Load Balanced Web Services in this environment, and will need to specify 'private'
network placement in your workload manifest(s). See the manifest documentation
specific to your workload type(s) (https://aws.github.io/copilot-cli/docs/manifest/overview/).
`)
}
o.importVPC.PublicSubnetIDs = publicSubnets
}
if o.importVPC.PrivateSubnetIDs == nil {
privateSubnets, err := o.selVPC.Subnets(selector.SubnetsInput{
Msg: envInitPrivateSubnetsSelectPrompt,
Help: "",
VPCID: o.importVPC.ID,
IsPublic: false,
})
if err != nil {
if errors.Is(err, selector.ErrSubnetsNotFound) {
log.Warningf(`No existing private subnets were found in VPC %s.
`, o.importVPC.ID)
} else {
return fmt.Errorf("select private subnets: %w", err)
}
}
if len(privateSubnets) == 1 {
return errors.New("select private subnets: at least two private subnets must be selected")
}
if len(privateSubnets) == 0 {
log.Warningf(`If you proceed without private subnets, you will not
be able to add them after this environment is created.
`)
}
o.importVPC.PrivateSubnetIDs = privateSubnets
}
if len(o.importVPC.PublicSubnetIDs)+len(o.importVPC.PrivateSubnetIDs) == 0 {
return errors.New("VPC must have subnets in order to proceed with environment creation")
}
return o.validateInternalALBSubnets()
}
func (o *initEnvOpts) askAdjustResources() error {
if o.adjustVPC.CIDR.String() == emptyIPNet.String() {
vpcCIDRString, err := o.prompt.Get(envInitVPCCIDRPrompt, envInitVPCCIDRPromptHelp, validateCIDR,
prompt.WithDefaultInput(stack.DefaultVPCCIDR), prompt.WithFinalMessage("VPC CIDR:"))
if err != nil {
return fmt.Errorf("get VPC CIDR: %w", err)
}
_, vpcCIDR, err := net.ParseCIDR(vpcCIDRString)
if err != nil {
return fmt.Errorf("parse VPC CIDR: %w", err)
}
o.adjustVPC.CIDR = *vpcCIDR
}
azs, err := o.askAZs()
if err != nil {
return err
}
o.adjustVPC.AZs = azs
if o.adjustVPC.PublicSubnetCIDRs == nil {
publicCIDR, err := o.prompt.Get(
envInitPublicCIDRPrompt, envInitPublicCIDRPromptHelp,
validatePublicSubnetsCIDR(len(o.adjustVPC.AZs)),
prompt.WithDefaultInput(strings.Join(stack.DefaultPublicSubnetCIDRs, ",")), prompt.WithFinalMessage("Public subnets CIDR:"))
if err != nil {
return fmt.Errorf("get public subnet CIDRs: %w", err)
}
o.adjustVPC.PublicSubnetCIDRs = strings.Split(publicCIDR, ",")
}
if o.adjustVPC.PrivateSubnetCIDRs == nil {
privateCIDR, err := o.prompt.Get(
envInitPrivateCIDRPrompt, envInitPrivateCIDRPromptHelp,
validatePrivateSubnetsCIDR(len(o.adjustVPC.AZs)),
prompt.WithDefaultInput(strings.Join(stack.DefaultPrivateSubnetCIDRs, ",")), prompt.WithFinalMessage("Private subnets CIDR:"))
if err != nil {
return fmt.Errorf("get private subnet CIDRs: %w", err)
}
o.adjustVPC.PrivateSubnetCIDRs = strings.Split(privateCIDR, ",")
}
return nil
}
func (o *initEnvOpts) askAZs() ([]string, error) {
if o.adjustVPC.AZs != nil {
return o.adjustVPC.AZs, nil
}
if o.ec2Client == nil {
o.ec2Client = ec2.New(o.sess)
}
azs, err := o.ec2Client.ListAZs()
if err != nil {
return nil, fmt.Errorf("list availability zones for region %s: %v", aws.StringValue(o.sess.Config.Region), err)
}
var options []string
for _, az := range azs {
options = append(options, az.Name)
}
const minAZs = 2
if len(options) < minAZs {
return nil, fmt.Errorf("requires at least %d availability zones (%s) in region %s", minAZs, strings.Join(options, ", "), aws.StringValue(o.sess.Config.Region))
}
defaultOptions := make([]string, minAZs)
for i := 0; i < minAZs; i += 1 {
defaultOptions[i] = azs[i].Name
}
selected, err := o.prompt.MultiSelect(
envInitAdjustAZPrompt, envInitAdjustAZPromptHelp, options,
prompt.RequireMinItems(minAZs),
prompt.WithDefaultSelections(defaultOptions), prompt.WithFinalMessage("AZs:"))
if err != nil {
return nil, fmt.Errorf("select availability zones: %v", err)
}
return selected, nil
}
func (o *initEnvOpts) validateDuplicateEnv() error {
_, err := o.store.GetEnvironment(o.appName, o.name)
if err == nil {
dir := filepath.Join("copilot", "environments", o.name)
log.Infof(`It seems like you are trying to init an environment that already exists.
To generate a manifest for the environment:
1. %s
2. %s
Alternatively, to recreate the environment:
1. %s
2. And then %s
`,
color.HighlightCode(fmt.Sprintf("mkdir -p %s", dir)),
color.HighlightCode(fmt.Sprintf("copilot env show -n %s --manifest > %s", o.name, filepath.Join(dir, "manifest.yml"))),
color.HighlightCode(fmt.Sprintf("copilot env delete --name %s", o.name)),
color.HighlightCode(fmt.Sprintf("copilot env init --name %s", o.name)))
return fmt.Errorf("environment %s already exists", color.HighlightUserInput(o.name))
}
var errNoSuchEnvironment *config.ErrNoSuchEnvironment
if !errors.As(err, &errNoSuchEnvironment) {
return fmt.Errorf("validate if environment exists: %w", err)
}
return nil
}
func (o *initEnvOpts) importVPCConfig() *config.ImportVPC {
if o.defaultConfig || !o.importVPC.isSet() {
return nil
}
return &config.ImportVPC{
ID: o.importVPC.ID,
PrivateSubnetIDs: o.importVPC.PrivateSubnetIDs,
PublicSubnetIDs: o.importVPC.PublicSubnetIDs,
}
}
func (o *initEnvOpts) adjustVPCConfig() *config.AdjustVPC {
if o.defaultConfig || !o.adjustVPC.isSet() {
return nil
}
return &config.AdjustVPC{
CIDR: o.adjustVPC.CIDR.String(),
AZs: o.adjustVPC.AZs,
PrivateSubnetCIDRs: o.adjustVPC.PrivateSubnetCIDRs,
PublicSubnetCIDRs: o.adjustVPC.PublicSubnetCIDRs,
}
}
func (o *initEnvOpts) deployEnv(app *config.Application) error {
envRegion := aws.StringValue(o.sess.Config.Region)
resources, err := o.appCFN.GetAppResourcesByRegion(app, envRegion)
if err != nil {
return fmt.Errorf("get app resources: %w", err)
}
if resources.S3Bucket == "" {
log.Errorf("Cannot find the S3 artifact bucket in %s region created by app %s. The S3 bucket is necessary for many future operations. For example, when you need addons to your services.", envRegion, app.Name)
return fmt.Errorf("cannot find the S3 artifact bucket in %s region", envRegion)
}
partition, err := partitions.Region(envRegion).Partition()
if err != nil {
return err
}
artifactBucketARN := s3.FormatARN(partition.ID(), resources.S3Bucket)
caller, err := o.identity.Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
deployEnvInput := &stack.EnvConfig{
Name: o.name,
App: deploy.AppInformation{
Name: o.appName,
Domain: app.Domain,
AccountPrincipalARN: caller.RootUserARN,
},
AdditionalTags: app.Tags,
ArtifactBucketARN: artifactBucketARN,
ArtifactBucketKeyARN: resources.KMSKeyARN,
PermissionsBoundary: app.PermissionsBoundary,
}
if err := o.cleanUpDanglingRoles(o.appName, o.name); err != nil {
return err
}
if err := o.envDeployer.CreateAndRenderEnvironment(stack.NewBootstrapEnvStackConfig(deployEnvInput), artifactBucketARN); err != nil {
var existsErr *cloudformation.ErrStackAlreadyExists
if errors.As(err, &existsErr) {
// Do nothing if the stack already exists.
return nil
}
// The stack failed to create due to an unexpect reason.
// Delete the retained roles created part of the stack.
o.tryDeletingEnvRoles(o.appName, o.name)
return err
}
return nil
}
func (o *initEnvOpts) addToStackset(opts *deploycfn.AddEnvToAppOpts) error {
if err := o.appDeployer.AddEnvToApp(opts); err != nil {
return fmt.Errorf("add env %s to application %s: %w", opts.EnvName, opts.App.Name, err)
}
return nil
}
func (o *initEnvOpts) delegateDNSFromApp(app *config.Application, accountID string) error {
// By default, our DNS Delegation permits same account delegation.
if accountID == app.AccountID {
return nil
}
o.prog.Start(fmt.Sprintf(fmtDNSDelegationStart, color.HighlightUserInput(accountID)))
if err := o.appDeployer.DelegateDNSPermissions(app, accountID); err != nil {
o.prog.Stop(log.Serrorf(fmtDNSDelegationFailed, color.HighlightUserInput(accountID)))
return err
}
o.prog.Stop(log.Ssuccessf(fmtDNSDelegationComplete, color.HighlightUserInput(accountID)))
return nil
}
func (o *initEnvOpts) validateCredentials() error {
if o.profile != "" && o.tempCreds.AccessKeyID != "" {
return fmt.Errorf("cannot specify both --%s and --%s", profileFlag, accessKeyIDFlag)
}
if o.profile != "" && o.tempCreds.SecretAccessKey != "" {
return fmt.Errorf("cannot specify both --%s and --%s", profileFlag, secretAccessKeyFlag)
}
if o.profile != "" && o.tempCreds.SessionToken != "" {
return fmt.Errorf("cannot specify both --%s and --%s", profileFlag, sessionTokenFlag)
}
return nil
}
func (o *initEnvOpts) validateInternalALBSubnets() error {
if len(o.internalALBSubnets) == 0 {
return nil
}
isImported := make(map[string]bool)
for _, placementSubnet := range o.internalALBSubnets {
for _, subnet := range append(o.importVPC.PrivateSubnetIDs, o.importVPC.PublicSubnetIDs...) {
if placementSubnet == subnet {
isImported[placementSubnet] = true
}
}
}
if len(isImported) != len(o.internalALBSubnets) {
return fmt.Errorf("%s '%s' %s designated for ALB placement, but %s imported",
english.PluralWord(len(o.internalALBSubnets), "subnet", "subnets"),
strings.Join(o.internalALBSubnets, ", "),
english.PluralWord(len(o.internalALBSubnets), "was", "were"),
english.PluralWord(len(o.internalALBSubnets), "it was not", "they were not all"))
}
return nil
}
// cleanUpDanglingRoles deletes any IAM roles created for the same app and env that were left over from a previous
// environment creation.
func (o *initEnvOpts) cleanUpDanglingRoles(app, env string) error {
exists, err := o.cfn.Exists(stack.NameForEnv(app, env))
if err != nil {
return fmt.Errorf("check if stack %s exists: %w", stack.NameForEnv(app, env), err)
}
if exists {
return nil
}
// There is no environment stack. Either the customer ran "env delete" before, or it's their
// first time running this command.
// We should clean up any IAM roles that were *not* deleted during "env delete"
// before re-creating the stack otherwise the deployment will fail.
o.tryDeletingEnvRoles(app, env)
return nil
}
// tryDeletingEnvRoles attempts a best effort deletion of IAM roles created from an environment.
// To ensure that the roles being deleted were created by Copilot, we check if the copilot-environment tag
// is applied to the role.
func (o *initEnvOpts) tryDeletingEnvRoles(app, env string) {
roleNames := []string{
fmt.Sprintf("%s-CFNExecutionRole", stack.NameForEnv(app, env)),
fmt.Sprintf("%s-EnvManagerRole", stack.NameForEnv(app, env)),
}
for _, roleName := range roleNames {
tags, err := o.iam.ListRoleTags(roleName)
if err != nil {
continue
}
if _, hasTag := tags[deploy.EnvTagKey]; !hasTag {
continue
}
_ = o.iam.DeleteRole(roleName)
}
}
func (o *initEnvOpts) writeManifest() (string, error) {
customizedEnv := &config.CustomizeEnv{
ImportVPC: o.importVPCConfig(),
VPCConfig: o.adjustVPCConfig(),
ImportCertARNs: o.importCerts,
InternalALBSubnets: o.internalALBSubnets,
EnableInternalALBVPCIngress: o.allowVPCIngress,
}
if customizedEnv.IsEmpty() {
customizedEnv = nil
}
props := manifest.EnvironmentProps{
Name: o.name,
CustomConfig: customizedEnv,
Telemetry: o.telemetry.toConfig(),
}
var manifestExists bool
manifestPath, err := o.manifestWriter.WriteEnvironmentManifest(manifest.NewEnvironment(&props), props.Name)
if err != nil {
e, ok := err.(*workspace.ErrFileExists)
if !ok {
return "", fmt.Errorf("write environment manifest: %w", err)
}
manifestExists = true
manifestPath = e.FileName
}
manifestPath = displayPath(manifestPath)
manifestMsgFmt := "Wrote the manifest for environment %s at %s\n"
if manifestExists {
manifestMsgFmt = "Manifest file for environment %s already exists at %s, skipping writing it.\n"
}
log.Successf(manifestMsgFmt, color.HighlightUserInput(props.Name), color.HighlightResource(manifestPath))
return manifestPath, nil
}
func validateAppVersion(vg versionGetter, name, templateVersion string) error {
appVersion, err := vg.Version()
if err != nil {
return fmt.Errorf("get template version of application %s: %w", name, err)
}
if diff := semver.Compare(appVersion, templateVersion); diff > 0 {
return &errCannotDowngradeAppVersion{
appName: name,
appVersion: appVersion,
templateVersion: templateVersion,
}
}
return nil
}
// buildEnvInitCmd builds the command for adding an environment.
func buildEnvInitCmd() *cobra.Command {
vars := initEnvVars{}
cmd := &cobra.Command{
Use: "init",
Short: "Creates a new environment in your application.",
Example: `
Creates a test environment using your "default" AWS profile and default configuration.
/code $ copilot env init --name test --profile default --default-config
Creates a prod-iad environment using your "prod-admin" AWS profile and enables container insights.
/code $ copilot env init --name prod-iad --profile prod-admin --container-insights
Creates an environment with imported resources.
/code $ copilot env init --import-vpc-id vpc-099c32d2b98cdcf47 \
/code --import-public-subnets subnet-013e8b691862966cf,subnet-014661ebb7ab8681a \
/code --import-private-subnets subnet-055fafef48fb3c547,subnet-00c9e76f288363e7f \
/code --import-cert-arns arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012
Creates an environment with overridden CIDRs and AZs.
/code $ copilot env init --override-vpc-cidr 10.1.0.0/16 \
/code --override-az-names us-west-2b,us-west-2c \
/code --override-public-cidrs 10.1.0.0/24,10.1.1.0/24 \
/code --override-private-cidrs 10.1.2.0/24,10.1.3.0/24`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newInitEnvOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", envFlagDescription)
cmd.Flags().StringVar(&vars.profile, profileFlag, "", profileFlagDescription)
cmd.Flags().StringVar(&vars.tempCreds.AccessKeyID, accessKeyIDFlag, "", accessKeyIDFlagDescription)
cmd.Flags().StringVar(&vars.tempCreds.SecretAccessKey, secretAccessKeyFlag, "", secretAccessKeyFlagDescription)
cmd.Flags().StringVar(&vars.tempCreds.SessionToken, sessionTokenFlag, "", sessionTokenFlagDescription)
cmd.Flags().StringVar(&vars.region, regionFlag, "", envRegionTokenFlagDescription)
cmd.Flags().BoolVar(&vars.allowAppDowngrade, allowDowngradeFlag, false, allowDowngradeFlagDescription)
cmd.Flags().BoolVar(&vars.isProduction, prodEnvFlag, false, prodEnvFlagDescription) // Deprecated. Use telemetry flags instead.
cmd.Flags().BoolVar(&vars.telemetry.EnableContainerInsights, enableContainerInsightsFlag, false, enableContainerInsightsFlagDescription)
cmd.Flags().StringVar(&vars.importVPC.ID, vpcIDFlag, "", vpcIDFlagDescription)
cmd.Flags().StringSliceVar(&vars.importVPC.PublicSubnetIDs, publicSubnetsFlag, nil, publicSubnetsFlagDescription)
cmd.Flags().StringSliceVar(&vars.importVPC.PrivateSubnetIDs, privateSubnetsFlag, nil, privateSubnetsFlagDescription)
cmd.Flags().StringSliceVar(&vars.importCerts, certsFlag, nil, certsFlagDescription)
cmd.Flags().IPNetVar(&vars.adjustVPC.CIDR, overrideVPCCIDRFlag, net.IPNet{}, overrideVPCCIDRFlagDescription)
cmd.Flags().StringSliceVar(&vars.adjustVPC.AZs, overrideAZsFlag, nil, overrideAZsFlagDescription)
// TODO: use IPNetSliceVar when it is available (https://github.com/spf13/pflag/issues/273).
cmd.Flags().StringSliceVar(&vars.adjustVPC.PublicSubnetCIDRs, overridePublicSubnetCIDRsFlag, nil, overridePublicSubnetCIDRsFlagDescription)
cmd.Flags().StringSliceVar(&vars.adjustVPC.PrivateSubnetCIDRs, overridePrivateSubnetCIDRsFlag, nil, overridePrivateSubnetCIDRsFlagDescription)
cmd.Flags().StringSliceVar(&vars.internalALBSubnets, internalALBSubnetsFlag, nil, internalALBSubnetsFlagDescription)
cmd.Flags().BoolVar(&vars.allowVPCIngress, allowVPCIngressFlag, false, allowVPCIngressFlagDescription)
cmd.Flags().BoolVar(&vars.defaultConfig, defaultConfigFlag, false, defaultConfigFlagDescription)
flags := pflag.NewFlagSet("Common", pflag.ContinueOnError)
flags.AddFlag(cmd.Flags().Lookup(appFlag))
flags.AddFlag(cmd.Flags().Lookup(nameFlag))
flags.AddFlag(cmd.Flags().Lookup(profileFlag))
flags.AddFlag(cmd.Flags().Lookup(accessKeyIDFlag))
flags.AddFlag(cmd.Flags().Lookup(secretAccessKeyFlag))
flags.AddFlag(cmd.Flags().Lookup(sessionTokenFlag))
flags.AddFlag(cmd.Flags().Lookup(regionFlag))
flags.AddFlag(cmd.Flags().Lookup(defaultConfigFlag))
flags.AddFlag(cmd.Flags().Lookup(allowDowngradeFlag))
resourcesImportFlags := pflag.NewFlagSet("Import Existing Resources", pflag.ContinueOnError)
resourcesImportFlags.AddFlag(cmd.Flags().Lookup(vpcIDFlag))
resourcesImportFlags.AddFlag(cmd.Flags().Lookup(publicSubnetsFlag))
resourcesImportFlags.AddFlag(cmd.Flags().Lookup(privateSubnetsFlag))
resourcesImportFlags.AddFlag(cmd.Flags().Lookup(certsFlag))
resourcesConfigFlags := pflag.NewFlagSet("Configure Default Resources", pflag.ContinueOnError)
resourcesConfigFlags.AddFlag(cmd.Flags().Lookup(overrideVPCCIDRFlag))
resourcesConfigFlags.AddFlag(cmd.Flags().Lookup(overrideAZsFlag))
resourcesConfigFlags.AddFlag(cmd.Flags().Lookup(overridePublicSubnetCIDRsFlag))
resourcesConfigFlags.AddFlag(cmd.Flags().Lookup(overridePrivateSubnetCIDRsFlag))
resourcesConfigFlags.AddFlag(cmd.Flags().Lookup(internalALBSubnetsFlag))
resourcesConfigFlags.AddFlag(cmd.Flags().Lookup(allowVPCIngressFlag))
telemetryFlags := pflag.NewFlagSet("Telemetry", pflag.ContinueOnError)
telemetryFlags.AddFlag(cmd.Flags().Lookup(enableContainerInsightsFlag))
cmd.Annotations = map[string]string{
// The order of the sections we want to display.
"sections": "Common,Import Existing Resources,Configure Default Resources,Telemetry",
"Common": flags.FlagUsages(),
"Import Existing Resources": resourcesImportFlags.FlagUsages(),
"Configure Default Resources": resourcesConfigFlags.FlagUsages(),
"Telemetry": telemetryFlags.FlagUsages(),
}
cmd.SetUsageTemplate(`{{h1 "Usage"}}{{if .Runnable}}
{{.UseLine}}{{end}}{{$annotations := .Annotations}}{{$sections := split .Annotations.sections ","}}{{if gt (len $sections) 0}}
{{range $i, $sectionName := $sections}}{{h1 (print $sectionName " Flags")}}
{{(index $annotations $sectionName) | trimTrailingWhitespaces}}{{if ne (inc $i) (len $sections)}}
{{end}}{{end}}{{end}}{{if .HasAvailableInheritedFlags}}
{{h1 "Global Flags"}}
{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasExample}}
{{h1 "Examples"}}{{code .Example}}{{end}}
`)
return cmd
}
| 1,011 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"net"
"testing"
"github.com/aws/copilot-cli/internal/pkg/aws/ec2"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
deploycfn "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
)
type initEnvMocks struct {
sessProvider *mocks.MocksessionProvider
prompt *mocks.Mockprompter
selVPC *mocks.Mockec2Selector
selCreds *mocks.MockcredsSelector
ec2Client *mocks.Mockec2Client
selApp *mocks.MockappSelector
store *mocks.Mockstore
wsAppName string
}
func TestInitEnvOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inEnvName string
inAppName string
inDefault bool
inVPCID string
inPublicIDs []string
inPrivateIDs []string
inInternalALBSubnets []string
inVPCCIDR net.IPNet
inAZs []string
inPublicCIDRs []string
inProfileName string
inAccessKeyID string
inSecretAccessKey string
inSessionToken string
setupMocks func(m *initEnvMocks)
wantedErrMsg string
}{
"valid environment creation": {
inEnvName: "test-pdx",
inAppName: "phonetool",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test-pdx").Return(nil, &config.ErrNoSuchEnvironment{})
},
},
"fail if command not run under a workspace": {
wantedErrMsg: "could not find an application attached to this workspace, please run `app init` first",
},
"fail if using different app name from the workspace": {
inAppName: "demo",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
},
wantedErrMsg: "cannot specify app demo because the workspace is already registered with app phonetool",
},
"fail if cannot validate application": {
inAppName: "phonetool",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, errors.New("some error"))
},
wantedErrMsg: "get application phonetool configuration: some error",
},
"invalid environment name": {
inEnvName: "123env",
inAppName: "phonetool",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
wantedErrMsg: fmt.Sprintf("environment name 123env is invalid: %s", errBasicNameRegexNotMatched),
},
"should error if environment already exists": {
inEnvName: "test-pdx",
inAppName: "phonetool",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test-pdx").Return(nil, nil)
},
wantedErrMsg: "environment test-pdx already exists",
},
"cannot specify both vpc resources importing flags and configuring flags": {
inEnvName: "test-pdx",
inAppName: "phonetool",
inPublicCIDRs: []string{"mockCIDR"},
inPublicIDs: []string{"mockID", "anotherMockID"},
inVPCCIDR: net.IPNet{
IP: net.IP{10, 1, 232, 0},
Mask: net.IPMask{255, 255, 255, 0},
},
inVPCID: "mockID",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test-pdx").Return(nil, &config.ErrNoSuchEnvironment{})
},
wantedErrMsg: "cannot specify both import vpc flags and configure vpc flags",
},
"cannot import or configure resources if use default flag is set": {
inEnvName: "test-pdx",
inAppName: "phonetool",
inDefault: true,
inVPCID: "mockID",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test-pdx").Return(nil, &config.ErrNoSuchEnvironment{})
},
wantedErrMsg: fmt.Sprintf("cannot import or configure vpc if --%s is set", defaultConfigFlag),
},
"should err if both profile and access key id are set": {
inAppName: "phonetool",
inEnvName: "test",
inProfileName: "default",
inAccessKeyID: "AKIAIOSFODNN7EXAMPLE",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(nil, &config.ErrNoSuchEnvironment{})
},
wantedErrMsg: "cannot specify both --profile and --aws-access-key-id",
},
"should err if both profile and secret access key are set": {
inAppName: "phonetool",
inEnvName: "test",
inProfileName: "default",
inSecretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(nil, &config.ErrNoSuchEnvironment{})
},
wantedErrMsg: "cannot specify both --profile and --aws-secret-access-key",
},
"should err if both profile and session token are set": {
inAppName: "phonetool",
inEnvName: "test",
inProfileName: "default",
inSessionToken: "verylongtoken",
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(nil, &config.ErrNoSuchEnvironment{})
},
wantedErrMsg: "cannot specify both --profile and --aws-session-token",
},
"should err if fewer than two private subnets are set:": {
inVPCID: "mockID",
inPublicIDs: []string{"mockID", "anotherMockID"},
inPrivateIDs: []string{"mockID"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
wantedErrMsg: "at least two private subnets must be imported",
},
"should err if fewer than two availability zones are provided": {
inAZs: []string{"us-east-1a"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
wantedErrMsg: "at least two availability zones must be provided to enable Load Balancing",
},
"invalid VPC resource import (no VPC, 1 public, 2 private)": {
inPublicIDs: []string{"mockID"},
inPrivateIDs: []string{"mockID", "anotherMockID"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
wantedErrMsg: "at least two public subnets must be imported to enable Load Balancing",
},
"valid VPC resource import (0 public, 3 private)": {
inVPCID: "mockID",
inPublicIDs: []string{},
inPrivateIDs: []string{"mockID", "anotherMockID", "yetAnotherMockID"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
},
"valid VPC resource import (3 public, 2 private)": {
inVPCID: "mockID",
inPublicIDs: []string{"mockID", "anotherMockID", "yetAnotherMockID"},
inPrivateIDs: []string{"mockID", "anotherMockID"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
},
"cannot specify internal ALB subnet placement with default config": {
inDefault: true,
inInternalALBSubnets: []string{"mockSubnet", "anotherMockSubnet"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
wantedErrMsg: "subnets 'mockSubnet, anotherMockSubnet' specified for internal ALB placement, but those subnets are not imported",
},
"cannot specify internal ALB subnet placement with adjusted VPC resources": {
inPublicCIDRs: []string{"mockCIDR"},
inInternalALBSubnets: []string{"mockSubnet", "anotherMockSubnet"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
wantedErrMsg: "subnets 'mockSubnet, anotherMockSubnet' specified for internal ALB placement, but those subnets are not imported",
},
"invalid specification of internal ALB subnet placement": {
inPrivateIDs: []string{"mockID", "mockSubnet", "anotherMockSubnet"},
inInternalALBSubnets: []string{"mockSubnet", "notMockSubnet"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
wantedErrMsg: "subnets 'mockSubnet, notMockSubnet' were designated for ALB placement, but they were not all imported",
},
"valid specification of internal ALB subnet placement": {
inPrivateIDs: []string{"mockID", "mockSubnet", "anotherMockSubnet"},
inInternalALBSubnets: []string{"mockSubnet", "anotherMockSubnet"},
setupMocks: func(m *initEnvMocks) {
m.wsAppName = "phonetool"
m.store.EXPECT().GetApplication("phonetool").Return(nil, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &initEnvMocks{
store: mocks.NewMockstore(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(m)
}
// GIVEN
opts := &initEnvOpts{
initEnvVars: initEnvVars{
name: tc.inEnvName,
defaultConfig: tc.inDefault,
internalALBSubnets: tc.inInternalALBSubnets,
adjustVPC: adjustVPCVars{
AZs: tc.inAZs,
PublicSubnetCIDRs: tc.inPublicCIDRs,
CIDR: tc.inVPCCIDR,
},
importVPC: importVPCVars{
PublicSubnetIDs: tc.inPublicIDs,
PrivateSubnetIDs: tc.inPrivateIDs,
ID: tc.inVPCID,
},
appName: tc.inAppName,
profile: tc.inProfileName,
tempCreds: tempCredsVars{
AccessKeyID: tc.inAccessKeyID,
SecretAccessKey: tc.inSecretAccessKey,
SessionToken: tc.inSessionToken,
},
},
store: m.store,
wsAppName: m.wsAppName,
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedErrMsg != "" {
require.EqualError(t, err, tc.wantedErrMsg)
} else {
require.NoError(t, err)
}
})
}
}
func TestInitEnvOpts_Ask(t *testing.T) {
const (
mockApp = "test-app"
mockEnv = "test"
mockProfile = "default"
mockVPCCIDR = "10.10.10.10/24"
mockSubnetCIDRs = "10.10.10.10/24,10.10.10.10/24"
mockRegion = "us-west-2"
)
mockErr := errors.New("some error")
mockSession := &session.Session{
Config: &aws.Config{
Region: aws.String(mockRegion),
},
}
mockPublicSubnetInput := selector.SubnetsInput{
Msg: envInitPublicSubnetsSelectPrompt,
Help: "",
VPCID: "mockVPC",
IsPublic: true,
}
mockPrivateSubnetInput := selector.SubnetsInput{
Msg: envInitPrivateSubnetsSelectPrompt,
Help: "",
VPCID: "mockVPC",
IsPublic: false,
}
testCases := map[string]struct {
inAppName string
inEnv string
inProfile string
inTempCreds tempCredsVars
inRegion string
inDefault bool
inImportVPCVars importVPCVars
inAdjustVPCVars adjustVPCVars
inInternalALBSubnets []string
setupMocks func(mocks initEnvMocks)
wantedError error
}{
"fail to get env name": {
inAppName: mockApp,
setupMocks: func(m initEnvMocks) {
gomock.InOrder(
m.prompt.EXPECT().
Get(envInitNamePrompt, envInitNameHelpPrompt, gomock.Any(), gomock.Any()).
Return("", mockErr),
)
},
wantedError: fmt.Errorf("get environment name: some error"),
},
"should error if environment already exists": {
inAppName: mockApp,
setupMocks: func(m initEnvMocks) {
gomock.InOrder(
m.prompt.EXPECT().
Get(envInitNamePrompt, envInitNameHelpPrompt, gomock.Any(), gomock.Any()).
Return("test", nil),
m.store.EXPECT().GetEnvironment(mockApp, mockEnv).Return(nil, nil),
)
},
wantedError: errors.New("environment test already exists"),
},
"should create a session from a named profile if flag is provided": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inDefault: true,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(mockProfile).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("us-west-2"),
},
}, nil)
},
},
"should create a session from temporary creds if flags are provided": {
inAppName: mockApp,
inEnv: mockEnv,
inTempCreds: tempCredsVars{
AccessKeyID: "abcd",
SecretAccessKey: "efgh",
},
inDefault: true,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromStaticCreds("abcd", "efgh", "").Return(mockSession, nil)
},
},
"should prompt for credentials if no profile or temp creds flags are provided": {
inAppName: mockApp,
inEnv: mockEnv,
inDefault: true,
setupMocks: func(m initEnvMocks) {
m.selCreds.EXPECT().Creds("Which credentials would you like to use to create test?", gomock.Any()).Return(mockSession, nil)
},
},
"should prompt for region if user configuration does not have one": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inDefault: true,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(&session.Session{
Config: &aws.Config{},
}, nil)
m.prompt.EXPECT().Get("Which region?", gomock.Any(), nil, gomock.Any(), gomock.Any()).Return("us-west-2", nil)
},
},
"should skip prompting for region if flag is provided": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inRegion: mockRegion,
inDefault: true,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(&session.Session{
Config: &aws.Config{},
}, nil)
m.prompt.EXPECT().Get("Which region?", gomock.Any(), nil, gomock.Any(), gomock.Any()).Times(0)
},
},
"should not prompt for configuring environment if default config flag is true": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inDefault: true,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
},
"fail to select whether to adjust or import resources": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return("", mockErr)
},
wantedError: fmt.Errorf("select adjusting or importing resources: some error"),
},
"success with no custom resources": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitDefaultConfigSelectOption, nil)
},
},
"fail to select VPC": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("", mockErr)
},
wantedError: fmt.Errorf("select VPC: some error"),
},
"fail to check if VPC has DNS support": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(false, mockErr)
},
wantedError: fmt.Errorf("check if VPC mockVPC has DNS support enabled: some error"),
},
"fail to import VPC has no DNS support": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(false, nil)
},
wantedError: fmt.Errorf("VPC mockVPC has no DNS support enabled"),
},
"fail to select public subnets": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return(nil, mockErr)
},
wantedError: fmt.Errorf("select public subnets: some error"),
},
"fail to select TWO public subnets": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet"}, nil)
},
wantedError: fmt.Errorf("select public subnets: at least two public subnets must be selected to enable Load Balancing"),
},
"fail to select private subnets": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return(nil, mockErr)
},
wantedError: fmt.Errorf("select private subnets: some error"),
},
"fail to select TWO private subnets": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{"mockPrivateSubnet"}, nil)
},
wantedError: fmt.Errorf("select private subnets: at least two private subnets must be selected"),
},
"success with selecting zero public subnets and two private subnets": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{"mockPrivateSubnet", "anotherMockPrivateSubnet"}, nil)
},
},
"success with selecting two public subnets and zero private subnets": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{}, nil)
},
},
"success with importing env resources with no flags": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitImportEnvResourcesSelectOption, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{"mockPrivateSubnet", "anotherMockPrivateSubnet"}, nil)
},
},
"success with importing env resources with flags": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inImportVPCVars: importVPCVars{
ID: "mockVPCID",
PrivateSubnetIDs: []string{"mockPrivateSubnetID", "anotherMockPrivateSubnetID"},
PublicSubnetIDs: []string{"mockPublicSubnetID", "anotherMockPublicSubnetID"},
},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
m.ec2Client.EXPECT().HasDNSSupport("mockVPCID").Return(true, nil)
},
},
"prompt for subnets if only VPC passed with flag": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inImportVPCVars: importVPCVars{
ID: "mockVPC",
},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{"mockPrivateSubnet", "anotherMockPrivateSubnet"}, nil)
},
},
"prompt for VPC if only subnets passed with flags": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inImportVPCVars: importVPCVars{
PrivateSubnetIDs: []string{"mockPrivateSubnetID", "anotherMockPrivateSubnetID"},
PublicSubnetIDs: []string{"mockPublicSubnetID", "anotherMockPublicSubnetID"},
},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
},
},
"prompt for public subnets if only private subnets and VPC passed with flags": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inImportVPCVars: importVPCVars{
ID: "mockVPC",
PrivateSubnetIDs: []string{"mockPrivateSubnetID", "anotherMockPrivateSubnetID"},
},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
},
},
"prompt for private subnets if only public subnets and VPC passed with flags": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inImportVPCVars: importVPCVars{
ID: "mockVPC",
PublicSubnetIDs: []string{"mockPublicSubnetID", "anotherMockPublicSubnetID"},
},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{"mockPrivateSubnet", "anotherMockPrivateSubnet"}, nil)
},
},
"after prompting for missing imported VPC resources, validate if internalALBSubnets set": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inImportVPCVars: importVPCVars{
ID: "mockVPC",
},
inInternalALBSubnets: []string{"nonexistentSubnet", "anotherNonexistentSubnet"},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{"mockPrivateSubnet", "anotherMockPrivateSubnet"}, nil)
},
wantedError: errors.New("subnets 'nonexistentSubnet, anotherNonexistentSubnet' were designated for ALB placement, but they were not all imported"),
},
"error if no subnets selected": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inImportVPCVars: importVPCVars{
ID: "mockVPC",
},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return(nil, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return(nil, nil)
},
wantedError: fmt.Errorf("VPC must have subnets in order to proceed with environment creation"),
},
"only prompt for imported resources if internalALBSubnets set": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inInternalALBSubnets: []string{"mockPrivateSubnet", "anotherMockPrivateSubnet"},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.selVPC.EXPECT().VPC(envInitVPCSelectPrompt, "").Return("mockVPC", nil)
m.ec2Client.EXPECT().HasDNSSupport("mockVPC").Return(true, nil)
m.selVPC.EXPECT().Subnets(mockPublicSubnetInput).
Return([]string{"mockPublicSubnet", "anotherMockPublicSubnet"}, nil)
m.selVPC.EXPECT().Subnets(mockPrivateSubnetInput).
Return([]string{"mockPrivateSubnet", "anotherMockPrivateSubnet"}, nil)
},
},
"fail to get VPC CIDR": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitAdjustEnvResourcesSelectOption, nil)
m.prompt.EXPECT().Get(envInitVPCCIDRPrompt, envInitVPCCIDRPromptHelp, gomock.Any(), gomock.Any()).
Return("", mockErr)
},
wantedError: fmt.Errorf("get VPC CIDR: some error"),
},
"should return err when failed to retrieve list of AZs to adjust": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(envInitAdjustEnvResourcesSelectOption, nil)
m.prompt.EXPECT().Get(envInitVPCCIDRPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(mockVPCCIDR, nil)
m.ec2Client.EXPECT().ListAZs().Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("list availability zones for region %s: some error", mockRegion),
},
"should return err if the number of available AZs does not meet the minimum": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(envInitAdjustEnvResourcesSelectOption, nil)
m.prompt.EXPECT().Get(envInitVPCCIDRPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(mockVPCCIDR, nil)
m.ec2Client.EXPECT().ListAZs().Return([]ec2.AZ{
{
Name: "us-east-1a",
},
}, nil)
},
wantedError: fmt.Errorf("requires at least 2 availability zones (us-east-1a) in region %s", mockRegion),
},
"fail to get public subnet CIDRs": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(envInitAdjustEnvResourcesSelectOption, nil)
m.prompt.EXPECT().Get(envInitVPCCIDRPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(mockVPCCIDR, nil)
m.ec2Client.EXPECT().ListAZs().Return([]ec2.AZ{
{
Name: "us-east-1a",
},
{
Name: "us-east-1b",
},
}, nil)
m.prompt.EXPECT().MultiSelect(envInitAdjustAZPrompt, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return([]string{"us-east-1a", "us-east-1b"}, nil)
m.prompt.EXPECT().Get(envInitPublicCIDRPrompt, envInitPublicCIDRPromptHelp, gomock.Any(), gomock.Any()).
Return("", mockErr)
},
wantedError: fmt.Errorf("get public subnet CIDRs: some error"),
},
"fail to get private subnet CIDRs": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(envInitAdjustEnvResourcesSelectOption, nil)
m.prompt.EXPECT().Get(envInitVPCCIDRPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(mockVPCCIDR, nil)
m.ec2Client.EXPECT().ListAZs().Return([]ec2.AZ{
{
Name: "us-east-1a",
},
{
Name: "us-east-1b",
},
}, nil)
m.prompt.EXPECT().MultiSelect(envInitAdjustAZPrompt, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return([]string{"us-east-1a", "us-east-1b"}, nil)
m.prompt.EXPECT().Get(envInitPublicCIDRPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return(mockSubnetCIDRs, nil)
m.prompt.EXPECT().Get(envInitPrivateCIDRPrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return("", mockErr)
},
wantedError: fmt.Errorf("get private subnet CIDRs: some error"),
},
"success with adjusting default env config with no flags": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, "", envInitCustomizedEnvTypes, gomock.Any()).
Return(envInitAdjustEnvResourcesSelectOption, nil)
m.prompt.EXPECT().Get(envInitVPCCIDRPrompt, envInitVPCCIDRPromptHelp, gomock.Any(), gomock.Any()).
Return(mockVPCCIDR, nil)
m.ec2Client.EXPECT().ListAZs().Return([]ec2.AZ{
{
Name: "us-east-1a",
},
{
Name: "us-east-1b",
},
}, nil)
m.prompt.EXPECT().MultiSelect(envInitAdjustAZPrompt, gomock.Any(), []string{"us-east-1a", "us-east-1b"}, gomock.Any(), gomock.Any()).
Return([]string{"us-east-1a", "us-east-1b"}, nil)
m.prompt.EXPECT().Get(envInitPublicCIDRPrompt, envInitPublicCIDRPromptHelp, gomock.Any(), gomock.Any()).
Return(mockSubnetCIDRs, nil)
m.prompt.EXPECT().Get(envInitPrivateCIDRPrompt, envInitPrivateCIDRPromptHelp, gomock.Any(), gomock.Any()).
Return(mockSubnetCIDRs, nil)
},
},
"success with adjusting default env config with flags": {
inAppName: mockApp,
inEnv: mockEnv,
inProfile: mockProfile,
inAdjustVPCVars: adjustVPCVars{
CIDR: net.IPNet{
IP: net.IP{10, 1, 232, 0},
Mask: net.IPMask{255, 255, 255, 0},
},
AZs: []string{"us-east-1a", "us-east-1b"},
PrivateSubnetCIDRs: []string{"mockPrivateCIDR1", "mockPrivateCIDR2"},
PublicSubnetCIDRs: []string{"mockPublicCIDR1", "mockPublicCIDR2"},
},
setupMocks: func(m initEnvMocks) {
m.sessProvider.EXPECT().FromProfile(gomock.Any()).Return(mockSession, nil)
m.prompt.EXPECT().SelectOne(envInitDefaultEnvConfirmPrompt, gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := initEnvMocks{
sessProvider: mocks.NewMocksessionProvider(ctrl),
prompt: mocks.NewMockprompter(ctrl),
selVPC: mocks.NewMockec2Selector(ctrl),
selCreds: mocks.NewMockcredsSelector(ctrl),
ec2Client: mocks.NewMockec2Client(ctrl),
selApp: mocks.NewMockappSelector(ctrl),
store: mocks.NewMockstore(ctrl),
}
tc.setupMocks(mocks)
// GIVEN
addEnv := &initEnvOpts{
initEnvVars: initEnvVars{
appName: tc.inAppName,
name: tc.inEnv,
profile: tc.inProfile,
tempCreds: tc.inTempCreds,
region: tc.inRegion,
defaultConfig: tc.inDefault,
adjustVPC: tc.inAdjustVPCVars,
importVPC: tc.inImportVPCVars,
internalALBSubnets: tc.inInternalALBSubnets,
},
sessProvider: mocks.sessProvider,
selVPC: mocks.selVPC,
selCreds: func() (credsSelector, error) {
return mocks.selCreds, nil
},
ec2Client: mocks.ec2Client,
prompt: mocks.prompt,
selApp: mocks.selApp,
store: mocks.store,
}
// WHEN
err := addEnv.Ask()
// THEN
if tc.wantedError == nil {
require.NoError(t, err)
require.Equal(t, mockEnv, addEnv.name, "expected environment names to match")
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
type initEnvExecuteMocks struct {
store *mocks.Mockstore
deployer *mocks.Mockdeployer
identity *mocks.MockidentityService
progress *mocks.Mockprogress
iam *mocks.MockroleManager
cfn *mocks.MockstackExistChecker
appCFN *mocks.MockappResourcesGetter
manifestWriter *mocks.MockenvironmentManifestWriter
appVersionGetter *mocks.MockversionGetter
}
func TestInitEnvOpts_Execute(t *testing.T) {
const (
mockAppVersion = "v0.0.0"
mockCurrVersion = "v1.29.0"
mockFutureAppVersion = "v2.0.0"
)
mockError := errors.New("some error")
testCases := map[string]struct {
enableContainerInsights bool
allowDowngrade bool
setupMocks func(m *initEnvExecuteMocks)
wantedErrorS string
}{
"returns error when failed to get app version": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return("", mockError)
},
wantedErrorS: "get template version of application phonetool: some error",
},
"returns error when cannot downgrade app version": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockFutureAppVersion, nil)
},
wantedErrorS: "cannot downgrade application \"phonetool\" (currently in version v2.0.0) to version v1.29.0",
},
"returns app exists error": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(nil, mockError)
},
wantedErrorS: "some error",
},
"returns identity get error": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.identity.EXPECT().Get().Return(identity.Caller{}, errors.New("some identity error"))
},
wantedErrorS: "get identity: some identity error",
},
"fail to write manifest": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().CreateEnvironment(gomock.Any()).Times(0)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("", mockError)
},
wantedErrorS: "write environment manifest: some error",
},
"failed to create stack set instance": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().CreateEnvironment(gomock.Any()).Times(0)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil)
m.deployer.EXPECT().AddEnvToApp(&deploycfn.AddEnvToAppOpts{
App: &config.Application{Name: "phonetool"},
EnvName: "test",
EnvAccountID: "1234",
EnvRegion: "us-west-2",
}).Return(errors.New("some cfn error"))
},
wantedErrorS: "add env test to application phonetool: some cfn error",
},
"errors cannot get app resources by region": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil)
m.deployer.EXPECT().AddEnvToApp(gomock.Any()).Return(nil)
m.appCFN.EXPECT().GetAppResourcesByRegion(&config.Application{Name: "phonetool"}, "us-west-2").
Return(nil, mockError)
},
wantedErrorS: "get app resources: some error",
},
"deletes retained IAM roles if environment stack fails creation": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil).Times(2)
gomock.InOrder(
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil),
// Skip deleting non-existing roles.
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-CFNExecutionRole")).Return(nil, errors.New("does not exist")),
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-EnvManagerRole")).Return(nil, errors.New("does not exist")),
// Cleanup after created roles.
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-CFNExecutionRole")).Return(map[string]string{
"copilot-application": "phonetool",
"copilot-environment": "test",
}, nil),
m.iam.EXPECT().DeleteRole(gomock.Eq("phonetool-test-CFNExecutionRole")).Return(nil),
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-EnvManagerRole")).Return(nil, errors.New("does not exist")),
)
m.cfn.EXPECT().Exists("phonetool-test").Return(false, nil)
m.deployer.EXPECT().AddEnvToApp(gomock.Any()).Return(nil)
m.deployer.EXPECT().CreateAndRenderEnvironment(gomock.Any(), gomock.Any()).Return(errors.New("some deploy error"))
m.appCFN.EXPECT().GetAppResourcesByRegion(&config.Application{Name: "phonetool"}, "us-west-2").
Return(&stack.AppRegionalResources{
S3Bucket: "mockBucket",
}, nil)
},
wantedErrorS: "some deploy error",
},
"returns error from CreateEnvironment": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{
Name: "phonetool",
}, nil)
m.store.EXPECT().CreateEnvironment(gomock.Any()).Return(errors.New("some create error"))
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil).Times(2)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil)
m.iam.EXPECT().ListRoleTags(gomock.Any()).
Return(nil, errors.New("does not exist")).AnyTimes()
m.cfn.EXPECT().Exists("phonetool-test").Return(false, nil)
m.deployer.EXPECT().CreateAndRenderEnvironment(gomock.Any(), gomock.Any()).Return(nil)
m.deployer.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{
App: "phonetool",
Name: "test",
AccountID: "1234",
Region: "mars-1",
}, nil)
m.deployer.EXPECT().AddEnvToApp(gomock.Any()).Return(nil)
m.appCFN.EXPECT().GetAppResourcesByRegion(&config.Application{Name: "phonetool"}, "us-west-2").
Return(&stack.AppRegionalResources{
S3Bucket: "mockBucket",
}, nil)
},
wantedErrorS: "store environment: some create error",
},
"success": {
enableContainerInsights: true,
allowDowngrade: true,
setupMocks: func(m *initEnvExecuteMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.store.EXPECT().CreateEnvironment(&config.Environment{
App: "phonetool",
Name: "test",
AccountID: "1234",
Region: "mars-1",
}).Return(nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil).Times(2)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil)
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-CFNExecutionRole")).Return(nil, errors.New("does not exist"))
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-EnvManagerRole")).Return(nil, errors.New("does not exist"))
m.cfn.EXPECT().Exists("phonetool-test").Return(false, nil)
m.deployer.EXPECT().CreateAndRenderEnvironment(gomock.Any(), gomock.Any()).Return(nil)
m.deployer.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{
AccountID: "1234",
Region: "mars-1",
Name: "test",
App: "phonetool",
}, nil)
m.deployer.EXPECT().AddEnvToApp(gomock.Any()).Return(nil)
m.appCFN.EXPECT().GetAppResourcesByRegion(&config.Application{Name: "phonetool"}, "us-west-2").
Return(&stack.AppRegionalResources{
S3Bucket: "mockBucket",
}, nil)
},
},
"proceed if manifest already exists": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.store.EXPECT().CreateEnvironment(&config.Environment{
App: "phonetool",
Name: "test",
AccountID: "1234",
Region: "mars-1",
}).Return(nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil).Times(2)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("", &workspace.ErrFileExists{
FileName: "/environments/test/manifest.yml",
})
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil)
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-CFNExecutionRole")).Return(nil, errors.New("does not exist"))
m.iam.EXPECT().ListRoleTags(gomock.Eq("phonetool-test-EnvManagerRole")).Return(nil, errors.New("does not exist"))
m.cfn.EXPECT().Exists("phonetool-test").Return(false, nil)
m.deployer.EXPECT().CreateAndRenderEnvironment(gomock.Any(), gomock.Any()).Return(nil)
m.deployer.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{
AccountID: "1234",
Region: "mars-1",
Name: "test",
App: "phonetool",
}, nil)
m.deployer.EXPECT().AddEnvToApp(gomock.Any()).Return(nil)
m.appCFN.EXPECT().GetAppResourcesByRegion(&config.Application{Name: "phonetool"}, "us-west-2").
Return(&stack.AppRegionalResources{
S3Bucket: "mockBucket",
}, nil)
},
},
"skips creating stack if environment stack already exists": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.store.EXPECT().CreateEnvironment(&config.Environment{
App: "phonetool",
Name: "test",
AccountID: "1234",
Region: "mars-1",
}).Return(nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "1234"}, nil).Times(2)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil)
// Don't attempt to delete any roles since an environment stack already exists.
m.iam.EXPECT().ListRoleTags(gomock.Any()).Times(0)
m.cfn.EXPECT().Exists("phonetool-test").Return(true, nil)
m.deployer.EXPECT().CreateAndRenderEnvironment(gomock.Any(), gomock.Any()).DoAndReturn(func(conf deploycfn.StackConfiguration, bucketARN string) error {
require.Equal(t, conf, stack.NewBootstrapEnvStackConfig(&stack.EnvConfig{
Name: "test",
App: deploy.AppInformation{
Name: "phonetool",
AccountPrincipalARN: "some arn",
},
ArtifactBucketARN: "arn:aws:s3:::mockBucket",
ArtifactBucketKeyARN: "mockKMS",
}))
require.Equal(t, bucketARN, "arn:aws:s3:::mockBucket")
return &cloudformation.ErrStackAlreadyExists{}
})
m.deployer.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{
AccountID: "1234",
Region: "mars-1",
Name: "test",
App: "phonetool",
}, nil)
m.deployer.EXPECT().AddEnvToApp(gomock.Any()).Return(nil)
m.appCFN.EXPECT().GetAppResourcesByRegion(&config.Application{Name: "phonetool"}, "us-west-2").
Return(&stack.AppRegionalResources{
S3Bucket: "mockBucket",
KMSKeyARN: "mockKMS",
}, nil)
},
},
"failed to delegate DNS (app has Domain and env and apps are different)": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool", AccountID: "1234", Domain: "amazon.com"}, nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "4567"}, nil).Times(1)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.progress.EXPECT().Start(fmt.Sprintf(fmtDNSDelegationStart, "4567"))
m.progress.EXPECT().Stop(log.Serrorf(fmtDNSDelegationFailed, "4567"))
m.deployer.EXPECT().DelegateDNSPermissions(gomock.Any(), "4567").Return(mockError)
},
wantedErrorS: "granting DNS permissions: some error",
},
"success with DNS Delegation (app has Domain and env and app are different)": {
setupMocks: func(m *initEnvExecuteMocks) {
m.appVersionGetter.EXPECT().Version().Return(mockAppVersion, nil)
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool", AccountID: "1234", Domain: "amazon.com"}, nil)
m.store.EXPECT().CreateEnvironment(&config.Environment{
App: "phonetool",
Name: "test",
AccountID: "4567",
Region: "us-west-2",
}).Return(nil)
m.identity.EXPECT().Get().Return(identity.Caller{RootUserARN: "some arn", Account: "4567"}, nil).Times(2)
m.manifestWriter.EXPECT().WriteEnvironmentManifest(gomock.Any(), "test").Return("/environments/test/manifest.yml", nil)
m.iam.EXPECT().CreateECSServiceLinkedRole().Return(nil)
m.iam.EXPECT().ListRoleTags(gomock.Any()).
Return(nil, errors.New("does not exist")).AnyTimes()
m.cfn.EXPECT().Exists("phonetool-test").Return(false, nil)
m.progress.EXPECT().Start(fmt.Sprintf(fmtDNSDelegationStart, "4567"))
m.progress.EXPECT().Stop(log.Ssuccessf(fmtDNSDelegationComplete, "4567"))
m.deployer.EXPECT().DelegateDNSPermissions(gomock.Any(), "4567").Return(nil)
m.deployer.EXPECT().CreateAndRenderEnvironment(gomock.Any(), gomock.Any()).Return(nil)
m.deployer.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{
AccountID: "4567",
Region: "us-west-2",
Name: "test",
App: "phonetool",
}, nil)
m.deployer.EXPECT().AddEnvToApp(gomock.Any()).Return(nil)
m.appCFN.EXPECT().GetAppResourcesByRegion(&config.Application{
Name: "phonetool",
AccountID: "1234",
Domain: "amazon.com",
}, "us-west-2").
Return(&stack.AppRegionalResources{
S3Bucket: "mockBucket",
}, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &initEnvExecuteMocks{
store: mocks.NewMockstore(ctrl),
deployer: mocks.NewMockdeployer(ctrl),
identity: mocks.NewMockidentityService(ctrl),
progress: mocks.NewMockprogress(ctrl),
iam: mocks.NewMockroleManager(ctrl),
cfn: mocks.NewMockstackExistChecker(ctrl),
appCFN: mocks.NewMockappResourcesGetter(ctrl),
manifestWriter: mocks.NewMockenvironmentManifestWriter(ctrl),
appVersionGetter: mocks.NewMockversionGetter(ctrl),
}
tc.setupMocks(m)
provider := sessions.ImmutableProvider()
sess, _ := provider.DefaultWithRegion("us-west-2")
opts := &initEnvOpts{
initEnvVars: initEnvVars{
name: "test",
appName: "phonetool",
telemetry: telemetryVars{
EnableContainerInsights: tc.enableContainerInsights,
},
allowAppDowngrade: tc.allowDowngrade,
},
store: m.store,
envDeployer: m.deployer,
appDeployer: m.deployer,
identity: m.identity,
envIdentity: m.identity,
iam: m.iam,
cfn: m.cfn,
prog: m.progress,
sess: sess,
appCFN: m.appCFN,
appVersionGetter: m.appVersionGetter,
manifestWriter: m.manifestWriter,
templateVersion: mockCurrVersion,
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedErrorS != "" {
require.EqualError(t, err, tc.wantedErrorS)
} else {
require.NoError(t, err)
}
})
}
}
func TestInitEnvOpts_delegateDNSFromApp(t *testing.T) {
testCases := map[string]struct {
app *config.Application
expectDeployer func(m *mocks.Mockdeployer)
expectProgress func(m *mocks.Mockprogress)
wantedErr string
}{
"should call DelegateDNSPermissions when app and env are in different accounts": {
app: &config.Application{
AccountID: "1234",
Name: "crossaccountapp",
Domain: "amazon.com",
},
expectProgress: func(m *mocks.Mockprogress) {
m.EXPECT().Start(fmt.Sprintf(fmtDNSDelegationStart, "4567"))
m.EXPECT().Stop(log.Ssuccessf(fmtDNSDelegationComplete, "4567"))
},
expectDeployer: func(m *mocks.Mockdeployer) {
m.EXPECT().DelegateDNSPermissions(gomock.Any(), "4567").Return(nil)
},
},
"should skip updating when app and env are in same account": {
app: &config.Application{
AccountID: "4567",
Name: "crossaccountapp",
Domain: "amazon.com",
},
expectProgress: func(m *mocks.Mockprogress) {
m.EXPECT().Start(gomock.Any()).Times(0)
},
expectDeployer: func(m *mocks.Mockdeployer) {
m.EXPECT().DelegateDNSPermissions(gomock.Any(), gomock.Any()).Times(0)
},
},
"should return errors from DelegateDNSPermissions": {
app: &config.Application{
AccountID: "1234",
Name: "crossaccountapp",
Domain: "amazon.com",
},
expectProgress: func(m *mocks.Mockprogress) {
m.EXPECT().Start(fmt.Sprintf(fmtDNSDelegationStart, "4567"))
m.EXPECT().Stop(log.Serrorf(fmtDNSDelegationFailed, "4567"))
},
expectDeployer: func(m *mocks.Mockdeployer) {
m.EXPECT().DelegateDNSPermissions(gomock.Any(), gomock.Any()).Return(fmt.Errorf("error"))
},
wantedErr: "error",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockDeployer := mocks.NewMockdeployer(ctrl)
mockProgress := mocks.NewMockprogress(ctrl)
if tc.expectDeployer != nil {
tc.expectDeployer(mockDeployer)
}
if tc.expectProgress != nil {
tc.expectProgress(mockProgress)
}
opts := &initEnvOpts{
initEnvVars: initEnvVars{
appName: tc.app.Name,
},
appDeployer: mockDeployer,
prog: mockProgress,
}
// WHEN
err := opts.delegateDNSFromApp(tc.app, "4567")
// THEN
if tc.wantedErr != "" {
require.EqualError(t, err, tc.wantedErr)
} else {
require.NoError(t, err)
}
})
}
}
| 1,400 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"encoding/json"
"fmt"
"io"
"os"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
envListAppNamePrompt = "Which application is the environment in?"
envListAppNameHelper = "An application is a collection of related services."
)
type listEnvVars struct {
appName string
shouldOutputJSON bool
}
type listEnvOpts struct {
listEnvVars
store store
prompt prompter
sel configSelector
w io.Writer
}
func newListEnvOpts(vars listEnvVars) (*listEnvOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("env ls"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompter := prompt.New()
return &listEnvOpts{
listEnvVars: vars,
store: store,
sel: selector.NewConfigSelector(prompter, store),
prompt: prompter,
w: os.Stdout,
}, nil
}
// Ask asks for fields that are required but not passed in.
func (o *listEnvOpts) Ask() error {
if o.appName != "" {
return nil
}
app, err := o.sel.Application(envListAppNamePrompt, envListAppNameHelper)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
// Execute lists the environments through the prompt.
func (o *listEnvOpts) Execute() error {
// Ensure the application actually exists before we try to list its environments.
if _, err := o.store.GetApplication(o.appName); err != nil {
return err
}
envs, err := o.store.ListEnvironments(o.appName)
if err != nil {
return err
}
var out string
if o.shouldOutputJSON {
data, err := o.jsonOutput(envs)
if err != nil {
return err
}
out = data
} else {
out = o.humanOutput(envs)
}
fmt.Fprint(o.w, out)
return nil
}
func (o *listEnvOpts) humanOutput(envs []*config.Environment) string {
b := &strings.Builder{}
for _, env := range envs {
fmt.Fprintln(b, env.Name)
}
return b.String()
}
func (o *listEnvOpts) jsonOutput(envs []*config.Environment) (string, error) {
type serializedEnvs struct {
Environments []*config.Environment `json:"environments"`
}
b, err := json.Marshal(serializedEnvs{Environments: envs})
if err != nil {
return "", fmt.Errorf("marshal environments: %w", err)
}
return fmt.Sprintf("%s\n", b), nil
}
// buildEnvListCmd builds the command for listing environments in an application.
func buildEnvListCmd() *cobra.Command {
vars := listEnvVars{}
cmd := &cobra.Command{
Use: "ls",
Short: "Lists all the environments in an application.",
Example: `
Lists all the environments for the frontend application.
/code $ copilot env ls -a frontend`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newListEnvOpts(vars)
if err != nil {
return err
}
if err := opts.Ask(); err != nil {
return err
}
return opts.Execute()
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
return cmd
}
| 143 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestEnvList_Ask(t *testing.T) {
testCases := map[string]struct {
inputApp string
mockSelector func(m *mocks.MockconfigSelector)
wantedApp string
wantedErr error
}{
"with no flags set": {
mockSelector: func(m *mocks.MockconfigSelector) {
m.EXPECT().Application(envListAppNamePrompt, envListAppNameHelper).Return("my-app", nil)
},
wantedApp: "my-app",
},
"with env flags set": {
inputApp: "my-app",
wantedApp: "my-app",
mockSelector: func(m *mocks.MockconfigSelector) {},
},
"error if fail to select app": {
mockSelector: func(m *mocks.MockconfigSelector) {
m.EXPECT().Application(envListAppNamePrompt, envListAppNameHelper).Return("", errors.New("some error"))
},
wantedApp: "my-app",
wantedErr: fmt.Errorf("select application: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSelector := mocks.NewMockconfigSelector(ctrl)
tc.mockSelector(mockSelector)
listEnvs := &listEnvOpts{
listEnvVars: listEnvVars{
appName: tc.inputApp,
},
sel: mockSelector,
}
err := listEnvs.Ask()
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, listEnvs.appName, "expected app names to match")
}
})
}
}
func TestEnvList_Execute(t *testing.T) {
ctrl := gomock.NewController(t)
mockError := fmt.Errorf("error")
mockstore := mocks.NewMockstore(ctrl)
defer ctrl.Finish()
testCases := map[string]struct {
listOpts listEnvOpts
mocking func()
expectedErr error
expectedContent string
}{
"with json envs": {
listOpts: listEnvOpts{
listEnvVars: listEnvVars{
shouldOutputJSON: true,
appName: "coolapp",
},
store: mockstore,
},
mocking: func() {
mockstore.EXPECT().
GetApplication(gomock.Eq("coolapp")).
Return(&config.Application{}, nil)
mockstore.
EXPECT().
ListEnvironments(gomock.Eq("coolapp")).
Return([]*config.Environment{
{Name: "test"},
{Name: "test2"},
}, nil)
},
expectedContent: "{\"environments\":[{\"app\":\"\",\"name\":\"test\",\"region\":\"\",\"accountID\":\"\",\"registryURL\":\"\",\"executionRoleARN\":\"\",\"managerRoleARN\":\"\"},{\"app\":\"\",\"name\":\"test2\",\"region\":\"\",\"accountID\":\"\",\"registryURL\":\"\",\"executionRoleARN\":\"\",\"managerRoleARN\":\"\"}]}\n",
},
"with envs": {
listOpts: listEnvOpts{
listEnvVars: listEnvVars{
appName: "coolapp",
},
store: mockstore,
},
mocking: func() {
mockstore.EXPECT().
GetApplication(gomock.Eq("coolapp")).
Return(&config.Application{}, nil)
mockstore.
EXPECT().
ListEnvironments(gomock.Eq("coolapp")).
Return([]*config.Environment{
{Name: "test"},
{Name: "test2"},
}, nil)
},
expectedContent: "test\ntest2\n",
},
"with invalid app name": {
expectedErr: mockError,
listOpts: listEnvOpts{
listEnvVars: listEnvVars{
appName: "coolapp",
},
store: mockstore,
},
mocking: func() {
mockstore.EXPECT().
GetApplication(gomock.Eq("coolapp")).
Return(nil, mockError)
mockstore.
EXPECT().
ListEnvironments(gomock.Eq("coolapp")).
Times(0)
},
},
"with failed call to list": {
expectedErr: mockError,
listOpts: listEnvOpts{
listEnvVars: listEnvVars{
appName: "coolapp",
},
store: mockstore,
},
mocking: func() {
mockstore.EXPECT().
GetApplication(gomock.Eq("coolapp")).
Return(&config.Application{}, nil)
mockstore.
EXPECT().
ListEnvironments(gomock.Eq("coolapp")).
Return(nil, mockError)
},
},
"with production envs": {
listOpts: listEnvOpts{
listEnvVars: listEnvVars{
appName: "coolapp",
},
store: mockstore,
},
mocking: func() {
mockstore.EXPECT().
GetApplication(gomock.Eq("coolapp")).
Return(&config.Application{}, nil)
mockstore.
EXPECT().
ListEnvironments(gomock.Eq("coolapp")).
Return([]*config.Environment{
{Name: "test"},
{Name: "test2"},
}, nil)
},
expectedContent: "test\ntest2\n",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
b := &bytes.Buffer{}
tc.mocking()
tc.listOpts.w = b
err := tc.listOpts.Execute()
if tc.expectedErr != nil {
require.EqualError(t, tc.expectedErr, err.Error())
} else {
require.Equal(t, tc.expectedContent, b.String())
}
})
}
}
| 204 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
type overrideEnvOpts struct {
*overrideOpts
// Interfaces to interact with dependencies.
ws wsEnvironmentReader
}
func newOverrideEnvOpts(vars overrideVars) (*overrideEnvOpts, error) {
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("env override"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
cfgStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompt := prompt.New()
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
fs: fs,
cfgStore: cfgStore,
prompt: prompt,
cfnPrompt: selector.NewCFNSelector(prompt),
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
},
ws: ws,
}
cmd.overrideOpts.packageCmd = cmd.newEnvPackageCmd
return cmd, nil
}
// Validate returns an error for any invalid optional flags.
func (o *overrideEnvOpts) Validate() error {
if err := o.overrideOpts.Validate(); err != nil {
return err
}
return o.validateName()
}
// Ask prompts for and validates any required flags.
func (o *overrideEnvOpts) Ask() error {
if err := o.assignEnvName(); err != nil {
return err
}
return o.overrideOpts.Ask()
}
// Execute writes IaC override files to the local workspace.
// This method assumes that the IaC tool chosen by the user is valid.
func (o *overrideEnvOpts) Execute() error {
o.overrideOpts.dir = func() string {
return o.ws.EnvOverridesPath()
}
return o.overrideOpts.Execute()
}
func (o *overrideEnvOpts) validateName() error {
if o.name == "" {
return nil
}
names, err := o.ws.ListEnvironments()
if err != nil {
return fmt.Errorf("list environments in the workspace: %v", err)
}
if !contains(o.name, names) {
return fmt.Errorf("environment %q does not exist in the workspace", o.name)
}
return nil
}
func (o *overrideEnvOpts) newEnvPackageCmd(tplBuf stringWriteCloser) (executor, error) {
cmd, err := newPackageEnvOpts(packageEnvVars{
name: o.name,
appName: o.appName,
})
if err != nil {
return nil, err
}
cmd.tplWriter = tplBuf
return cmd, nil
}
// If the user does not explicitly provide an environment, default to a random environment.
func (o *overrideEnvOpts) assignEnvName() error {
if o.name != "" {
return nil
}
envs, err := o.ws.ListEnvironments()
if err != nil {
return fmt.Errorf("list environments in the workspace: %v", err)
}
if len(envs) == 0 {
return errors.New("no environments found in the workspace")
}
o.name = envs[0]
return nil
}
func buildEnvOverrideCmd() *cobra.Command {
vars := overrideVars{}
cmd := &cobra.Command{
Use: "override",
Short: "Override the AWS CloudFormation template of environments.",
Long: `Scaffold Infrastructure as Code (IaC) extension files for environments.
The generated files allow you to extend and override the Copilot-generated AWS CloudFormation template.
You can edit the files to change existing resource properties, delete
or add new resources to an environment's template.`,
Example: `
Create a new Cloud Development Kit application to override environment templates.
/code $ copilot env override --tool cdk`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newOverrideEnvOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", overrideEnvFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.iacTool, iacToolFlag, "", iacToolFlagDescription)
cmd.Flags().StringVar(&vars.cdkLang, cdkLanguageFlag, typescriptCDKLang, cdkLanguageFlagDescription)
cmd.Flags().BoolVar(&vars.skipResources, skipResourcesFlag, false, skipResourcesFlagDescription)
return cmd
}
| 155 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"path/filepath"
"testing"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestOverrideEnv_Validate(t *testing.T) {
t.Run("validate application", func(t *testing.T) {
testCases := map[string]struct {
appName string
initMocks func(ctrl *gomock.Controller, cmd *overrideEnvOpts)
wanted error
}{
"return an error if the workspace has no application associated with": {
wanted: errNoAppInWorkspace,
},
"return a wrapped error if the workspace's application cannot be fetched from the Config Store": {
appName: "demo",
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).Return(nil, errors.New("some error"))
cmd.cfgStore = mockSSM
},
wanted: errors.New(`get application "demo" configuration: some error`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
vars := overrideVars{appName: tc.appName}
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
},
}
if tc.initMocks != nil {
tc.initMocks(ctrl, cmd)
}
// WHEN
err := cmd.Validate()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
t.Run("validate environment name", func(t *testing.T) {
testCases := map[string]struct {
name string
initMocks func(ctrl *gomock.Controller, cmd *overrideEnvOpts)
wanted error
}{
"skip validating if environment name is empty": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).AnyTimes()
cmd.cfgStore = mockSSM
},
},
"return a wrapped error if environment name from workspace cannot be retrieved": {
name: "test",
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).AnyTimes()
mockWS := mocks.NewMockwsEnvironmentReader(ctrl)
mockWS.EXPECT().ListEnvironments().Return(nil, errors.New("some error"))
cmd.cfgStore = mockSSM
cmd.ws = mockWS
},
wanted: errors.New("list environments in the workspace: some error"),
},
"return an error if the environment does not exist in the workspace": {
name: "test",
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).AnyTimes()
mockWS := mocks.NewMockwsEnvironmentReader(ctrl)
mockWS.EXPECT().ListEnvironments().Return([]string{"prod"}, nil)
cmd.cfgStore = mockSSM
cmd.ws = mockWS
},
wanted: errors.New(`environment "test" does not exist in the workspace`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
vars := overrideVars{name: tc.name, appName: "demo", cdkLang: "typescript"}
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
},
}
if tc.initMocks != nil {
tc.initMocks(ctrl, cmd)
}
// WHEN
err := cmd.Validate()
// THEN
if tc.wanted != nil {
require.ErrorContains(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
t.Run("validate CDK language", func(t *testing.T) {
testCases := map[string]struct {
lang string
wanted error
}{
"return an error when an unknown language is selected": {
lang: "python",
wanted: errors.New(`"python" is not a valid CDK language: must be one of: "typescript"`),
},
"typescript is a valid CDK language": {
lang: "typescript",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).Return(nil, nil)
vars := overrideVars{appName: "demo", cdkLang: tc.lang}
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mockSSM,
},
}
// WHEN
err := cmd.Validate()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
}
func TestOverrideEnv_Ask(t *testing.T) {
t.Run("assign environment name", func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ListEnvironments().Return([]string{"test", "prod"}, nil)
vars := overrideVars{name: "", appName: "demo", iacTool: "cdk", skipResources: true}
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mocks.NewMockstore(ctrl),
packageCmd: func(_ stringWriteCloser) (executor, error) {
mockCmd := mocks.NewMockexecutor(ctrl)
mockCmd.EXPECT().Execute().AnyTimes()
return mockCmd, nil
},
},
ws: ws,
}
// WHEN
err := cmd.Ask()
// THEN
require.NoError(t, err)
})
t.Run("ask or validate IaC tool", func(t *testing.T) {
testCases := map[string]struct {
iacTool string
initMocks func(ctrl *gomock.Controller, cmd *overrideEnvOpts)
wanted error
}{
"validation passes if IaC tool is a valid option": {
iacTool: "cdk",
wanted: nil,
},
"return an error if IaC tool flag value is invalid": {
iacTool: "terraform",
wanted: errors.New(`"terraform" is not a valid IaC tool: must be one of: "cdk", "yamlpatch"`),
},
"should ask for IaC tool name if flag is not provided": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockPrompt := mocks.NewMockprompter(ctrl)
mockPrompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), []string{"cdk", "yamlpatch"}, gomock.Any())
cmd.prompt = mockPrompt
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSSM := mocks.NewMockstore(ctrl)
mockCfnPrompt := mocks.NewMockcfnSelector(ctrl)
mockCfnPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
vars := overrideVars{appName: "demo", name: "test", iacTool: tc.iacTool}
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mockSSM,
cfnPrompt: mockCfnPrompt,
packageCmd: func(_ stringWriteCloser) (executor, error) {
mockCmd := mocks.NewMockexecutor(ctrl)
mockCmd.EXPECT().Execute().AnyTimes()
return mockCmd, nil
},
spinner: &spinnerTestDouble{},
},
}
if tc.initMocks != nil {
tc.initMocks(ctrl, cmd)
}
// WHEN
err := cmd.Ask()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
t.Run("ask for which template resources to override", func(t *testing.T) {
testCases := map[string]struct {
skip bool
initMocks func(ctrl *gomock.Controller, cmd *overrideEnvOpts)
wanted error
}{
"should skip prompting for resources if the user opts-in to generating empty files": {
skip: true,
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockPrompt := mocks.NewMockcfnSelector(ctrl)
mockPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
cmd.cfnPrompt = mockPrompt
},
},
"should return an error if package command cannot be initialized": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
cmd.packageCmd = func(_ stringWriteCloser) (executor, error) {
return nil, errors.New("init fail")
}
},
wanted: errors.New("init fail"),
},
"should return a wrapped error if package command fails to execute": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockPkgCmd := mocks.NewMockexecutor(ctrl)
mockPkgCmd.EXPECT().Execute().Return(errors.New("some error"))
cmd.packageCmd = func(_ stringWriteCloser) (executor, error) {
return mockPkgCmd, nil
}
},
wanted: errors.New(`generate CloudFormation template for "test": some error`),
},
"should prompt for CloudFormation resources in a template": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
mockPkgCmd := mocks.NewMockexecutor(ctrl)
mockPkgCmd.EXPECT().Execute().Return(nil)
mockPrompt := mocks.NewMockcfnSelector(ctrl)
template := `
Resources:
VPC:
Type: AWS::EC2::VPC
`
mockPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), template).Return(nil, nil)
cmd.packageCmd = func(w stringWriteCloser) (executor, error) {
_, _ = w.Write([]byte(template))
return mockPkgCmd, nil
}
cmd.cfnPrompt = mockPrompt
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSSM := mocks.NewMockstore(ctrl)
vars := overrideVars{appName: "demo", name: "test", iacTool: "cdk", skipResources: tc.skip}
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mockSSM,
spinner: &spinnerTestDouble{},
},
}
tc.initMocks(ctrl, cmd)
// WHEN
err := cmd.Ask()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
}
func TestOverrideEnv_Execute(t *testing.T) {
t.Run("with the CDK", func(t *testing.T) {
testCases := map[string]struct {
resources []template.CFNResource
initMocks func(ctrl *gomock.Controller, cmd *overrideEnvOpts)
wanted error
}{
"should succeed creating IaC files without any resources": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
fs := afero.NewMemMapFs()
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().EnvOverridesPath().Return(filepath.Join("copilot", "environments", "overrides"))
cmd.ws = ws
cmd.fs = fs
},
},
"should succeed creating IaC files with resources": {
resources: []template.CFNResource{
{
Type: "AWS::EC2::VPC",
LogicalID: "VPC",
},
},
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
fs := afero.NewMemMapFs()
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().EnvOverridesPath().Return(filepath.Join("copilot", "environments", "overrides"))
cmd.ws = ws
cmd.fs = fs
},
},
"should return a wrapped error if override files already exists": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideEnvOpts) {
dir := filepath.Join("copilot", "environments", "overrides")
fs := afero.NewMemMapFs()
_ = fs.MkdirAll(dir, 0755)
_ = afero.WriteFile(fs, filepath.Join(dir, "cdk.json"), []byte("content"), 0755)
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().EnvOverridesPath().Return(dir)
cmd.ws = ws
cmd.fs = fs
},
wanted: fmt.Errorf("scaffold CDK application under %q", filepath.Join("copilot", "environments", "overrides")),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
vars := overrideVars{appName: "demo", name: "test", iacTool: "cdk", resources: tc.resources}
cmd := &overrideEnvOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
},
}
tc.initMocks(ctrl, cmd)
// WHEN
err := cmd.Execute()
// THEN
if tc.wanted != nil {
require.ErrorContains(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
}
| 426 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"os"
"path/filepath"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/spf13/cobra"
)
const (
envCFNTemplateNameFmt = "%s.env.yml"
envCFNTemplateConfigurationNameFmt = "%s.env.params.json"
envAddonsCFNTemplateName = "env.addons.yml"
)
type packageEnvVars struct {
name string
appName string
outputDir string
uploadAssets bool
forceNewUpdate bool
showDiff bool
allowEnvDowngrade bool
}
type discardFile struct{}
func (df discardFile) Write(p []byte) (n int, err error) {
return io.Discard.Write(p)
}
func (df discardFile) Close() error {
return nil // noop
}
type packageEnvOpts struct {
packageEnvVars
// Dependencies.
cfgStore store
ws wsEnvironmentReader
sel wsEnvironmentSelector
caller identityService
fs afero.Fs
tplWriter io.WriteCloser
paramsWriter io.WriteCloser
addonsWriter io.WriteCloser
diffWriter io.Writer
newInterpolator func(appName, name string) interpolator
newEnvVersionGetter func(appName, name string) (versionGetter, error)
newEnvPackager func() (envPackager, error)
// Cached variables.
appCfg *config.Application
envCfg *config.Environment
// Overridden in tests.
templateVersion string
}
func newPackageEnvOpts(vars packageEnvVars) (*packageEnvOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("env package"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
cfgStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
opts := &packageEnvOpts{
packageEnvVars: vars,
cfgStore: cfgStore,
ws: ws,
sel: selector.NewLocalEnvironmentSelector(prompt.New(), cfgStore, ws),
caller: identity.New(defaultSess),
fs: fs,
tplWriter: os.Stdout,
paramsWriter: discardFile{},
addonsWriter: discardFile{},
diffWriter: os.Stdout,
templateVersion: version.LatestTemplateVersion(),
newEnvVersionGetter: func(appName, name string) (versionGetter, error) {
return describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: name,
ConfigStore: cfgStore,
})
},
newInterpolator: func(appName, name string) interpolator {
return manifest.NewInterpolator(appName, name)
},
}
opts.newEnvPackager = func() (envPackager, error) {
appCfg, err := opts.getAppCfg()
if err != nil {
return nil, err
}
envCfg, err := opts.getEnvCfg()
if err != nil {
return nil, err
}
ovrdr, err := deploy.NewOverrider(ws.EnvOverridesPath(), envCfg.App, envCfg.Name, fs, sessProvider)
if err != nil {
return nil, err
}
return deploy.NewEnvDeployer(&deploy.NewEnvDeployerInput{
App: appCfg,
Env: envCfg,
SessionProvider: sessProvider,
ConfigStore: opts.cfgStore,
Workspace: ws,
Overrider: ovrdr,
})
}
return opts, nil
}
// Validate returns an error for any invalid optional flags.
func (o *packageEnvOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *packageEnvOpts) Ask() error {
if o.appName == "" {
// This command is required to be executed under a workspace. We don't prompt for it.
return errNoAppInWorkspace
}
if _, err := o.getAppCfg(); err != nil {
return err
}
return o.validateOrAskName()
}
// Execute prints the CloudFormation configuration for the environment.
func (o *packageEnvOpts) Execute() error {
if !o.allowEnvDowngrade {
envVersionGetter, err := o.newEnvVersionGetter(o.appName, o.name)
if err != nil {
return err
}
if err := validateEnvVersion(envVersionGetter, o.name, o.templateVersion); err != nil {
return err
}
}
rawMft, err := o.ws.ReadEnvironmentManifest(o.name)
if err != nil {
return fmt.Errorf("read manifest for environment %q: %w", o.name, err)
}
mft, err := environmentManifest(o.name, rawMft, o.newInterpolator(o.appName, o.name))
if err != nil {
return err
}
principal, err := o.caller.Get()
if err != nil {
return fmt.Errorf("get caller principal identity: %v", err)
}
packager, err := o.newEnvPackager()
if err != nil {
return err
}
if err := packager.Validate(mft); err != nil {
return err
}
var uploadArtifactsOut deploy.UploadEnvArtifactsOutput
if o.uploadAssets {
out, err := packager.UploadArtifacts()
if err != nil {
return fmt.Errorf("upload assets for environment %q: %v", o.name, err)
}
uploadArtifactsOut = *out
}
res, err := packager.GenerateCloudFormationTemplate(&deploy.DeployEnvironmentInput{
RootUserARN: principal.RootUserARN,
AddonsURL: uploadArtifactsOut.AddonsURL,
CustomResourcesURLs: uploadArtifactsOut.CustomResourceURLs,
Manifest: mft,
RawManifest: rawMft,
PermissionsBoundary: o.appCfg.PermissionsBoundary,
ForceNewUpdate: o.forceNewUpdate,
Version: o.templateVersion,
})
if err != nil {
return fmt.Errorf("generate CloudFormation template from environment %q manifest: %v", o.name, err)
}
if o.showDiff {
if err := diff(packager, res.Template, o.diffWriter); err != nil {
var errHasDiff *errHasDiff
if errors.As(err, &errHasDiff) {
return err
}
return &errDiffNotAvailable{
parentErr: err,
}
}
}
addonsTemplate, err := packager.AddonsTemplate()
if err != nil {
return fmt.Errorf("retrieve environment addons template: %w", err)
}
if err := o.setWriters(); err != nil {
return err
}
if err := o.writeAndClose(o.tplWriter, res.Template); err != nil {
return err
}
if err := o.writeAndClose(o.paramsWriter, res.Parameters); err != nil {
return err
}
if addonsTemplate == "" {
return nil
}
if err := o.setAddonsWriter(); err != nil {
return err
}
return o.writeAndClose(o.addonsWriter, addonsTemplate)
}
func (o *packageEnvOpts) getAppCfg() (*config.Application, error) {
if o.appCfg != nil {
return o.appCfg, nil
}
cfg, err := o.cfgStore.GetApplication(o.appName)
if err != nil {
return nil, fmt.Errorf("get application %q configuration: %w", o.appName, err)
}
o.appCfg = cfg
return o.appCfg, nil
}
func (o *packageEnvOpts) getEnvCfg() (*config.Environment, error) {
if o.envCfg != nil {
return o.envCfg, nil
}
cfg, err := o.cfgStore.GetEnvironment(o.appName, o.name)
if err != nil {
return nil, fmt.Errorf("get environment %q in application %q: %w", o.name, o.appName, err)
}
o.envCfg = cfg
return o.envCfg, nil
}
func (o *packageEnvOpts) validateOrAskName() error {
if o.name != "" {
if _, err := o.getEnvCfg(); err != nil {
log.Errorf("It seems like environment %s is not added in application %s yet. Have you run %s?\n",
o.name, o.appName, color.HighlightCode("copilot env init"))
return err
}
return nil
}
name, err := o.sel.LocalEnvironment("Select an environment manifest from your workspace", "")
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
o.name = name
return nil
}
func (o *packageEnvOpts) setWriters() error {
if o.outputDir == "" {
return nil
}
if err := o.fs.MkdirAll(o.outputDir, 0755); err != nil {
return fmt.Errorf("create directory %q: %w", o.outputDir, err)
}
path := filepath.Join(o.outputDir, fmt.Sprintf(envCFNTemplateNameFmt, o.name))
tplFile, err := o.fs.Create(path)
if err != nil {
return fmt.Errorf("create file at %q: %w", path, err)
}
path = filepath.Join(o.outputDir, fmt.Sprintf(envCFNTemplateConfigurationNameFmt, o.name))
paramsFile, err := o.fs.Create(path)
if err != nil {
return fmt.Errorf("create file at %q: %w", path, err)
}
o.tplWriter = tplFile
o.paramsWriter = paramsFile
return nil
}
func (o *packageEnvOpts) setAddonsWriter() error {
if o.outputDir == "" {
return nil
}
addonsPath := filepath.Join(o.outputDir, envAddonsCFNTemplateName)
addonsFile, err := o.fs.Create(addonsPath)
if err != nil {
return fmt.Errorf("create file %s: %w", addonsPath, err)
}
o.addonsWriter = addonsFile
return nil
}
func (o *packageEnvOpts) writeAndClose(wc io.WriteCloser, dat string) error {
if _, err := wc.Write([]byte(dat)); err != nil {
return err
}
return wc.Close()
}
// buildEnvPkgCmd builds the command for printing an environment CloudFormation stack configuration.
func buildEnvPkgCmd() *cobra.Command {
vars := packageEnvVars{}
cmd := &cobra.Command{
Use: "package",
Short: "Print the AWS CloudFormation template of an environment.",
Long: `Print the CloudFormation stack template and configuration used to deploy an environment.`,
Example: `
Print the CloudFormation template for the "prod" environment.
/code $ copilot env package -n prod --upload-assets
Write the CloudFormation template and configuration to a "infrastructure/" sub-directory instead of stdout.
/startcodeblock
$ copilot env package -n test --output-dir ./infrastructure --upload-assets
$ ls ./infrastructure
test.env.yml test.env.params.json
/endcodeblock`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newPackageEnvOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.outputDir, stackOutputDirFlag, "", stackOutputDirFlagDescription)
cmd.Flags().BoolVar(&vars.uploadAssets, uploadAssetsFlag, false, uploadAssetsFlagDescription)
cmd.Flags().BoolVar(&vars.forceNewUpdate, forceFlag, false, forceEnvDeployFlagDescription)
cmd.Flags().BoolVar(&vars.showDiff, diffFlag, false, diffFlagDescription)
cmd.Flags().BoolVar(&vars.allowEnvDowngrade, allowDowngradeFlag, false, allowDowngradeFlagDescription)
cmd.MarkFlagsMutuallyExclusive(diffFlag, stackOutputDirFlag)
cmd.MarkFlagsMutuallyExclusive(diffFlag, uploadAssetsFlag)
return cmd
}
| 376 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"strings"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
)
func TestPackageEnvOpts_Ask(t *testing.T) {
testCases := map[string]struct {
in packageEnvVars
mockedCmd func(ctrl *gomock.Controller, vars packageEnvVars) *packageEnvOpts
wanted error
}{
"should return errNoAppInWorkspace if app name is empty": {
mockedCmd: func(ctrl *gomock.Controller, vars packageEnvVars) *packageEnvOpts {
return &packageEnvOpts{
packageEnvVars: vars,
}
},
wanted: errNoAppInWorkspace,
},
"should return a wrapped error if application name cannot be retrieved": {
in: packageEnvVars{
appName: "phonetool",
},
mockedCmd: func(ctrl *gomock.Controller, vars packageEnvVars) *packageEnvOpts {
cfgStore := mocks.NewMockstore(ctrl)
cfgStore.EXPECT().GetApplication(gomock.Any()).Return(nil, errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: vars,
cfgStore: cfgStore,
}
},
wanted: errors.New(`get application "phonetool" configuration: some error`),
},
"should return a wrapped error if environment name doesn't exist in SSM": {
in: packageEnvVars{
appName: "phonetool",
name: "test",
},
mockedCmd: func(ctrl *gomock.Controller, vars packageEnvVars) *packageEnvOpts {
cfgStore := mocks.NewMockstore(ctrl)
cfgStore.EXPECT().GetApplication(gomock.Any()).Return(&config.Application{}, nil)
cfgStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Return(nil, errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: vars,
cfgStore: cfgStore,
}
},
wanted: errors.New(`get environment "test" in application "phonetool": some error`),
},
"should return a wrapped error if environment cannot be selected from workspace": {
in: packageEnvVars{
appName: "phonetool",
},
mockedCmd: func(ctrl *gomock.Controller, vars packageEnvVars) *packageEnvOpts {
cfgStore := mocks.NewMockstore(ctrl)
cfgStore.EXPECT().GetApplication(gomock.Any()).Return(&config.Application{}, nil)
sel := mocks.NewMockwsEnvironmentSelector(ctrl)
sel.EXPECT().LocalEnvironment(gomock.Any(), gomock.Any()).Return("", errors.New("no environments found"))
return &packageEnvOpts{
packageEnvVars: vars,
cfgStore: cfgStore,
sel: sel,
}
},
wanted: errors.New(`select environment: no environments found`),
},
"should return nil if environment name was asked successfully": {
in: packageEnvVars{
appName: "phonetool",
},
mockedCmd: func(ctrl *gomock.Controller, vars packageEnvVars) *packageEnvOpts {
cfgStore := mocks.NewMockstore(ctrl)
cfgStore.EXPECT().GetApplication(vars.appName).Return(&config.Application{}, nil)
sel := mocks.NewMockwsEnvironmentSelector(ctrl)
sel.EXPECT().LocalEnvironment("Select an environment manifest from your workspace", "").Return("test", nil)
return &packageEnvOpts{
packageEnvVars: vars,
cfgStore: cfgStore,
sel: sel,
}
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
cmd := tc.mockedCmd(ctrl, tc.in)
// WHEN
actual := cmd.Ask()
// THEN
if tc.wanted == nil {
require.NoError(t, actual)
} else {
require.EqualError(t, actual, tc.wanted.Error())
}
})
}
}
func TestPackageEnvOpts_Execute(t *testing.T) {
testCases := map[string]struct {
mockedCmd func(controller *gomock.Controller) *packageEnvOpts
wantedDiff string
wantedFS func(t *testing.T, fs afero.Fs)
wantedErr error
}{
"should return a wrapped error when reading env manifest fails": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return(nil, errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
},
ws: ws,
newInterpolator: func(_, _ string) interpolator {
return nil
},
envCfg: &config.Environment{Name: "test"},
}
},
wantedErr: errors.New(`read manifest for environment "test": some error`),
},
"should return a wrapped error when manifest interpolation fails": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("hi"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("", errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
},
ws: ws,
newInterpolator: func(_, _ string) interpolator {
return interop
},
envCfg: &config.Environment{Name: "test"},
}
},
wantedErr: errors.New(`interpolate environment variables for "test" manifest: some error`),
},
"should return a wrapped error when STS call fails": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
envCfg: &config.Environment{Name: "test"},
}
},
wantedErr: errors.New(`get caller principal identity: some error`),
},
"should return a wrapped error when fails to verify env": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(errors.New("mock error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
envCfg: &config.Environment{Name: "test"},
}
},
wantedErr: errors.New(`mock error`),
},
"should return a wrapped error when uploading assets fails": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(nil)
deployer.EXPECT().UploadArtifacts().Return(nil, errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
uploadAssets: true,
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
envCfg: &config.Environment{Name: "test"},
}
},
wantedErr: errors.New(`upload assets for environment "test": some error`),
},
"should return a wrapped error when generating CloudFormation templates fails": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(nil)
deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(nil, errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
envCfg: &config.Environment{Name: "test"},
appCfg: &config.Application{},
}
},
wantedErr: errors.New(`generate CloudFormation template from environment "test" manifest: some error`),
},
"should return an error if fail to get the diff": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(nil)
deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
deployer.EXPECT().DeployDiff(gomock.Any()).Return("", errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
showDiff: true,
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
envCfg: &config.Environment{Name: "test"},
appCfg: &config.Application{},
diffWriter: &strings.Builder{},
}
},
wantedErr: errors.New("some error"),
},
"should return a wrapped error when retrieving addons CloudFormation template fails": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
packager := mocks.NewMockenvPackager(ctrl)
packager.EXPECT().Validate(gomock.Any()).Return(nil)
packager.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{
Template: "template",
Parameters: "parameters",
}, nil)
packager.EXPECT().AddonsTemplate().Return("", errors.New("some error"))
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return packager, nil
},
envCfg: &config.Environment{Name: "test"},
appCfg: &config.Application{},
}
},
wantedErr: errors.New(`retrieve environment addons template: some error`),
},
"should generate templates with artifact URLs": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest("test").Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate("name: test\ntype: Environment\n").Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(nil)
deployer.EXPECT().UploadArtifacts().Return(&deploy.UploadEnvArtifactsOutput{
AddonsURL: "mockAddonsURL",
CustomResourceURLs: map[string]string{
"mockCustomResource": "mockURL",
},
}, nil)
deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).DoAndReturn(func(in *deploy.DeployEnvironmentInput) (*deploy.GenerateCloudFormationTemplateOutput, error) {
require.Equal(t, in.AddonsURL, "mockAddonsURL")
require.Equal(t, in.CustomResourcesURLs, map[string]string{
"mockCustomResource": "mockURL",
})
return &deploy.GenerateCloudFormationTemplateOutput{
Template: "template",
Parameters: "parameters",
}, nil
})
deployer.EXPECT().AddonsTemplate().Return("", nil)
fs := afero.NewMemMapFs()
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
uploadAssets: true,
},
ws: ws,
caller: caller,
tplWriter: discardFile{},
paramsWriter: discardFile{},
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
fs: fs,
envCfg: &config.Environment{Name: "test"},
appCfg: &config.Application{
PermissionsBoundary: "mockPermissionsBoundaryPolicy",
},
}
},
wantedFS: func(_ *testing.T, _ afero.Fs) {},
},
"should write the diff": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest(gomock.Any()).Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate(gomock.Any()).Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(nil)
deployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
deployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
showDiff: true,
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
envCfg: &config.Environment{Name: "test"},
appCfg: &config.Application{},
diffWriter: &strings.Builder{},
}
},
wantedDiff: "mock diff",
wantedErr: &errHasDiff{},
},
"should write files to output directories without addons": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest("test").Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate("name: test\ntype: Environment\n").Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(nil)
deployer.EXPECT().GenerateCloudFormationTemplate(&deploy.DeployEnvironmentInput{
RootUserARN: "",
CustomResourcesURLs: nil,
Manifest: &manifest.Environment{
Workload: manifest.Workload{
Name: aws.String("test"),
Type: aws.String("Environment"),
},
EnvironmentConfig: manifest.EnvironmentConfig{},
},
ForceNewUpdate: false,
RawManifest: []byte("name: test\ntype: Environment\n"),
PermissionsBoundary: "mockPermissionsBoundaryPolicy",
}).Return(&deploy.GenerateCloudFormationTemplateOutput{
Template: "template",
Parameters: "parameters",
}, nil)
deployer.EXPECT().AddonsTemplate().Return("", nil)
fs := afero.NewMemMapFs()
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
outputDir: "infrastructure",
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
fs: fs,
envCfg: &config.Environment{Name: "test"},
appCfg: &config.Application{
PermissionsBoundary: "mockPermissionsBoundaryPolicy",
},
}
},
wantedFS: func(t *testing.T, fs afero.Fs) {
f, err := fs.Open("infrastructure/test.env.yml")
require.NoError(t, err)
actual, err := io.ReadAll(f)
require.NoError(t, err)
require.Equal(t, []byte("template"), actual)
f, err = fs.Open("infrastructure/test.env.params.json")
require.NoError(t, err)
actual, err = io.ReadAll(f)
require.NoError(t, err)
require.Equal(t, []byte("parameters"), actual)
_, err = fs.Open(fmt.Sprintf("infrastructure/%s", envAddonsCFNTemplateName))
require.EqualError(t, err, fmt.Errorf("open infrastructure/%s: file does not exist", envAddonsCFNTemplateName).Error())
},
},
"should write files to output directories with addons": {
mockedCmd: func(ctrl *gomock.Controller) *packageEnvOpts {
ws := mocks.NewMockwsEnvironmentReader(ctrl)
ws.EXPECT().ReadEnvironmentManifest("test").Return([]byte("name: test\ntype: Environment\n"), nil)
interop := mocks.NewMockinterpolator(ctrl)
interop.EXPECT().Interpolate("name: test\ntype: Environment\n").Return("name: test\ntype: Environment\n", nil)
caller := mocks.NewMockidentityService(ctrl)
caller.EXPECT().Get().Return(identity.Caller{}, nil)
deployer := mocks.NewMockenvPackager(ctrl)
deployer.EXPECT().Validate(gomock.Any()).Return(nil)
deployer.EXPECT().GenerateCloudFormationTemplate(&deploy.DeployEnvironmentInput{
RootUserARN: "",
CustomResourcesURLs: nil,
Manifest: &manifest.Environment{
Workload: manifest.Workload{
Name: aws.String("test"),
Type: aws.String("Environment"),
},
EnvironmentConfig: manifest.EnvironmentConfig{},
},
ForceNewUpdate: false,
RawManifest: []byte("name: test\ntype: Environment\n"),
PermissionsBoundary: "mockPermissionsBoundaryPolicy",
}).Return(&deploy.GenerateCloudFormationTemplateOutput{
Template: "template",
Parameters: "parameters",
}, nil)
deployer.EXPECT().AddonsTemplate().Return("addons", nil)
fs := afero.NewMemMapFs()
return &packageEnvOpts{
packageEnvVars: packageEnvVars{
name: "test",
outputDir: "infrastructure",
},
ws: ws,
caller: caller,
newInterpolator: func(_, _ string) interpolator {
return interop
},
newEnvPackager: func() (envPackager, error) {
return deployer, nil
},
fs: fs,
envCfg: &config.Environment{Name: "test"},
appCfg: &config.Application{
PermissionsBoundary: "mockPermissionsBoundaryPolicy",
},
}
},
wantedFS: func(t *testing.T, fs afero.Fs) {
f, err := fs.Open("infrastructure/test.env.yml")
require.NoError(t, err)
actual, err := io.ReadAll(f)
require.NoError(t, err)
require.Equal(t, []byte("template"), actual)
f, err = fs.Open("infrastructure/test.env.params.json")
require.NoError(t, err)
actual, err = io.ReadAll(f)
require.NoError(t, err)
require.Equal(t, []byte("parameters"), actual)
f, err = fs.Open("infrastructure/env.addons.yml")
require.NoError(t, err)
actual, err = io.ReadAll(f)
require.NoError(t, err)
require.Equal(t, []byte("addons"), actual)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
cmd := tc.mockedCmd(ctrl)
cmd.allowEnvDowngrade = true // downgrade logic is tested in env deploy
// WHEN
actual := cmd.Execute()
// THEN
if tc.wantedErr == nil {
require.NoError(t, actual)
} else {
require.EqualError(t, actual, tc.wantedErr.Error())
}
if tc.wantedFS != nil {
tc.wantedFS(t, cmd.fs)
}
if tc.wantedDiff != "" {
require.Equal(t, tc.wantedDiff, cmd.diffWriter.(*strings.Builder).String())
}
})
}
}
| 607 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"io"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
envShowAppNamePrompt = "Which application is the environment in?"
envShowAppNameHelpPrompt = "An application is a collection of related services."
envShowNamePrompt = "Which environment of %s would you like to show?"
envShowHelpPrompt = "The detail of an environment will be shown (e.g., region, account ID, services)."
)
type showEnvVars struct {
appName string
name string
shouldOutputJSON bool
shouldOutputResources bool
shouldOutputManifest bool
}
type showEnvOpts struct {
showEnvVars
w io.Writer
store store
describer envDescriber
sel configSelector
initEnvDescriber func() error
}
func newShowEnvOpts(vars showEnvVars) (*showEnvOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("env show"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, store)
if err != nil {
return nil, fmt.Errorf("connect to copilot deploy store: %w", err)
}
opts := &showEnvOpts{
showEnvVars: vars,
store: store,
w: log.OutputWriter,
sel: selector.NewConfigSelector(prompt.New(), store),
}
opts.initEnvDescriber = func() error {
d, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: opts.appName,
Env: opts.name,
ConfigStore: store,
DeployStore: deployStore,
EnableResources: opts.shouldOutputResources,
})
if err != nil {
return fmt.Errorf("creating describer for environment %s in application %s: %w", opts.name, opts.appName, err)
}
opts.describer = d
return nil
}
return opts, nil
}
// Validate returns an error if any optional flags are invalid.
func (o *showEnvOpts) Validate() error {
return nil
}
// Ask validates required fields that users passed in, otherwise it prompts for them.
func (o *showEnvOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
return o.validateOrAskEnv()
}
// Execute shows the environments through the prompt.
func (o *showEnvOpts) Execute() error {
if err := o.initEnvDescriber(); err != nil {
return err
}
if o.shouldOutputManifest {
return o.writeManifest()
}
env, err := o.describer.Describe()
if err != nil {
return fmt.Errorf("describe environment %s: %w", o.name, err)
}
content := env.HumanString()
if o.shouldOutputJSON {
data, err := env.JSONString()
if err != nil {
return err
}
content = data
}
fmt.Fprint(o.w, content)
return nil
}
func (o *showEnvOpts) validateOrAskApp() error {
if o.appName != "" {
return o.validateApp()
}
app, err := o.sel.Application(envShowAppNamePrompt, envShowAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *showEnvOpts) validateApp() error {
if _, err := o.store.GetApplication(o.appName); err != nil {
return fmt.Errorf("validate application name %q: %v", o.appName, err)
}
return nil
}
func (o *showEnvOpts) validateOrAskEnv() error {
if o.name != "" {
return o.validateEnv()
}
env, err := o.sel.Environment(fmt.Sprintf(envShowNamePrompt, color.HighlightUserInput(o.appName)), envShowHelpPrompt, o.appName)
if err != nil {
return fmt.Errorf("select environment for application %s: %w", o.appName, err)
}
o.name = env
return nil
}
func (o *showEnvOpts) validateEnv() error {
if _, err := o.store.GetEnvironment(o.appName, o.name); err != nil {
return fmt.Errorf("validate environment name %q in application %q: %v", o.name, o.appName, err)
}
return nil
}
func (o *showEnvOpts) writeManifest() error {
out, err := o.describer.Manifest()
if err != nil {
return fmt.Errorf("fetch manifest for environment %s: %v", o.name, err)
}
fmt.Fprintln(o.w, string(out))
return nil
}
// buildEnvShowCmd builds the command for showing environments in an application.
func buildEnvShowCmd() *cobra.Command {
vars := showEnvVars{}
cmd := &cobra.Command{
Use: "show",
Short: "Shows info about a deployed environment.",
Long: "Shows info about a deployed environment, including region, account ID, and services.",
Example: `
Print configuration for the "test" environment.
/code $ copilot env show -n test
Print manifest file for deploying the "prod" environment.
/code $ copilot env show -n prod --manifest`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newShowEnvOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", envFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputResources, resourcesFlag, false, envResourcesFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputManifest, manifestFlag, false, manifestFlagDescription)
cmd.MarkFlagsMutuallyExclusive(jsonFlag, manifestFlag)
cmd.MarkFlagsMutuallyExclusive(resourcesFlag, manifestFlag)
return cmd
}
| 202 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/describe/stack"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type showEnvMocks struct {
storeSvc *mocks.Mockstore
describer *mocks.MockenvDescriber
sel *mocks.MockconfigSelector
}
func TestEnvShow_Ask(t *testing.T) {
mockErr := errors.New("some error")
testCases := map[string]struct {
inputApp string
inputEnv string
setupMocks func(mocks showEnvMocks)
wantedApp string
wantedEnv string
wantedError error
}{
"ensure resources are registered in SSM if users passes flags": {
inputApp: "my-app",
inputEnv: "my-env",
setupMocks: func(m showEnvMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(nil, nil)
m.storeSvc.EXPECT().GetEnvironment("my-app", "my-env").Return(nil, nil)
},
wantedApp: "my-app",
wantedEnv: "my-env",
},
"should wrap error if validation of app name fails": {
inputApp: "my-app",
setupMocks: func(m showEnvMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(nil, mockErr)
},
wantedError: errors.New(`validate application name "my-app": some error`),
},
"should wrap error if validation of env name fails": {
inputApp: "my-app",
inputEnv: "my-env",
setupMocks: func(m showEnvMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(nil, nil)
m.storeSvc.EXPECT().GetEnvironment("my-app", "my-env").Return(nil, mockErr)
},
wantedError: errors.New(`validate environment name "my-env" in application "my-app": some error`),
},
"returns error when fail to select app": {
inputApp: "",
inputEnv: "",
setupMocks: func(m showEnvMocks) {
m.sel.EXPECT().Application(envShowAppNamePrompt, envShowAppNameHelpPrompt).Return("", mockErr)
},
wantedError: fmt.Errorf("select application: some error"),
},
"returns error when fail to select environment": {
inputApp: "my-app",
inputEnv: "",
setupMocks: func(m showEnvMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(nil, nil)
m.sel.EXPECT().Environment(fmt.Sprintf(envShowNamePrompt, color.HighlightUserInput("my-app")), envShowHelpPrompt, "my-app").Return("", mockErr)
},
wantedError: fmt.Errorf("select environment for application my-app: some error"),
},
"success with no flag set": {
inputApp: "",
inputEnv: "",
setupMocks: func(m showEnvMocks) {
gomock.InOrder(
m.sel.EXPECT().Application(envShowAppNamePrompt, envShowAppNameHelpPrompt).Return("my-app", nil),
m.sel.EXPECT().Environment(fmt.Sprintf(envShowNamePrompt, color.HighlightUserInput("my-app")), envShowHelpPrompt, "my-app").Return("my-env", nil),
)
},
wantedApp: "my-app",
wantedEnv: "my-env",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSelector := mocks.NewMockconfigSelector(ctrl)
mockStore := mocks.NewMockstore(ctrl)
mocks := showEnvMocks{
sel: mockSelector,
storeSvc: mockStore,
}
tc.setupMocks(mocks)
showEnvs := &showEnvOpts{
showEnvVars: showEnvVars{
name: tc.inputEnv,
appName: tc.inputApp,
},
sel: mockSelector,
store: mockStore,
}
// WHEN
err := showEnvs.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, showEnvs.appName, "expected app name to match")
require.Equal(t, tc.wantedEnv, showEnvs.name, "expected environment name to match")
}
})
}
}
func TestEnvShow_Execute(t *testing.T) {
mockError := errors.New("some error")
mockEnvDescription := describe.EnvDescription{
Environment: &config.Environment{
App: "testApp",
Name: "testEnv",
Region: "us-west-2",
AccountID: "123456789012",
RegistryURL: "",
ExecutionRoleARN: "",
ManagerRoleARN: "",
},
Services: []*config.Workload{
{
App: "testApp",
Name: "testSvc1",
Type: "load-balanced",
}, {
App: "testApp",
Name: "testSvc2",
Type: "load-balanced",
}, {
App: "testApp",
Name: "testSvc3",
Type: "load-balanced",
}},
Jobs: []*config.Workload{{
App: "testApp",
Name: "testJob1",
Type: "Scheduled Job",
}, {
App: "testApp",
Name: "testJob2",
Type: "Scheduled Job",
}},
Tags: map[string]string{"copilot-application": "testApp", "copilot-environment": "testEnv", "key1": "value1", "key2": "value2"},
Resources: []*stack.Resource{
{
Type: "AWS::IAM::Role",
PhysicalID: "testApp-testEnv-CFNExecutionRole",
},
{
Type: "testApp-testEnv-Cluster",
PhysicalID: "AWS::ECS::Cluster-jI63pYBWU6BZ",
},
},
}
testCases := map[string]struct {
inputEnv string
shouldOutputJSON bool
shouldOutputManifest bool
setupMocks func(mocks showEnvMocks)
wantedContent string
wantedError error
}{
"return error if fail to describe the env": {
inputEnv: "testEnv",
setupMocks: func(m showEnvMocks) {
m.describer.EXPECT().Describe().Return(nil, mockError)
},
wantedError: fmt.Errorf("describe environment testEnv: some error"),
},
"return error if fail to generate JSON output": {
inputEnv: "testEnv",
shouldOutputJSON: true,
setupMocks: func(m showEnvMocks) {
m.describer.EXPECT().Describe().Return(&mockEnvDescription, mockError)
},
wantedError: fmt.Errorf("describe environment testEnv: some error"),
},
"should print human format": {
inputEnv: "testEnv",
setupMocks: func(m showEnvMocks) {
m.describer.EXPECT().Describe().Return(&mockEnvDescription, nil)
},
wantedContent: `About
Name testEnv
Region us-west-2
Account ID 123456789012
Workloads
Name Type
---- ----
testSvc1 load-balanced
testSvc2 load-balanced
testSvc3 load-balanced
testJob1 Scheduled Job
testJob2 Scheduled Job
Tags
Key Value
--- -----
copilot-application testApp
copilot-environment testEnv
key1 value1
key2 value2
Resources
AWS::IAM::Role testApp-testEnv-CFNExecutionRole
testApp-testEnv-Cluster AWS::ECS::Cluster-jI63pYBWU6BZ
`,
},
"should print JSON format": {
inputEnv: "testEnv",
shouldOutputJSON: true,
setupMocks: func(m showEnvMocks) {
m.describer.EXPECT().Describe().Return(&mockEnvDescription, nil)
},
wantedContent: "{\"environment\":{\"app\":\"testApp\",\"name\":\"testEnv\",\"region\":\"us-west-2\",\"accountID\":\"123456789012\",\"registryURL\":\"\",\"executionRoleARN\":\"\",\"managerRoleARN\":\"\"},\"services\":[{\"app\":\"testApp\",\"name\":\"testSvc1\",\"type\":\"load-balanced\"},{\"app\":\"testApp\",\"name\":\"testSvc2\",\"type\":\"load-balanced\"},{\"app\":\"testApp\",\"name\":\"testSvc3\",\"type\":\"load-balanced\"}],\"jobs\":[{\"app\":\"testApp\",\"name\":\"testJob1\",\"type\":\"Scheduled Job\"},{\"app\":\"testApp\",\"name\":\"testJob2\",\"type\":\"Scheduled Job\"}],\"tags\":{\"copilot-application\":\"testApp\",\"copilot-environment\":\"testEnv\",\"key1\":\"value1\",\"key2\":\"value2\"},\"resources\":[{\"type\":\"AWS::IAM::Role\",\"physicalID\":\"testApp-testEnv-CFNExecutionRole\"},{\"type\":\"testApp-testEnv-Cluster\",\"physicalID\":\"AWS::ECS::Cluster-jI63pYBWU6BZ\"}],\"environmentVPC\":{\"id\":\"\",\"publicSubnetIDs\":null,\"privateSubnetIDs\":null}}\n",
},
"should print manifest file": {
inputEnv: "testEnv",
shouldOutputManifest: true,
setupMocks: func(m showEnvMocks) {
m.describer.EXPECT().Manifest().Return([]byte("hello"), nil)
},
wantedContent: "hello\n",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
b := &bytes.Buffer{}
mockStoreReader := mocks.NewMockstore(ctrl)
mockEnvDescriber := mocks.NewMockenvDescriber(ctrl)
mocks := showEnvMocks{
describer: mockEnvDescriber,
}
tc.setupMocks(mocks)
showEnvs := &showEnvOpts{
showEnvVars: showEnvVars{
name: tc.inputEnv,
shouldOutputJSON: tc.shouldOutputJSON,
shouldOutputManifest: tc.shouldOutputManifest,
},
store: mockStoreReader,
describer: mockEnvDescriber,
initEnvDescriber: func() error { return nil },
w: b,
}
// WHEN
err := showEnvs.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedContent, b.String(), "expected output content match")
}
})
}
}
| 317 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"github.com/spf13/cobra"
)
// Deprecated. Clients should use "env deploy" instead after copilot v1.20.0.
// buildEnvUpgradeCmd builds the command to update environment(s) to the latest version of
// the environment template.
func buildEnvUpgradeCmd() *cobra.Command {
var envName, appName string
var all bool
cmd := &cobra.Command{
Use: "upgrade",
Short: "Deprecated. Upgrades the template of an environment to the latest version.",
Long: `Deprecated. Use "copilot env deploy" instead.
This command is now a no op. Upgrades the template of an environment stack to the latest version.
`,
Hidden: true,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
return nil
}),
}
cmd.Flags().StringVarP(&envName, nameFlag, nameFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&all, allFlag, false, upgradeAllEnvsDescription)
return cmd
}
| 32 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"github.com/aws/copilot-cli/internal/pkg/term/color"
)
type errCannotDowngradeEnvVersion struct {
envName string
envVersion string
templateVersion string
}
func (e *errCannotDowngradeEnvVersion) init() *errCannotDowngradeVersion {
return &errCannotDowngradeVersion{
componentName: e.envName,
componentType: "environment",
currentVersion: e.envVersion,
latestTemplateVersion: e.templateVersion,
}
}
func (e *errCannotDowngradeEnvVersion) Error() string {
return e.init().Error()
}
func (e *errCannotDowngradeEnvVersion) RecommendActions() string {
return e.init().RecommendActions()
}
type errCannotDowngradeAppVersion struct {
appName string
appVersion string
templateVersion string
}
func (e *errCannotDowngradeAppVersion) init() *errCannotDowngradeVersion {
return &errCannotDowngradeVersion{
componentName: e.appName,
componentType: "application",
currentVersion: e.appVersion,
latestTemplateVersion: e.templateVersion,
}
}
func (e *errCannotDowngradeAppVersion) Error() string {
return e.init().Error()
}
func (e *errCannotDowngradeAppVersion) RecommendActions() string {
return e.init().RecommendActions()
}
type errCannotDowngradeVersion struct {
componentName string
componentType string
currentVersion string
latestTemplateVersion string
}
func (e *errCannotDowngradeVersion) Error() string {
return fmt.Sprintf("cannot downgrade %s %q (currently in version %s) to version %s", e.componentType, e.componentName, e.currentVersion, e.latestTemplateVersion)
}
func (e *errCannotDowngradeVersion) RecommendActions() string {
return fmt.Sprintf(`It looks like you are trying to use an earlier version of Copilot to downgrade %s lastly updated by a newer version of Copilot.
- We recommend upgrade your local Copilot CLI version and run this command again.
- Alternatively, you can run with %s to override. However, this can cause unsuccessful deployment. Please use with caution!`,
color.HighlightCode(fmt.Sprintf("%s %s", e.componentType, e.componentName)), color.HighlightCode(fmt.Sprintf("--%s", allowDowngradeFlag)))
}
| 75 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
const (
defaultCommand = "/bin/sh"
)
type execVars struct {
appName string
envName string
name string
command string
taskID string
containerName string
skipConfirmation *bool // If nil, we will prompt to upgrade the ssm plugin.
}
| 19 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"strconv"
"strings"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/dustin/go-humanize/english"
)
// Long flag names.
const (
// Common flags.
nameFlag = "name"
appFlag = "app"
envFlag = "env"
workloadFlag = "workload"
svcTypeFlag = "svc-type"
jobTypeFlag = "job-type"
typeFlag = "type"
profileFlag = "profile"
yesFlag = "yes"
jsonFlag = "json"
allFlag = "all"
forceFlag = "force"
allowDowngradeFlag = "allow-downgrade"
noRollbackFlag = "no-rollback"
manifestFlag = "manifest"
resourceTagsFlag = "resource-tags"
// Build flags.
dockerFileFlag = "dockerfile"
dockerFileContextFlag = "build-context"
imageTagFlag = "tag"
stackOutputDirFlag = "output-dir"
uploadAssetsFlag = "upload-assets"
deployFlag = "deploy"
diffFlag = "diff"
diffAutoApproveFlag = "diff-yes"
sourcesFlag = "sources"
// Flags for operational commands.
limitFlag = "limit"
lastFlag = "last"
followFlag = "follow"
previousFlag = "previous"
sinceFlag = "since"
startTimeFlag = "start-time"
endTimeFlag = "end-time"
tasksFlag = "tasks"
logGroupFlag = "log-group"
containerLogFlag = "container"
includeStateMachineLogsFlag = "include-state-machine"
resourcesFlag = "resources"
taskIDFlag = "task-id"
containerFlag = "container"
// Flags for CI/CD.
githubURLFlag = "github-url"
repoURLFlag = "url"
githubAccessTokenFlag = "github-access-token"
gitBranchFlag = "git-branch"
envsFlag = "environments"
pipelineTypeFlag = "pipeline-type"
// Flags for ls.
localFlag = "local"
// Flags for storage.
storageTypeFlag = "storage-type"
storageLifecycleFlag = "lifecycle"
storageAddIngressFromFlag = "add-ingress-from"
storagePartitionKeyFlag = "partition-key"
storageSortKeyFlag = "sort-key"
storageNoSortFlag = "no-sort"
storageLSIConfigFlag = "lsi"
storageNoLSIFlag = "no-lsi"
storageAuroraServerlessVersionFlag = "serverless-version"
storageRDSEngineFlag = "engine"
storageRDSInitialDBFlag = "initial-db"
storageRDSParameterGroupFlag = "parameter-group"
// Flags for one-off tasks.
taskGroupNameFlag = "task-group-name"
countFlag = "count"
cpuFlag = "cpu"
memoryFlag = "memory"
imageFlag = "image"
taskRoleFlag = "task-role"
executionRoleFlag = "execution-role"
clusterFlag = "cluster"
acknowledgeSecretsAccessFlag = "acknowledge-secrets-access"
subnetsFlag = "subnets"
securityGroupsFlag = "security-groups"
envVarsFlag = "env-vars"
envFileFlag = "env-file"
secretsFlag = "secrets"
commandFlag = "command"
entrypointFlag = "entrypoint"
taskDefaultFlag = "default"
generateCommandFlag = "generate-cmd"
osFlag = "platform-os"
archFlag = "platform-arch"
// Flags for environment configurations.
vpcIDFlag = "import-vpc-id"
publicSubnetsFlag = "import-public-subnets"
privateSubnetsFlag = "import-private-subnets"
certsFlag = "import-cert-arns"
internalALBSubnetsFlag = "internal-alb-subnets"
allowVPCIngressFlag = "internal-alb-allow-vpc-ingress"
overrideVPCCIDRFlag = "override-vpc-cidr"
overrideAZsFlag = "override-az-names"
overridePublicSubnetCIDRsFlag = "override-public-cidrs"
overridePrivateSubnetCIDRsFlag = "override-private-cidrs"
enableContainerInsightsFlag = "container-insights"
defaultConfigFlag = "default-config"
accessKeyIDFlag = "aws-access-key-id"
secretAccessKeyFlag = "aws-secret-access-key"
sessionTokenFlag = "aws-session-token"
regionFlag = "region"
// Flags for creating secrets.
valuesFlag = "values"
overwriteFlag = "overwrite"
inputFilePathFlag = "cli-input-yaml"
// Flags for overriding templates.
iacToolFlag = "tool"
cdkLanguageFlag = "cdk-language"
skipResourcesFlag = "skip-resources"
// Other.
svcPortFlag = "port"
noSubscriptionFlag = "no-subscribe"
subscribeTopicsFlag = "subscribe-topics"
ingressTypeFlag = "ingress-type"
retriesFlag = "retries"
timeoutFlag = "timeout"
scheduleFlag = "schedule"
domainNameFlag = "domain"
permissionsBoundaryFlag = "permissions-boundary"
prodEnvFlag = "prod"
deleteSecretFlag = "delete-secret"
)
// Short flag names.
// A short flag only exists if the flag or flag set is mandatory by the command.
const (
nameFlagShort = "n"
appFlagShort = "a"
envFlagShort = "e"
typeFlagShort = "t"
workloadFlagShort = "w"
previousFlagShort = "p"
dockerFileFlagShort = "d"
commandFlagShort = "c"
imageFlagShort = "i"
repoURLFlagShort = "u"
githubAccessTokenFlagShort = "t"
gitBranchFlagShort = "b"
envsFlagShort = "e"
pipelineTypeShort = "p"
storageLifecycleShort = "l"
scheduleFlagShort = "s"
)
// Descriptions for flags.
var (
svcTypeFlagDescription = fmt.Sprintf(`Type of service to create. Must be one of:
%s.`, strings.Join(applyAll(manifestinfo.ServiceTypes(), strconv.Quote), ", "))
imageFlagDescription = fmt.Sprintf(`The location of an existing Docker image.
Cannot be specified with --%s or --%s.`, dockerFileFlag, dockerFileContextFlag)
dockerFileFlagDescription = fmt.Sprintf(`Path to the Dockerfile.
Cannot be specified with --%s.`, imageFlag)
dockerFileContextFlagDescription = fmt.Sprintf(`Path to the Docker build context.
Cannot be specified with --%s.`, imageFlag)
sourcesFlagDescription = fmt.Sprintf(`List of relative paths to source directories or files.
Must be specified with '--%s "Static Site"'.`, svcTypeFlag)
storageTypeFlagDescription = fmt.Sprintf(`Type of storage to add. Must be one of:
%s.`, strings.Join(applyAll(storageTypes, strconv.Quote), ", "))
storageLifecycleFlagDescription = fmt.Sprintf(`Whether the storage should be created and deleted
at the same time as a workload or an environment.
Must be one of: %s.`, english.OxfordWordSeries(applyAll(validLifecycleOptions, strconv.Quote), "or"))
storageAddIngressFromFlagDescription = fmt.Sprintf(`The workload that needs access to an
environment storage resource. Must be
specified with %q and %q.
Can be specified with %q.`,
fmt.Sprintf("--%s", nameFlag),
fmt.Sprintf("--%s", storageTypeFlag),
fmt.Sprintf("--%s", storageRDSEngineFlag))
jobTypeFlagDescription = fmt.Sprintf(`Type of job to create. Must be one of:
%s.`, strings.Join(applyAll(manifestinfo.JobTypes(), strconv.Quote), ", "))
wkldTypeFlagDescription = fmt.Sprintf(`Type of job or svc to create. Must be one of:
%s.`, strings.Join(applyAll(manifestinfo.WorkloadTypes(), strconv.Quote), ", "))
clusterFlagDescription = fmt.Sprintf(`Optional. The short name or full ARN of the cluster to run the task in.
Cannot be specified with --%s, --%s or --%s.`, appFlag, envFlag, taskDefaultFlag)
acknowledgeSecretsAccessDescription = fmt.Sprintf(`Optional. Skip the confirmation question and grant access to the secrets specified by --secrets flag.
This flag is useful only when '%s' flag is specified`, secretsFlag)
subnetsFlagDescription = fmt.Sprintf(`Optional. The subnet IDs for the task to use. Can be specified multiple times.
Cannot be specified with --%s, --%s or --%s.`, appFlag, envFlag, taskDefaultFlag)
securityGroupsFlagDescription = "Optional. Additional security group IDs for the task to use. Can be specified multiple times."
taskRunDefaultFlagDescription = fmt.Sprintf(`Optional. Run tasks in default cluster and default subnets.
Cannot be specified with --%s, --%s or --%s.`, appFlag, envFlag, subnetsFlag)
taskExecDefaultFlagDescription = fmt.Sprintf(`Optional. Execute commands in running tasks in default cluster and default subnets.
Cannot be specified with --%s or --%s.`, appFlag, envFlag)
taskDeleteDefaultFlagDescription = fmt.Sprintf(`Optional. Delete a task which was launched in the default cluster and subnets.
Cannot be specified with --%s or --%s.`, appFlag, envFlag)
taskEnvFlagDescription = fmt.Sprintf(`Optional. Name of the environment.
Cannot be specified with --%s, --%s or --%s.`, taskDefaultFlag, subnetsFlag, securityGroupsFlag)
taskAppFlagDescription = fmt.Sprintf(`Optional. Name of the application.
Cannot be specified with --%s, --%s or --%s.`, taskDefaultFlag, subnetsFlag, securityGroupsFlag)
osFlagDescription = fmt.Sprintf(`Optional. Operating system of the task. Must be specified along with '%s'.`, archFlag)
archFlagDescription = fmt.Sprintf(`Optional. Architecture of the task. Must be specified along with '%s'.`, osFlag)
secretNameFlagDescription = fmt.Sprintf(`The name of the secret.
Mutually exclusive with the --%s flag.`, inputFilePathFlag)
secretValuesFlagDescription = fmt.Sprintf(`Values of the secret in each environment. Specified as <environment>=<value> separated by commas.
Mutually exclusive with the --%s flag.`, inputFilePathFlag)
secretInputFilePathFlagDescription = fmt.Sprintf(`Optional. A YAML file in which the secret values are specified.
Mutually exclusive with the -%s ,--%s and --%s flags.`, nameFlagShort, nameFlag, valuesFlag)
iacToolFlagDescription = fmt.Sprintf(`Infrastructure as Code tool to override a template.
Must be one of: %s.`, strings.Join(applyAll(validIaCTools, strconv.Quote), ", "))
cdkLanguageFlagDescription = `Optional. The Cloud Development Kit language.`
overrideEnvFlagDescription = `Optional. Name of the environment to use when retrieving resources in a template.
Defaults to a random environment.`
skipResourcesFlagDescription = `Optional. Skip asking for which resources to override and generate empty IaC extension files.`
repoURLFlagDescription = fmt.Sprintf(`The repository URL to trigger your pipeline.
Supported providers are: %s.`, strings.Join(manifest.PipelineProviders, ", "))
ingressTypeFlagDescription = fmt.Sprintf(`Required for a Request-Driven Web Service. Allowed source of traffic to your service.
Must be one of %s.`, english.OxfordWordSeries(rdwsIngressOptions, "or"))
)
const (
// Common flags
appFlagDescription = "Name of the application."
envFlagDescription = "Name of the environment."
svcFlagDescription = "Name of the service."
jobFlagDescription = "Name of the job."
workloadFlagDescription = "Name of the service or job."
nameFlagDescription = "Name of the service, job, or task group."
yesFlagDescription = "Skips confirmation prompt."
resourceTagsFlagDescription = `Optional. Labels with a key and value separated by commas.
Allows you to categorize resources.`
diffFlagDescription = "Compares the generated CloudFormation template to the deployed stack."
diffAutoApproveFlagDescription = "Skip interactive approval of diff before deploying."
// Deployment.
deployTestFlagDescription = `Deploy your service or job to a "test" environment.`
allowDowngradeFlagDescription = `Optional. Allow using an older version of Copilot to update Copilot components
updated by a newer version of Copilot.`
forceFlagDescription = `Optional. Force a new service deployment using the existing image.
Not available with the "Static Site" service type.`
noRollbackFlagDescription = `Optional. Disable automatic stack
rollback in case of deployment failure.
We do not recommend using this flag for a
production environment.`
forceEnvDeployFlagDescription = "Optional. Force update the environment stack template."
// Operational.
jsonFlagDescription = "Optional. Output in JSON format."
limitFlagDescription = `Optional. The maximum number of log events returned. Default is 10
unless any time filtering flags are set.`
lastFlagDescription = `Optional. The number of executions of the scheduled job for which
logs should be shown.`
followFlagDescription = "Optional. Specifies if the logs should be streamed."
previousFlagDescription = "Optional. Print logs for the last stopped task if exists."
sinceFlagDescription = `Optional. Only return logs newer than a relative duration like 5s, 2m, or 3h.
Defaults to all logs. Only one of start-time / since may be used.`
startTimeFlagDescription = `Optional. Only return logs after a specific date (RFC3339).
Defaults to all logs. Only one of start-time / since may be used.`
endTimeFlagDescription = `Optional. Only return logs before a specific date (RFC3339).
Defaults to all logs. Only one of end-time / follow may be used.`
tasksLogsFlagDescription = "Optional. Only return logs from specific task IDs."
includeStateMachineLogsFlagDescription = "Optional. Include logs from the state machine executions."
logGroupFlagDescription = "Optional. Only return logs from specific log group."
containerLogFlagDescription = "Optional. Return only logs from a specific container."
envResourcesFlagDescription = "Optional. Show the resources in your environment."
svcResourcesFlagDescription = "Optional. Show the resources in your service."
pipelineResourcesFlagDescription = "Optional. Show the resources in your pipeline."
localSvcFlagDescription = "Only show services in the workspace."
localJobFlagDescription = "Only show jobs in the workspace."
localPipelineFlagDescription = "Only show pipelines in the workspace."
svcManifestFlagDescription = `Optional. Name of the environment in which the service was deployed;
output the manifest file used for that deployment.`
manifestFlagDescription = "Optional. Output the manifest file used for the deployment."
execYesFlagDescription = "Optional. Whether to update the Session Manager Plugin."
taskIDFlagDescription = "Optional. ID of the task you want to exec in."
execCommandFlagDescription = `Optional. The command that is passed to a running container.`
containerFlagDescription = "Optional. The specific container you want to exec in. By default the first essential container will be used."
// Build.
imageTagFlagDescription = `Optional. The tag for the container images Copilot builds from Dockerfiles.`
uploadAssetsFlagDescription = `Optional. Whether to upload assets (container images, Lambda functions, etc.).
Uploaded asset locations are filled in the template configuration.`
stackOutputDirFlagDescription = "Optional. Writes the stack template and template configuration to a directory."
// CI/CD.
pipelineFlagDescription = "Name of the pipeline."
githubURLFlagDescription = "(Deprecated.) Use '--url' instead. Repository URL to trigger your pipeline."
githubAccessTokenFlagDescription = "GitHub personal access token for your repository."
gitBranchFlagDescription = "Branch used to trigger your pipeline."
pipelineEnvsFlagDescription = "Environments to add to the pipeline."
pipelineTypeFlagDescription = `The type of pipeline. Must be either "Workloads" or "Environments".`
// Storage.
storageFlagDescription = "Name of the storage resource to create."
storageWorkloadFlagDescription = "Name of the service/job that accesses the storage."
storagePartitionKeyFlagDescription = `Partition key for the DDB table.
Must be of the format '<keyName>:<dataType>'.`
storageSortKeyFlagDescription = `Optional. Sort key for the DDB table.
Must be of the format '<keyName>:<dataType>'.`
storageNoSortFlagDescription = "Optional. Skip configuring sort keys."
storageNoLSIFlagDescription = `Optional. Don't ask about configuring alternate sort keys.`
storageLSIConfigFlagDescription = `Optional. Attribute to use as an alternate sort key. May be specified up to 5 times.
Must be of the format '<keyName>:<dataType>'.`
storageAuroraServerlessVersionFlagDescription = `Optional. Aurora Serverless version.
Must be either "v1" or "v2".`
storageRDSEngineFlagDescription = `The database engine used in the cluster.
Must be either "MySQL" or "PostgreSQL".`
storageRDSInitialDBFlagDescription = "The initial database to create in the cluster."
storageRDSParameterGroupFlagDescription = "Optional. The name of the parameter group to associate with the cluster."
// One-off tasks.
countFlagDescription = "Optional. The number of tasks to set up."
cpuFlagDescription = "Optional. The number of CPU units to reserve for each task."
memoryFlagDescription = "Optional. The amount of memory to reserve in MiB for each task."
taskRoleFlagDescription = "Optional. The ARN of the role for the task to use."
executionRoleFlagDescription = "Optional. The ARN of the role that grants the container agent permission to make AWS API calls."
envVarsFlagDescription = "Optional. Environment variables specified by key=value separated by commas."
envFileFlagDescription = `Optional. A path to an environment variable (.env) file.
Each line should be of the form of VARIABLE=VALUE.
Values specified with --env-vars take precedence over --env-file.`
secretsFlagDescription = "Optional. Secrets to inject into the container. Specified by key=value separated by commas."
runCommandFlagDescription = `Optional. The command that is passed to "docker run" to override the default command.`
entrypointFlagDescription = `Optional. The entrypoint that is passed to "docker run" to override the default entrypoint.`
taskGroupFlagDescription = `Optional. The group name of the task.
Tasks with the same group name share the same set of resources.
(default directory name)`
taskImageTagFlagDescription = `Optional. The container image tag in addition to "latest".`
generateCommandFlagDescription = `Optional. Generate a command with a pre-filled value for each flag.
To use it for an ECS service, specify --generate-cmd <cluster name>/<service name>.
Alternatively, if the service or job is created with Copilot, specify --generate-cmd <application>/<environment>/<service or job name>.
Cannot be specified with any other flags.`
// Environment configurations.
vpcIDFlagDescription = "Optional. Use an existing VPC ID."
publicSubnetsFlagDescription = "Optional. Use existing public subnet IDs."
privateSubnetsFlagDescription = "Optional. Use existing private subnet IDs."
certsFlagDescription = "Optional. Apply existing ACM certificates to the internet-facing load balancer."
internalALBSubnetsFlagDescription = `Optional. Specify subnet IDs for an internal load balancer.
By default, the load balancer will be placed in your private subnets.
Cannot be specified with --default-config or any of the --override flags.`
allowVPCIngressFlagDescription = `Optional. Allow internal ALB ingress from port 80 and/or port 443.`
overrideVPCCIDRFlagDescription = `Optional. Global CIDR to use for VPC.
(default 10.0.0.0/16)`
overrideAZsFlagDescription = `Optional. Availability Zone names.
(default 2 random AZs)`
overridePublicSubnetCIDRsFlagDescription = `Optional. CIDR to use for public subnets.
(default 10.0.0.0/24,10.0.1.0/24)`
overridePrivateSubnetCIDRsFlagDescription = `Optional. CIDR to use for private subnets.
(default 10.0.2.0/24,10.0.3.0/24)`
enableContainerInsightsFlagDescription = "Optional. Enable CloudWatch Container Insights."
defaultConfigFlagDescription = "Optional. Skip prompting and use default environment configuration."
profileFlagDescription = "Name of the profile."
accessKeyIDFlagDescription = "Optional. An AWS access key."
secretAccessKeyFlagDescription = "Optional. An AWS secret access key."
sessionTokenFlagDescription = "Optional. An AWS session token for temporary credentials."
envRegionTokenFlagDescription = "Optional. An AWS region where the environment will be created."
// Other.
domainNameFlagDescription = "Optional. Your existing custom domain name."
deleteSecretFlagDescription = "Deletes AWS Secrets Manager secret associated with a pipeline source repository."
svcPortFlagDescription = "The port on which your service listens."
noSubscriptionFlagDescription = "Optional. Turn off selection for adding subscriptions for worker services."
subscribeTopicsFlagDescription = `Optional. SNS topics to subscribe to from other services in your application.
Must be of format '<svcName>:<topicName>'.`
retriesFlagDescription = "Optional. The number of times to try restarting the job on a failure."
timeoutFlagDescription = `Optional. The total execution time for the task, including retries.
Accepts valid Go duration strings. For example: "2h", "1h30m", "900s".`
scheduleFlagDescription = `The schedule on which to run this job.
Accepts cron expressions of the format (M H DoM M DoW) and schedule definition strings.
For example: "0 * * * *", "@daily", "@weekly", "@every 1h30m".
AWS Schedule Expressions of the form "rate(10 minutes)" or "cron(0 12 L * ? 2021)"
are also accepted.`
upgradeAllEnvsDescription = "Optional. Upgrade all environments."
secretOverwriteFlagDescription = "Optional. Whether to overwrite an existing secret."
permissionsBoundaryFlagDescription = `Optional. The name or ARN of an existing IAM policy with which to set a
permissions boundary for all roles generated within the application.`
prodEnvFlagDescription = "If the environment contains production services."
)
| 411 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"strings"
"github.com/aws/copilot-cli/internal/pkg/exec"
)
func describeGitChanges(r execRunner) (string, error) {
var stdout bytes.Buffer
var stderr bytes.Buffer
if err := r.Run("git", []string{"describe", "--always"}, exec.Stdout(&stdout), exec.Stderr(&stderr)); err != nil {
return "", err
}
// NOTE: `git describe` output bytes includes a `\n` character, so we trim it out.
return strings.TrimSpace(stdout.String()), nil
}
func hasUncommitedGitChanges(r execRunner) (bool, error) {
var stdout bytes.Buffer
var stderr bytes.Buffer
if err := r.Run("git", []string{"status", "--porcelain"}, exec.Stdout(&stdout), exec.Stderr(&stderr)); err != nil {
return false, err
}
return strings.TrimSpace(stdout.String()) != "", nil
}
// imageTagFromGit returns the image tag to apply in case the user is in a git repository.
// If there is a clean git commit with no local changes, then return the git commit id.
// Otherwise, returns the empty string.
func imageTagFromGit(r execRunner) string {
commit, err := describeGitChanges(r)
if err != nil {
return ""
}
isRepoDirty, _ := hasUncommitedGitChanges(r)
if isRepoDirty {
return ""
}
return commit
}
| 46 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import "github.com/aws/copilot-cli/internal/pkg/aws/identity"
type identityService interface {
Get() (identity.Caller, error)
}
| 11 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package cli contains the copilot commands.
package cli
import (
"errors"
"fmt"
"os"
awscfn "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/iam"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerfile"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
cmdtemplate "github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/initialize"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
const (
defaultEnvironmentName = "test"
)
const (
initShouldDeployPrompt = "Would you like to deploy a test environment?"
initShouldDeployHelpPrompt = "An environment with your service deployed to it. This will allow you to test your service before placing it in production."
)
type initVars struct {
// Flags unique to "init" that's not provided by other sub-commands.
shouldDeploy bool
appName string
wkldType string
svcName string
dockerfilePath string
image string
imageTag string
// Service specific flags
port uint16
// Scheduled Job specific flags
schedule string
retries int
timeout string
}
type initOpts struct {
initVars
ShouldDeploy bool // true means we should create a test environment and deploy the service to it. Defaults to false.
promptForShouldDeploy bool // true means that the user set the ShouldDeploy flag explicitly.
// Sub-commands to execute.
initAppCmd actionCommand
initWlCmd actionCommand
initEnvCmd actionCommand
deployEnvCmd cmd
deploySvcCmd actionCommand
deployJobCmd actionCommand
// Pointers to flag values part of sub-commands.
// Since the sub-commands implement the actionCommand interface, without pointers to their internal fields
// we have to resort to type-casting the interface. These pointers simplify data access.
appName *string
port *uint16
schedule *string
initWkldVars *initWkldVars
prompt prompter
setupWorkloadInit func(*initOpts, string) error
useExistingWorkspaceForCMDs func(*initOpts) error
}
func newInitOpts(vars initVars) (*initOpts, error) {
fs := afero.NewOsFs()
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("init"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompt := prompt.New()
deployStore, err := deploy.NewStore(sessProvider, configStore)
if err != nil {
return nil, err
}
snsSel := selector.NewDeploySelect(prompt, configStore, deployStore)
spin := termprogress.NewSpinner(log.DiagnosticWriter)
id := identity.New(defaultSess)
deployer := cloudformation.New(defaultSess, cloudformation.WithProgressTracker(os.Stderr))
iamClient := iam.New(defaultSess)
appVersionGetter, err := describe.NewAppDescriber(vars.appName)
if err != nil {
return nil, err
}
initAppCmd := &initAppOpts{
initAppVars: initAppVars{
name: vars.appName,
},
store: configStore,
prompt: prompt,
identity: id,
cfn: deployer,
prog: spin,
isSessionFromEnvVars: func() (bool, error) {
return sessions.AreCredsFromEnvVars(defaultSess)
},
existingWorkspace: func() (wsAppManager, error) {
return workspace.Use(fs)
},
newWorkspace: func(appName string) (wsAppManager, error) {
return workspace.Create(appName, fs)
},
iam: iamClient,
iamRoleManager: iamClient,
}
initEnvCmd := &initEnvOpts{
initEnvVars: initEnvVars{
appName: vars.appName,
name: defaultEnvironmentName,
isProduction: false,
},
store: configStore,
appDeployer: deployer,
prog: spin,
prompt: prompt,
identity: id,
appVersionGetter: appVersionGetter,
appCFN: cloudformation.New(defaultSess, cloudformation.WithProgressTracker(os.Stderr)),
sess: defaultSess,
templateVersion: version.LatestTemplateVersion(),
}
deployEnvCmd := &deployEnvOpts{
deployEnvVars: deployEnvVars{
appName: vars.appName,
name: defaultEnvironmentName,
},
store: configStore,
sessionProvider: sessProvider,
identity: id,
fs: fs,
newInterpolator: newManifestInterpolator,
newEnvVersionGetter: func(appName, envName string) (versionGetter, error) {
return describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: configStore,
})
},
templateVersion: version.LatestTemplateVersion(),
}
deploySvcCmd := &deploySvcOpts{
deployWkldVars: deployWkldVars{
envName: defaultEnvironmentName,
imageTag: vars.imageTag,
appName: vars.appName,
},
store: configStore,
prompt: prompt,
newInterpolator: newManifestInterpolator,
unmarshal: manifest.UnmarshalWorkload,
spinner: spin,
cmd: exec.NewCmd(),
sessProvider: sessProvider,
}
deploySvcCmd.newSvcDeployer = func() (workloadDeployer, error) {
return newSvcDeployer(deploySvcCmd)
}
deployJobCmd := &deployJobOpts{
deployWkldVars: deployWkldVars{
envName: defaultEnvironmentName,
imageTag: vars.imageTag,
appName: vars.appName,
},
store: configStore,
newInterpolator: newManifestInterpolator,
unmarshal: manifest.UnmarshalWorkload,
cmd: exec.NewCmd(),
sessProvider: sessProvider,
}
deployJobCmd.newJobDeployer = func() (workloadDeployer, error) {
return newJobDeployer(deployJobCmd)
}
cmd := exec.NewCmd()
useExistingWorkspaceClient := func(o *initOpts) error {
ws, err := workspace.Use(fs)
if err != nil {
return err
}
sel := selector.NewLocalWorkloadSelector(prompt, configStore, ws)
initEnvCmd.manifestWriter = ws
deployEnvCmd.ws = ws
deployEnvCmd.newEnvDeployer = func() (envDeployer, error) {
return newEnvDeployer(deployEnvCmd, ws)
}
deploySvcCmd.ws = ws
deploySvcCmd.sel = sel
deployJobCmd.ws = ws
deployJobCmd.sel = sel
if initWkCmd, ok := o.initWlCmd.(*initSvcOpts); ok {
initWkCmd.init = &initialize.WorkloadInitializer{Store: configStore, Ws: ws, Prog: spin, Deployer: deployer}
}
if initWkCmd, ok := o.initWlCmd.(*initJobOpts); ok {
initWkCmd.init = &initialize.WorkloadInitializer{Store: configStore, Ws: ws, Prog: spin, Deployer: deployer}
}
return nil
}
return &initOpts{
initVars: vars,
ShouldDeploy: vars.shouldDeploy,
initAppCmd: initAppCmd,
initEnvCmd: initEnvCmd,
deployEnvCmd: deployEnvCmd,
deploySvcCmd: deploySvcCmd,
deployJobCmd: deployJobCmd,
appName: &initAppCmd.name,
prompt: prompt,
setupWorkloadInit: func(o *initOpts, wkldType string) error {
wkldVars := initWkldVars{
appName: *o.appName,
wkldType: wkldType,
name: vars.svcName,
dockerfilePath: vars.dockerfilePath,
image: vars.image,
}
dfSel, err := selector.NewDockerfileSelector(prompt, fs)
if err != nil {
return fmt.Errorf("initiate dockerfile selector: %w", err)
}
switch t := wkldType; {
case manifestinfo.IsTypeAJob(t):
jobVars := initJobVars{
initWkldVars: wkldVars,
schedule: vars.schedule,
retries: vars.retries,
timeout: vars.timeout,
}
opts := initJobOpts{
initJobVars: jobVars,
fs: fs,
store: configStore,
dockerfileSel: dfSel,
scheduleSelector: selector.NewStaticSelector(prompt),
prompt: prompt,
newAppVersionGetter: func(appName string) (versionGetter, error) {
return describe.NewAppDescriber(appName)
},
dockerEngine: dockerengine.New(cmd),
wsPendingCreation: true,
initParser: func(s string) dockerfileParser {
return dockerfile.New(fs, s)
},
templateVersion: version.LatestTemplateVersion(),
initEnvDescriber: func(appName string, envName string) (envDescriber, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: configStore,
})
if err != nil {
return nil, err
}
return envDescriber, nil
},
}
o.initWlCmd = &opts
o.schedule = &opts.schedule // Surfaced via pointer for logging
o.initWkldVars = &opts.initWkldVars
case manifestinfo.IsTypeAService(t):
svcVars := initSvcVars{
initWkldVars: wkldVars,
port: vars.port,
ingressType: ingressTypeInternet,
}
opts := initSvcOpts{
initSvcVars: svcVars,
fs: fs,
sel: dfSel,
store: configStore,
topicSel: snsSel,
prompt: prompt,
newAppVersionGetter: func(appName string) (versionGetter, error) {
return describe.NewAppDescriber(appName)
},
dockerEngine: dockerengine.New(cmd),
wsPendingCreation: true,
templateVersion: version.LatestTemplateVersion(),
}
opts.dockerfile = func(path string) dockerfileParser {
if opts.df != nil {
return opts.df
}
opts.df = dockerfile.New(opts.fs, opts.dockerfilePath)
return opts.df
}
opts.initEnvDescriber = func(appName string, envName string) (envDescriber, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: opts.store,
})
if err != nil {
return nil, err
}
return envDescriber, nil
}
o.initWlCmd = &opts
o.port = &opts.port // Surfaced via pointer for logging.
o.initWkldVars = &opts.initWkldVars
default:
return fmt.Errorf("unrecognized workload type")
}
return nil
},
useExistingWorkspaceForCMDs: useExistingWorkspaceClient,
}, nil
}
// Run executes "app init", "env init", "svc init" and "svc deploy".
func (o *initOpts) Run() error {
if !workspace.IsInGitRepository(afero.NewOsFs()) {
log.Warningln("It's best to run this command in the root of your Git repository.")
}
log.Infoln(color.Help(`Welcome to the Copilot CLI! We're going to walk you through some questions
to help you get set up with a containerized application on AWS. An application is a collection of
containerized services that operate together.`))
log.Infoln()
if err := o.loadApp(); err != nil {
return err
}
if err := o.loadWkld(); err != nil {
return err
}
o.logWorkloadTypeAck()
log.Infoln()
if err := o.initAppCmd.Execute(); err != nil {
return fmt.Errorf("execute app init: %w", err)
}
if err := o.useExistingWorkspaceForCMDs(o); err != nil {
return fmt.Errorf("set up workspace client for commands: %w", err)
}
if err := o.initWlCmd.Execute(); err != nil {
return fmt.Errorf("execute %s init: %w", o.wkldType, err)
}
if err := o.deployEnv(); err != nil {
return err
}
return o.deploy()
}
func (o *initOpts) logWorkloadTypeAck() {
if manifestinfo.IsTypeAJob(o.initWkldVars.wkldType) {
log.Infof("Ok great, we'll set up a %s named %s in application %s running on the schedule %s.\n",
color.HighlightUserInput(o.initWkldVars.wkldType), color.HighlightUserInput(o.initWkldVars.name), color.HighlightUserInput(o.initWkldVars.appName), color.HighlightUserInput(*o.schedule))
return
}
log.Infof("Ok great, we'll set up a %s named %s in application %s.\n", color.HighlightUserInput(o.initWkldVars.wkldType), color.HighlightUserInput(o.initWkldVars.name), color.HighlightUserInput(o.initWkldVars.appName))
}
func (o *initOpts) deploy() error {
if manifestinfo.IsTypeAJob(o.initWkldVars.wkldType) {
return o.deployJob()
}
return o.deploySvc()
}
func (o *initOpts) loadApp() error {
if err := o.initAppCmd.Ask(); err != nil {
return fmt.Errorf("ask app init: %w", err)
}
if err := o.initAppCmd.Validate(); err != nil {
return err
}
return nil
}
func (o *initOpts) loadWkld() error {
err := o.loadWkldCmd()
if err != nil {
return err
}
if err := o.initWlCmd.Validate(); err != nil {
return fmt.Errorf("validate %s: %w", o.wkldType, err)
}
if err := o.initWlCmd.Ask(); err != nil {
return fmt.Errorf("ask %s: %w", o.wkldType, err)
}
return nil
}
func (o *initOpts) loadWkldCmd() error {
wkldType, err := o.askWorkload()
if err != nil {
return err
}
if err := o.setupWorkloadInit(o, wkldType); err != nil {
return err
}
return nil
}
func (o *initOpts) askWorkload() (string, error) {
if o.wkldType != "" {
return o.wkldType, nil
}
wkldInitTypePrompt := "Which " + color.Emphasize("workload type") + " best represents your architecture?"
// Build the workload help prompt from existing helps text.
wkldHelp := fmt.Sprintf("%s\n\n%s", svcInitSvcTypeHelpPrompt, jobInitTypeHelp)
t, err := o.prompt.SelectOption(wkldInitTypePrompt, wkldHelp, append(svcTypePromptOpts(), jobTypePromptOpts()...), prompt.WithFinalMessage("Workload type:"))
if err != nil {
return "", fmt.Errorf("select workload type: %w", err)
}
o.wkldType = t
return t, nil
}
// deployEnv prompts the user to deploy a test environment if the application doesn't already have one.
func (o *initOpts) deployEnv() error {
if o.promptForShouldDeploy {
log.Infoln("All right, you're all set for local development.")
if err := o.askShouldDeploy(); err != nil {
return err
}
}
if !o.ShouldDeploy {
// User chose not to deploy the service, exit.
return nil
}
if initEnvCmd, ok := o.initEnvCmd.(*initEnvOpts); ok {
// Set the application name from app init to the env init command.
initEnvCmd.appName = *o.appName
}
log.Infoln()
if err := o.initEnvCmd.Execute(); err != nil {
return err
}
log.Successf("Provisioned bootstrap resources for environment %s.\n", defaultEnvironmentName)
if deployEnvCmd, ok := o.deployEnvCmd.(*deployEnvOpts); ok {
// Set the application name from app init to the env deploy command.
deployEnvCmd.appName = *o.appName
}
if err := o.deployEnvCmd.Execute(); err != nil {
var errEmptyChangeSet *awscfn.ErrChangeSetEmpty
if !errors.As(err, &errEmptyChangeSet) {
return err
}
}
return nil
}
func (o *initOpts) deploySvc() error {
if !o.ShouldDeploy {
return nil
}
if deployOpts, ok := o.deploySvcCmd.(*deploySvcOpts); ok {
// Set the service's name and app name to the deploy sub-command.
deployOpts.name = o.initWkldVars.name
deployOpts.appName = *o.appName
}
if err := o.deploySvcCmd.Ask(); err != nil {
return err
}
if err := o.deploySvcCmd.Execute(); err != nil {
return err
}
if err := o.deploySvcCmd.RecommendActions(); err != nil {
return err
}
return nil
}
func (o *initOpts) deployJob() error {
if !o.ShouldDeploy {
return nil
}
if deployOpts, ok := o.deployJobCmd.(*deployJobOpts); ok {
// Set the service's name and app name to the deploy sub-command.
deployOpts.name = o.initWkldVars.name
deployOpts.appName = *o.appName
}
if err := o.deployJobCmd.Ask(); err != nil {
return err
}
if err := o.deployJobCmd.Execute(); err != nil {
return err
}
if err := o.deployJobCmd.RecommendActions(); err != nil {
return err
}
return nil
}
func (o *initOpts) askShouldDeploy() error {
v, err := o.prompt.Confirm(initShouldDeployPrompt, initShouldDeployHelpPrompt, prompt.WithFinalMessage("Deploy:"))
if err != nil {
return fmt.Errorf("failed to confirm deployment: %w", err)
}
o.ShouldDeploy = v
return nil
}
// BuildInitCmd builds the command for bootstrapping an application.
func BuildInitCmd() *cobra.Command {
vars := initVars{}
cmd := &cobra.Command{
Use: "init",
Short: "Create a new ECS or App Runner application.",
Long: "Create a new ECS or App Runner application.",
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newInitOpts(vars)
if err != nil {
return err
}
opts.promptForShouldDeploy = !cmd.Flags().Changed(deployFlag)
if err := opts.Run(); err != nil {
return err
}
if !opts.ShouldDeploy {
log.Info("\nNo problem, you can deploy your service later:\n")
log.Infof("- Run %s to create your environment.\n", color.HighlightCode("copilot env init"))
log.Infof("- Run %s to deploy your service.\n", color.HighlightCode("copilot deploy"))
}
log.Infoln(`- Be a part of the Copilot ✨community✨!
Ask or answer a question, submit a feature request...
Visit 👉 https://aws.github.io/copilot-cli/community/get-involved/ to see how!`)
return nil
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.svcName, nameFlag, nameFlagShort, "", workloadFlagDescription)
cmd.Flags().StringVarP(&vars.wkldType, typeFlag, typeFlagShort, "", wkldTypeFlagDescription)
cmd.Flags().StringVarP(&vars.dockerfilePath, dockerFileFlag, dockerFileFlagShort, "", dockerFileFlagDescription)
cmd.Flags().StringVarP(&vars.image, imageFlag, imageFlagShort, "", imageFlagDescription)
cmd.Flags().BoolVar(&vars.shouldDeploy, deployFlag, false, deployTestFlagDescription)
cmd.Flags().StringVar(&vars.imageTag, imageTagFlag, "", imageTagFlagDescription)
cmd.Flags().Uint16Var(&vars.port, svcPortFlag, 0, svcPortFlagDescription)
cmd.Flags().StringVar(&vars.schedule, scheduleFlag, "", scheduleFlagDescription)
cmd.Flags().StringVar(&vars.timeout, timeoutFlag, "", timeoutFlagDescription)
cmd.Flags().IntVar(&vars.retries, retriesFlag, 0, retriesFlagDescription)
cmd.SetUsageTemplate(cmdtemplate.Usage)
cmd.Annotations = map[string]string{
"group": group.GettingStarted,
}
return cmd
}
| 591 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
awscfn "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
climocks "github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestInitOpts_Run(t *testing.T) {
mockSchedule := "@hourly"
var mockPort uint16 = 80
var mockAppName = "demo"
testCases := map[string]struct {
inShouldDeploy bool
inPromptForShouldDeploy bool
inAppName string
inWlType string
expect func(opts *initOpts)
wantedError string
}{
"returns prompt error for application": {
inWlType: "Load Balanced Web Service",
expect: func(opts *initOpts) {
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(errors.New("my error"))
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Times(0)
},
wantedError: "ask app init: my error",
},
"returns validation error for application": {
expect: func(opts *initOpts) {
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(errors.New("my error"))
},
wantedError: "my error",
},
"returns prompt error for service": {
inWlType: "Backend Service",
expect: func(opts *initOpts) {
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Times(1).Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(errors.New("my error"))
},
wantedError: "ask Backend Service: my error",
},
"returns validation error for service": {
inWlType: "Load Balanced Web Service",
expect: func(opts *initOpts) {
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(errors.New("my error"))
},
wantedError: "validate Load Balanced Web Service: my error",
},
"returns execute error for application": {
expect: func(opts *initOpts) {
opts.prompt.(*climocks.Mockprompter).EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any())
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(errors.New("my error"))
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Execute().Times(0)
},
wantedError: "execute app init: my error",
},
"returns execute error for service": {
inWlType: "Load Balanced Web Service",
expect: func(opts *initOpts) {
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(errors.New("my error"))
},
wantedError: "execute Load Balanced Web Service init: my error",
},
"fail to deploy an environment": {
inPromptForShouldDeploy: true,
expect: func(opts *initOpts) {
opts.prompt.(*climocks.Mockprompter).EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(manifestinfo.LoadBalancedWebServiceType, nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.prompt.(*climocks.Mockprompter).EXPECT().Confirm(initShouldDeployPrompt, initShouldDeployHelpPrompt, gomock.Any()).
Return(true, nil)
opts.initEnvCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.deployEnvCmd.(*climocks.Mockcmd).EXPECT().Execute().Return(errors.New("some error"))
},
wantedError: "some error",
},
"deploys environment": {
inPromptForShouldDeploy: true,
expect: func(opts *initOpts) {
opts.prompt.(*climocks.Mockprompter).EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(manifestinfo.LoadBalancedWebServiceType, nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.prompt.(*climocks.Mockprompter).EXPECT().Confirm(initShouldDeployPrompt, initShouldDeployHelpPrompt, gomock.Any()).
Return(true, nil)
opts.initEnvCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.deployEnvCmd.(*climocks.Mockcmd).EXPECT().Execute().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().RecommendActions().Return(nil)
},
},
"should not error out if environment change set is empty": {
inPromptForShouldDeploy: true,
expect: func(opts *initOpts) {
opts.prompt.(*climocks.Mockprompter).EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(manifestinfo.LoadBalancedWebServiceType, nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.prompt.(*climocks.Mockprompter).EXPECT().Confirm(initShouldDeployPrompt, initShouldDeployHelpPrompt, gomock.Any()).
Return(true, nil)
opts.initEnvCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.deployEnvCmd.(*climocks.Mockcmd).EXPECT().Execute().Return(fmt.Errorf("wrap: %w", &awscfn.ErrChangeSetEmpty{}))
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().RecommendActions().Return(nil)
},
},
"deploy workload happy path": {
inPromptForShouldDeploy: true,
inShouldDeploy: true,
expect: func(opts *initOpts) {
opts.prompt.(*climocks.Mockprompter).EXPECT().SelectOption(gomock.Any(), gomock.Any(), []prompt.Option{
{
Value: manifestinfo.RequestDrivenWebServiceType,
Hint: "App Runner",
},
{
Value: manifestinfo.LoadBalancedWebServiceType,
Hint: "Internet to ECS on Fargate",
},
{
Value: manifestinfo.BackendServiceType,
Hint: "ECS on Fargate",
},
{
Value: manifestinfo.WorkerServiceType,
Hint: "Events to SQS to ECS on Fargate",
},
{
Value: manifestinfo.StaticSiteType,
Hint: "Internet to CDN to S3 bucket",
},
{
Value: manifestinfo.ScheduledJobType,
Hint: "Scheduled event to State Machine to Fargate",
},
}, gomock.Any())
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.prompt.(*climocks.Mockprompter).EXPECT().Confirm(initShouldDeployPrompt, initShouldDeployHelpPrompt, gomock.Any()).
Return(true, nil)
opts.initEnvCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.deployEnvCmd.(*climocks.Mockcmd).EXPECT().Execute().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.deploySvcCmd.(*climocks.MockactionCommand).EXPECT().RecommendActions().Return(nil)
},
},
"should not deploy the svc if shouldDeploy is false": {
inPromptForShouldDeploy: true,
inShouldDeploy: false,
expect: func(opts *initOpts) {
opts.prompt.(*climocks.Mockprompter).EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(manifestinfo.LoadBalancedWebServiceType, nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Ask().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Validate().Return(nil)
opts.initAppCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.initWlCmd.(*climocks.MockactionCommand).EXPECT().Execute().Return(nil)
opts.prompt.(*climocks.Mockprompter).EXPECT().Confirm(initShouldDeployPrompt, initShouldDeployHelpPrompt, gomock.Any()).
Return(false, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
opts := &initOpts{
initVars: initVars{
appName: tc.inAppName,
wkldType: tc.inWlType,
},
ShouldDeploy: tc.inShouldDeploy,
promptForShouldDeploy: tc.inPromptForShouldDeploy,
initAppCmd: climocks.NewMockactionCommand(ctrl),
initWlCmd: climocks.NewMockactionCommand(ctrl),
initEnvCmd: climocks.NewMockactionCommand(ctrl),
deployEnvCmd: climocks.NewMockcmd(ctrl),
deploySvcCmd: climocks.NewMockactionCommand(ctrl),
prompt: climocks.NewMockprompter(ctrl),
// These fields are used for logging, the values are not important for tests.
appName: &mockAppName,
initWkldVars: &initWkldVars{},
schedule: &mockSchedule,
port: &mockPort,
setupWorkloadInit: func(*initOpts, string) error { return nil },
useExistingWorkspaceForCMDs: func(opts *initOpts) error {
return nil
},
}
tc.expect(opts)
// WHEN
err := opts.Run()
// THEN
if tc.wantedError != "" {
require.EqualError(t, err, tc.wantedError)
} else {
require.NoError(t, err)
}
})
}
}
| 260 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"context"
"encoding"
"io"
"github.com/aws/aws-sdk-go/aws/session"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/codepipeline"
"github.com/aws/copilot-cli/internal/pkg/aws/ec2"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/secretsmanager"
"github.com/aws/copilot-cli/internal/pkg/aws/ssm"
clideploy "github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerfile"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/initialize"
"github.com/aws/copilot-cli/internal/pkg/logging"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/task"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
)
type cmd interface {
// Validate returns an error if a flag's value is invalid.
Validate() error
// Ask prompts for flag values that are required but not passed in.
Ask() error
// Execute runs the command after collecting all required options.
Execute() error
}
// actionCommand is the interface that every command that creates a resource implements.
type actionCommand interface {
cmd
// RecommendActions logs a list of follow-up suggestions users can run once the command executes successfully.
RecommendActions() error
}
// SSM store interfaces.
type serviceStore interface {
CreateService(svc *config.Workload) error
GetService(appName, svcName string) (*config.Workload, error)
ListServices(appName string) ([]*config.Workload, error)
DeleteService(appName, svcName string) error
}
type jobStore interface {
CreateJob(job *config.Workload) error
GetJob(appName, jobName string) (*config.Workload, error)
ListJobs(appName string) ([]*config.Workload, error)
DeleteJob(appName, jobName string) error
}
type wlStore interface {
ListWorkloads(appName string) ([]*config.Workload, error)
GetWorkload(appName, name string) (*config.Workload, error)
}
type workloadListWriter interface {
Write(appName string) error
}
type applicationStore interface {
applicationCreator
applicationUpdater
applicationGetter
applicationLister
applicationDeleter
}
type applicationCreator interface {
CreateApplication(app *config.Application) error
}
type applicationUpdater interface {
UpdateApplication(app *config.Application) error
}
type applicationGetter interface {
GetApplication(appName string) (*config.Application, error)
}
type applicationLister interface {
ListApplications() ([]*config.Application, error)
}
type applicationDeleter interface {
DeleteApplication(name string) error
}
type environmentStore interface {
environmentCreator
environmentGetter
environmentLister
environmentDeleter
}
type environmentCreator interface {
CreateEnvironment(env *config.Environment) error
}
type environmentGetter interface {
GetEnvironment(appName string, environmentName string) (*config.Environment, error)
}
type environmentLister interface {
ListEnvironments(appName string) ([]*config.Environment, error)
}
type wsEnvironmentsLister interface {
ListEnvironments() ([]string, error)
}
type environmentDeleter interface {
DeleteEnvironment(appName, environmentName string) error
}
type store interface {
applicationStore
environmentStore
serviceStore
jobStore
wlStore
}
type deployedEnvironmentLister interface {
ListEnvironmentsDeployedTo(appName, svcName string) ([]string, error)
ListDeployedServices(appName, envName string) ([]string, error)
ListDeployedJobs(appName string, envName string) ([]string, error)
IsServiceDeployed(appName, envName string, svcName string) (bool, error)
ListSNSTopics(appName string, envName string) ([]deploy.Topic, error)
}
// Secretsmanager interface.
type secretsManager interface {
secretCreator
secretDeleter
}
type secretCreator interface {
CreateSecret(secretName, secretString string) (string, error)
}
type secretDeleter interface {
DescribeSecret(secretName string) (*secretsmanager.DescribeSecretOutput, error)
DeleteSecret(secretName string) error
}
type imageBuilderPusher interface {
BuildAndPush(ctx context.Context, args *dockerengine.BuildArguments, w io.Writer) (string, error)
}
type repositoryLogin interface {
Login() (string, error)
}
type repositoryService interface {
repositoryLogin
imageBuilderPusher
}
type logEventsWriter interface {
WriteLogEvents(opts logging.WriteLogEventsOpts) error
}
type execRunner interface {
Run(name string, args []string, options ...exec.CmdOption) error
}
type eventsWriter interface {
WriteEventsUntilStopped() error
}
type defaultSessionProvider interface {
Default() (*session.Session, error)
}
type regionalSessionProvider interface {
DefaultWithRegion(region string) (*session.Session, error)
}
type sessionFromRoleProvider interface {
FromRole(roleARN string, region string) (*session.Session, error)
}
type sessionFromStaticProvider interface {
FromStaticCreds(accessKeyID, secretAccessKey, sessionToken string) (*session.Session, error)
}
type sessionFromProfileProvider interface {
FromProfile(name string) (*session.Session, error)
}
type sessionProvider interface {
defaultSessionProvider
regionalSessionProvider
sessionFromRoleProvider
sessionFromProfileProvider
sessionFromStaticProvider
}
type describer interface {
Describe() (describe.HumanJSONStringer, error)
}
type workloadDescriber interface {
describer
Manifest(string) ([]byte, error)
}
type wsFileDeleter interface {
DeleteWorkspaceFile() error
}
type manifestReader interface {
ReadWorkloadManifest(name string) (workspace.WorkloadManifest, error)
}
type environmentManifestWriter interface {
WriteEnvironmentManifest(encoding.BinaryMarshaler, string) (string, error)
}
type workspacePathGetter interface {
Path() string
}
type wsPipelineManifestReader interface {
ReadPipelineManifest(path string) (*manifest.Pipeline, error)
}
type relPath interface {
// Rel returns the path relative from the object's root path to the target path.
//
// Unlike filepath.Rel, the input path is allowed to be either relative to the
// current working directory or absolute.
Rel(path string) (string, error)
}
type wsPipelineIniter interface {
relPath
WritePipelineBuildspec(marshaler encoding.BinaryMarshaler, name string) (string, error)
WritePipelineManifest(marshaler encoding.BinaryMarshaler, name string) (string, error)
ListPipelines() ([]workspace.PipelineManifest, error)
}
type serviceLister interface {
ListServices() ([]string, error)
}
type wsSvcReader interface {
serviceLister
manifestReader
}
type jobLister interface {
ListJobs() ([]string, error)
}
type wsJobReader interface {
manifestReader
jobLister
}
type wlLister interface {
ListWorkloads() ([]string, error)
}
type wsWorkloadReader interface {
manifestReader
ReadFile(path string) ([]byte, error)
WorkloadExists(name string) (bool, error)
WorkloadAddonFilePath(wkldName, fName string) string
WorkloadAddonFileAbsPath(wkldName, fName string) string
}
type wsWorkloadReadWriter interface {
wsWorkloadReader
wsWriter
}
type wsReadWriter interface {
wsWorkloadReadWriter
wsEnvironmentReader
}
type wsJobDirReader interface {
wsJobReader
workspacePathGetter
}
type wsWlDirReader interface {
wsJobReader
wsSvcReader
workspacePathGetter
wlLister
wsEnvironmentsLister
WorkloadOverridesPath(string) string
Summary() (*workspace.Summary, error)
}
type wsEnvironmentReader interface {
wsEnvironmentsLister
HasEnvironments() (bool, error)
EnvOverridesPath() string
ReadEnvironmentManifest(mftDirName string) (workspace.EnvironmentManifest, error)
EnvAddonFilePath(fName string) string
EnvAddonFileAbsPath(fName string) string
}
type wsPipelineReader interface {
wsPipelineGetter
relPath
}
type wsPipelineGetter interface {
wsPipelineManifestReader
wlLister
ListPipelines() ([]workspace.PipelineManifest, error)
}
type wsAppManager interface {
Summary() (*workspace.Summary, error)
}
type wsAppManagerDeleter interface {
wsAppManager
wsFileDeleter
}
type wsWriter interface {
Write(content encoding.BinaryMarshaler, path string) (string, error)
}
type uploader interface {
Upload(bucket, key string, data io.Reader) (string, error)
}
type bucketEmptier interface {
EmptyBucket(bucket string) error
}
// Interfaces for deploying resources through CloudFormation. Facilitates mocking.
type environmentDeployer interface {
CreateAndRenderEnvironment(conf cloudformation.StackConfiguration, bucketARN string) error
DeleteEnvironment(appName, envName, cfnExecRoleARN string) error
GetEnvironment(appName, envName string) (*config.Environment, error)
Template(stackName string) (string, error)
UpdateEnvironmentTemplate(appName, envName, templateBody, cfnExecRoleARN string) error
}
type wlDeleter interface {
DeleteWorkload(in deploy.DeleteWorkloadInput) error
}
type svcRemoverFromApp interface {
RemoveServiceFromApp(app *config.Application, svcName string) error
}
type jobRemoverFromApp interface {
RemoveJobFromApp(app *config.Application, jobName string) error
}
type imageRemover interface {
ClearRepository(repoName string) error // implemented by ECR Service
}
type pipelineDeployer interface {
CreatePipeline(env *deploy.CreatePipelineInput, bucketName string) error
UpdatePipeline(env *deploy.CreatePipelineInput, bucketName string) error
PipelineExists(env *deploy.CreatePipelineInput) (bool, error)
DeletePipeline(pipeline deploy.Pipeline) error
AddPipelineResourcesToApp(app *config.Application, region string) error
Template(stackName string) (string, error)
appResourcesGetter
// TODO: Add StreamPipelineCreation method
}
type appDeployer interface {
DeployApp(in *deploy.CreateAppInput) error
AddServiceToApp(app *config.Application, svcName string, opts ...cloudformation.AddWorkloadToAppOpt) error
AddJobToApp(app *config.Application, jobName string, opts ...cloudformation.AddWorkloadToAppOpt) error
AddEnvToApp(opts *cloudformation.AddEnvToAppOpts) error
DelegateDNSPermissions(app *config.Application, accountID string) error
DeleteApp(name string) error
}
type appResourcesGetter interface {
GetAppResourcesByRegion(app *config.Application, region string) (*stack.AppRegionalResources, error)
GetRegionalAppResources(app *config.Application) ([]*stack.AppRegionalResources, error)
}
type taskDeployer interface {
DeployTask(input *deploy.CreateTaskResourcesInput, opts ...awscloudformation.StackOption) error
GetTaskStack(taskName string) (*deploy.TaskStackInfo, error)
}
type taskStackManager interface {
DeleteTask(task deploy.TaskStackInfo) error
GetTaskStack(taskName string) (*deploy.TaskStackInfo, error)
}
type taskRunner interface {
Run() ([]*task.Task, error)
CheckNonZeroExitCode([]*task.Task) error
}
type defaultClusterGetter interface {
HasDefaultCluster() (bool, error)
}
type deployer interface {
environmentDeployer
appDeployer
pipelineDeployer
ListTaskStacks(appName, envName string) ([]deploy.TaskStackInfo, error)
}
type domainHostedZoneGetter interface {
DomainHostedZoneID(domainName string) (string, error)
ValidateDomainOwnership(domainName string) error
}
type dockerfileParser interface {
GetExposedPorts() ([]dockerfile.Port, error)
GetHealthCheck() (*dockerfile.HealthCheck, error)
}
type statusDescriber interface {
Describe() (describe.HumanJSONStringer, error)
}
type envDescriber interface {
Describe() (*describe.EnvDescription, error)
PublicCIDRBlocks() ([]string, error)
Manifest() ([]byte, error)
ValidateCFServiceDomainAliases() error
}
type versionCompatibilityChecker interface {
versionGetter
AvailableFeatures() ([]string, error)
}
type versionGetter interface {
Version() (string, error)
}
type appUpgrader interface {
UpgradeApplication(in *deploy.CreateAppInput) error
}
type pipelineGetter interface {
GetPipeline(pipelineName string) (*codepipeline.Pipeline, error)
}
type deployedPipelineLister interface {
ListDeployedPipelines(appName string) ([]deploy.Pipeline, error)
}
type executor interface {
Execute() error
}
type executeAsker interface {
Ask() error
executor
}
type appSelector interface {
Application(prompt, help string, additionalOpts ...string) (string, error)
}
type appEnvSelector interface {
appSelector
Environment(prompt, help, app string, additionalOpts ...string) (string, error)
}
type cfnSelector interface {
Resources(msg, finalMsg, help, body string) ([]template.CFNResource, error)
}
type configSelector interface {
appEnvSelector
Service(prompt, help, app string) (string, error)
Job(prompt, help, app string) (string, error)
Workload(prompt, help, app string) (string, error)
}
type deploySelector interface {
appSelector
DeployedService(prompt, help string, app string, opts ...selector.GetDeployedWorkloadOpts) (*selector.DeployedService, error)
DeployedJob(prompt, help string, app string, opts ...selector.GetDeployedWorkloadOpts) (*selector.DeployedJob, error)
}
type pipelineEnvSelector interface {
Environments(prompt, help, app string, finalMsgFunc func(int) prompt.PromptConfig) ([]string, error)
}
type wsPipelineSelector interface {
WsPipeline(prompt, help string) (*workspace.PipelineManifest, error)
}
type wsEnvironmentSelector interface {
LocalEnvironment(msg, help string) (wl string, err error)
}
type codePipelineSelector interface {
appSelector
DeployedPipeline(prompt, help, app string) (deploy.Pipeline, error)
}
type wsSelector interface {
appEnvSelector
Service(prompt, help string) (string, error)
Job(prompt, help string) (string, error)
Workload(msg, help string) (string, error)
}
type staticSourceSelector interface {
StaticSources(selPrompt, selHelp, anotherPathPrompt, anotherPathHelp string, pathValidator prompt.ValidatorFunc) ([]string, error)
}
type scheduleSelector interface {
Schedule(scheduleTypePrompt, scheduleTypeHelp string, scheduleValidator, rateValidator prompt.ValidatorFunc) (string, error)
}
type cfTaskSelector interface {
Task(prompt, help string, opts ...selector.GetDeployedTaskOpts) (string, error)
}
type dockerfileSelector interface {
Dockerfile(selPrompt, notFoundPrompt, selHelp, notFoundHelp string, pv prompt.ValidatorFunc) (string, error)
}
type topicSelector interface {
Topics(prompt, help, app string) ([]deploy.Topic, error)
}
type ec2Selector interface {
VPC(prompt, help string) (string, error)
Subnets(input selector.SubnetsInput) ([]string, error)
}
type credsSelector interface {
Creds(prompt, help string) (*session.Session, error)
}
type ec2Client interface {
HasDNSSupport(vpcID string) (bool, error)
ListAZs() ([]ec2.AZ, error)
}
type serviceResumer interface {
ResumeService(string) error
}
type jobInitializer interface {
Job(props *initialize.JobProps) (string, error)
}
type svcInitializer interface {
Service(props *initialize.ServiceProps) (string, error)
}
type roleDeleter interface {
DeleteRole(string) error
}
type policyLister interface {
ListPolicyNames() ([]string, error)
}
type serviceDescriber interface {
DescribeService(app, env, svc string) (*ecs.ServiceDesc, error)
}
type apprunnerServiceDescriber interface {
ServiceARN(env string) (string, error)
}
type ecsCommandExecutor interface {
ExecuteCommand(in awsecs.ExecuteCommandInput) error
}
type ssmPluginManager interface {
ValidateBinary() error
InstallLatestBinary() error
}
type taskStopper interface {
StopOneOffTasks(app, env, family string) error
StopDefaultClusterTasks(familyName string) error
StopWorkloadTasks(app, env, workload string) error
}
type serviceLinkedRoleCreator interface {
CreateECSServiceLinkedRole() error
}
type roleTagsLister interface {
ListRoleTags(string) (map[string]string, error)
}
type roleManager interface {
roleTagsLister
roleDeleter
serviceLinkedRoleCreator
}
type stackExistChecker interface {
Exists(string) (bool, error)
}
type runningTaskSelector interface {
RunningTask(prompt, help string, opts ...selector.TaskOpts) (*awsecs.Task, error)
}
type dockerEngine interface {
CheckDockerEngineRunning() error
GetPlatform() (string, string, error)
}
type codestar interface {
GetConnectionARN(string) (string, error)
}
type publicIPGetter interface {
PublicIP(ENI string) (string, error)
}
type cliStringer interface {
CLIString() (string, error)
}
type secretPutter interface {
PutSecret(in ssm.PutSecretInput) (*ssm.PutSecretOutput, error)
}
type servicePauser interface {
PauseService(svcARN string) error
}
type interpolator interface {
Interpolate(s string) (string, error)
}
type workloadDeployer interface {
UploadArtifacts() (*clideploy.UploadArtifactsOutput, error)
GenerateCloudFormationTemplate(in *clideploy.GenerateCloudFormationTemplateInput) (
*clideploy.GenerateCloudFormationTemplateOutput, error)
DeployWorkload(in *clideploy.DeployWorkloadInput) (clideploy.ActionRecommender, error)
IsServiceAvailableInRegion(region string) (bool, error)
templateDiffer
}
type templateDiffer interface {
DeployDiff(inTmpl string) (string, error)
}
type workloadStackGenerator interface {
UploadArtifacts() (*clideploy.UploadArtifactsOutput, error)
GenerateCloudFormationTemplate(in *clideploy.GenerateCloudFormationTemplateInput) (
*clideploy.GenerateCloudFormationTemplateOutput, error)
AddonsTemplate() (string, error)
templateDiffer
}
type runner interface {
Run() error
}
type envDeployer interface {
DeployEnvironment(in *clideploy.DeployEnvironmentInput) error
Validate(*manifest.Environment) error
UploadArtifacts() (*clideploy.UploadEnvArtifactsOutput, error)
GenerateCloudFormationTemplate(in *clideploy.DeployEnvironmentInput) (
*clideploy.GenerateCloudFormationTemplateOutput, error)
templateDiffer
}
type envPackager interface {
GenerateCloudFormationTemplate(in *clideploy.DeployEnvironmentInput) (*clideploy.GenerateCloudFormationTemplateOutput, error)
Validate(*manifest.Environment) error
UploadArtifacts() (*clideploy.UploadEnvArtifactsOutput, error)
AddonsTemplate() (string, error)
templateDiffer
}
type pipelineStackConfig interface {
Template() (string, error)
}
| 711 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
)
// BuildJobCmd is the top level command for jobs.
func BuildJobCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "job",
Short: `Commands for jobs.
Jobs are tasks that are triggered by events.`,
Long: `Commands for jobs.
Jobs are tasks that are triggered by events.`,
}
cmd.AddCommand(buildJobInitCmd())
cmd.AddCommand(buildJobListCmd())
cmd.AddCommand(buildJobPackageCmd())
cmd.AddCommand(buildJobOverrideCmd())
cmd.AddCommand(buildJobDeployCmd())
cmd.AddCommand(buildJobDeleteCmd())
cmd.AddCommand(buildJobLogsCmd())
cmd.AddCommand(buildJobRunCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Develop,
}
return cmd
}
| 38 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/spf13/cobra"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/ecr"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
)
const (
fmtJobDeleteConfirmPrompt = "Are you sure you want to delete job %s from application %s?"
fmtJobDeleteFromEnvConfirmPrompt = "Are you sure you want to delete job %s from environment %s?"
jobDeleteAppNamePrompt = "Which application's job would you like to delete?"
jobDeleteJobNamePrompt = "Which job would you like to delete?"
jobDeleteConfirmHelp = "This will remove the job from all environments and delete it from your app."
fmtJobDeleteFromEnvConfirmHelp = "This will remove the job from just the %s environment."
)
const (
fmtJobTasksStopStart = "Stopping running tasks of job %s from environment %s."
fmtJobTasksStopFailed = "Failed to stop running tasks of job %s from environment %s: %v.\n"
fmtJobTasksStopComplete = "Stopped running tasks of job %s from environment %s.\n"
)
var (
errJobDeleteCancelled = errors.New("job delete cancelled - no changes made")
)
type deleteJobVars struct {
appName string
skipConfirmation bool
name string
envName string
}
type deleteJobOpts struct {
deleteJobVars
// Interfaces to dependencies.
store store
prompt prompter
sel configSelector
sess sessionProvider
spinner progress
appCFN jobRemoverFromApp
newWlDeleter func(sess *session.Session) wlDeleter
newImageRemover func(sess *session.Session) imageRemover
newTaskStopper func(sess *session.Session) taskStopper
}
func newDeleteJobOpts(vars deleteJobVars) (*deleteJobOpts, error) {
provider := sessions.ImmutableProvider(sessions.UserAgentExtras("job delete"))
defaultSession, err := provider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
return &deleteJobOpts{
deleteJobVars: vars,
store: store,
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
prompt: prompt.New(),
sel: selector.NewConfigSelector(prompter, store),
sess: provider,
appCFN: cloudformation.New(defaultSession, cloudformation.WithProgressTracker(os.Stderr)),
newWlDeleter: func(session *session.Session) wlDeleter {
return cloudformation.New(session, cloudformation.WithProgressTracker(os.Stderr))
},
newImageRemover: func(session *session.Session) imageRemover {
return ecr.New(session)
},
newTaskStopper: func(session *session.Session) taskStopper {
return ecs.New(session)
},
}, nil
}
// Validate returns an error if the user inputs are invalid.
func (o *deleteJobOpts) Validate() error {
if o.name != "" {
if _, err := o.store.GetJob(o.appName, o.name); err != nil {
return err
}
}
if o.envName != "" {
return o.validateEnvName()
}
return nil
}
// Ask prompts the user for any required flags.
func (o *deleteJobOpts) Ask() error {
if err := o.askAppName(); err != nil {
return err
}
if err := o.askJobName(); err != nil {
return err
}
if o.skipConfirmation {
return nil
}
// When there's no env name passed in, we'll completely
// remove the job from the application.
deletePrompt := fmt.Sprintf(fmtJobDeleteConfirmPrompt, o.name, o.appName)
deleteConfirmHelp := jobDeleteConfirmHelp
if o.envName != "" {
// When a customer provides a particular environment,
// we'll just delete the job from that environment -
// but keep it in the app.
deletePrompt = fmt.Sprintf(fmtJobDeleteFromEnvConfirmPrompt, o.name, o.envName)
deleteConfirmHelp = fmt.Sprintf(fmtJobDeleteFromEnvConfirmHelp, o.envName)
}
deleteConfirmed, err := o.prompt.Confirm(
deletePrompt,
deleteConfirmHelp,
prompt.WithConfirmFinalMessage())
if err != nil {
return fmt.Errorf("job delete confirmation prompt: %w", err)
}
if !deleteConfirmed {
return errJobDeleteCancelled
}
return nil
}
// Execute deletes the job's CloudFormation stack.
// If the job is being removed from the application, Execute will
// also delete the ECR repository and the SSM parameter.
func (o *deleteJobOpts) Execute() error {
envs, err := o.appEnvironments()
if err != nil {
return err
}
if err := o.deleteJobs(envs); err != nil {
return err
}
// Skip removing the job from the application if
// we are only removing the stack from a particular environment.
if !o.needsAppCleanup() {
return nil
}
if err := o.emptyECRRepos(envs); err != nil {
return err
}
if err := o.removeJobFromApp(); err != nil {
return err
}
if err := o.deleteSSMParam(); err != nil {
return err
}
log.Successf("Deleted job %s from application %s.\n", o.name, o.appName)
return nil
}
func (o *deleteJobOpts) validateEnvName() error {
if _, err := o.targetEnv(); err != nil {
return err
}
return nil
}
func (o *deleteJobOpts) targetEnv() (*config.Environment, error) {
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, fmt.Errorf("get environment %s from config store: %w", o.envName, err)
}
return env, nil
}
func (o *deleteJobOpts) askAppName() error {
if o.appName != "" {
return nil
}
name, err := o.sel.Application(jobDeleteAppNamePrompt, "")
if err != nil {
return fmt.Errorf("select application name: %w", err)
}
o.appName = name
return nil
}
func (o *deleteJobOpts) askJobName() error {
if o.name != "" {
return nil
}
name, err := o.sel.Job(jobDeleteJobNamePrompt, "", o.appName)
if err != nil {
return fmt.Errorf("select job: %w", err)
}
o.name = name
return nil
}
func (o *deleteJobOpts) appEnvironments() ([]*config.Environment, error) {
var envs []*config.Environment
var err error
if o.envName != "" {
env, err := o.targetEnv()
if err != nil {
return nil, err
}
envs = append(envs, env)
} else {
envs, err = o.store.ListEnvironments(o.appName)
if err != nil {
return nil, fmt.Errorf("list environments: %w", err)
}
}
return envs, nil
}
func (o *deleteJobOpts) deleteJobs(envs []*config.Environment) error {
for _, env := range envs {
sess, err := o.sess.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
// Delete job stack
if err = o.deleteStack(sess, env); err != nil {
return err
}
// Delete orphan tasks
if err = o.deleteTasks(sess, env.Name); err != nil {
return err
}
}
return nil
}
func (o *deleteJobOpts) deleteStack(sess *session.Session, env *config.Environment) error {
cfClient := o.newWlDeleter(sess)
if err := cfClient.DeleteWorkload(deploy.DeleteWorkloadInput{
Name: o.name,
EnvName: env.Name,
AppName: o.appName,
ExecutionRoleARN: env.ExecutionRoleARN,
}); err != nil {
return fmt.Errorf("delete job stack: %w", err)
}
return nil
}
func (o *deleteJobOpts) deleteTasks(sess *session.Session, env string) error {
o.spinner.Start(fmt.Sprintf(fmtJobTasksStopStart, o.name, env))
if err := o.newTaskStopper(sess).StopWorkloadTasks(o.appName, env, o.name); err != nil {
o.spinner.Stop(log.Serrorf(fmtJobTasksStopFailed, o.name, env, err))
return fmt.Errorf("stop tasks for environment %s: %w", env, err)
}
o.spinner.Stop(log.Ssuccessf(fmtJobTasksStopComplete, o.name, env))
return nil
}
func (o *deleteJobOpts) needsAppCleanup() bool {
// Only remove a job from the app if
// we're removing it from every environment.
// If we're just removing the job from one
// env, we keep the app configuration.
return o.envName == ""
}
// This is to make mocking easier in unit tests
func (o *deleteJobOpts) emptyECRRepos(envs []*config.Environment) error {
var uniqueRegions []string
for _, env := range envs {
if !contains(env.Region, uniqueRegions) {
uniqueRegions = append(uniqueRegions, env.Region)
}
}
// TODO: centralized ECR repo name
repoName := fmt.Sprintf("%s/%s", o.appName, o.name)
for _, region := range uniqueRegions {
sess, err := o.sess.DefaultWithRegion(region)
if err != nil {
return err
}
client := o.newImageRemover(sess)
if err := client.ClearRepository(repoName); err != nil {
return err
}
}
return nil
}
func (o *deleteJobOpts) removeJobFromApp() error {
proj, err := o.store.GetApplication(o.appName)
if err != nil {
return err
}
if err := o.appCFN.RemoveJobFromApp(proj, o.name); err != nil {
if !isStackSetNotExistsErr(err) {
return err
}
}
return nil
}
func (o *deleteJobOpts) deleteSSMParam() error {
if err := o.store.DeleteJob(o.appName, o.name); err != nil {
return fmt.Errorf("delete job %s in application %s from config store: %w", o.name, o.appName, err)
}
return nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *deleteJobOpts) RecommendActions() error {
logRecommendedActions([]string{
fmt.Sprintf("Run %s to update the corresponding pipeline if it exists.",
color.HighlightCode("copilot pipeline deploy")),
})
return nil
}
// buildJobDeleteCmd builds the command to delete job(s).
func buildJobDeleteCmd() *cobra.Command {
vars := deleteJobVars{}
cmd := &cobra.Command{
Use: "delete",
Short: "Deletes a job from an application.",
Example: `
Delete the "report-generator" job from the my-app application.
/code $ copilot job delete --name report-generator --app my-app
Delete the "report-generator" job from just the prod environment.
/code $ copilot job delete --name report-generator --env prod
Delete the "report-generator" job from the my-app application from outside of the workspace.
/code $ copilot job delete --name report-generator --app my-app
Delete the "report-generator" job without confirmation prompt.
/code $ copilot job delete --name report-generator --yes`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeleteJobOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", jobFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
return cmd
}
| 385 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestDeleteJobOpts_Validate(t *testing.T) {
mockError := errors.New("some error")
tests := map[string]struct {
inAppName string
inEnvName string
inName string
setupMocks func(m *mocks.Mockstore)
want error
}{
"with no flag set": {
inAppName: "phonetool",
setupMocks: func(m *mocks.Mockstore) {},
want: nil,
},
"with all flags set": {
inAppName: "phonetool",
inEnvName: "test",
inName: "resizer",
setupMocks: func(m *mocks.Mockstore) {
m.EXPECT().GetEnvironment("phonetool", "test").
Return(&config.Environment{Name: "test"}, nil)
m.EXPECT().GetJob("phonetool", "resizer").Times(1).Return(&config.Workload{
Name: "resizer",
}, nil)
},
want: nil,
},
"with env flag set": {
inAppName: "phonetool",
inEnvName: "test",
setupMocks: func(m *mocks.Mockstore) {
m.EXPECT().GetEnvironment("phonetool", "test").
Return(&config.Environment{Name: "test"}, nil)
},
want: nil,
},
"with job flag set": {
inAppName: "phonetool",
inName: "resizer",
setupMocks: func(m *mocks.Mockstore) {
m.EXPECT().GetJob("phonetool", "resizer").Times(1).Return(&config.Workload{
Name: "resizer",
}, nil)
},
want: nil,
},
"with unknown environment": {
inAppName: "phonetool",
inEnvName: "test",
setupMocks: func(m *mocks.Mockstore) {
m.EXPECT().GetEnvironment("phonetool", "test").Return(nil, errors.New("unknown env"))
},
want: errors.New("get environment test from config store: unknown env"),
},
"should return error if fail to get job name": {
inAppName: "phonetool",
inName: "resizer",
setupMocks: func(m *mocks.Mockstore) {
m.EXPECT().GetJob("phonetool", "resizer").Times(1).Return(nil, mockError)
},
want: errors.New("some error"),
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
test.setupMocks(mockstore)
opts := deleteJobOpts{
deleteJobVars: deleteJobVars{
appName: test.inAppName,
name: test.inName,
envName: test.inEnvName,
},
store: mockstore,
}
err := opts.Validate()
if test.want != nil {
require.EqualError(t, err, test.want.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestDeleteJobOpts_Ask(t *testing.T) {
const (
testAppName = "phonetool"
testJobName = "resizer"
)
mockError := errors.New("mockError")
tests := map[string]struct {
skipConfirmation bool
inName string
envName string
appName string
mockPrompt func(m *mocks.Mockprompter)
mockSel func(m *mocks.MockconfigSelector)
wantedName string
wantedError error
}{
"should ask for app name": {
appName: "",
inName: testJobName,
skipConfirmation: true,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Application("Which application's job would you like to delete?", "").Return(testAppName, nil)
},
mockPrompt: func(m *mocks.Mockprompter) {},
wantedName: testJobName,
},
"should ask for job name": {
appName: testAppName,
inName: "",
skipConfirmation: true,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job("Which job would you like to delete?", "", testAppName).Return(testJobName, nil)
},
mockPrompt: func(m *mocks.Mockprompter) {},
wantedName: testJobName,
},
"returns error if no jobs found": {
appName: testAppName,
inName: "",
skipConfirmation: true,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job("Which job would you like to delete?", "", testAppName).Return("", mockError)
},
mockPrompt: func(m *mocks.Mockprompter) {},
wantedError: fmt.Errorf("select job: %w", mockError),
},
"returns error if fail to select job": {
appName: testAppName,
inName: "",
skipConfirmation: true,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job("Which job would you like to delete?", "", testAppName).Return("", mockError)
},
mockPrompt: func(m *mocks.Mockprompter) {},
wantedError: fmt.Errorf("select job: %w", mockError),
},
"should skip confirmation": {
appName: testAppName,
inName: testJobName,
skipConfirmation: true,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
mockPrompt: func(m *mocks.Mockprompter) {},
wantedName: testJobName,
},
"should wrap error returned from prompter confirmation": {
appName: testAppName,
inName: testJobName,
skipConfirmation: false,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm(
fmt.Sprintf(fmtJobDeleteConfirmPrompt, testJobName, testAppName),
jobDeleteConfirmHelp,
gomock.Any(),
).Times(1).Return(true, mockError)
},
wantedError: fmt.Errorf("job delete confirmation prompt: %w", mockError),
},
"should return error if user does not confirm job delete": {
appName: testAppName,
inName: testJobName,
skipConfirmation: false,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm(
fmt.Sprintf(fmtJobDeleteConfirmPrompt, testJobName, testAppName),
jobDeleteConfirmHelp,
gomock.Any(),
).Times(1).Return(false, nil)
},
wantedError: errJobDeleteCancelled,
},
"should return error nil if user confirms job delete": {
appName: testAppName,
inName: testJobName,
skipConfirmation: false,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm(
fmt.Sprintf(fmtJobDeleteConfirmPrompt, testJobName, testAppName),
jobDeleteConfirmHelp,
gomock.Any(),
).Times(1).Return(true, nil)
},
wantedName: testJobName,
},
"should return error nil if user confirms job delete --env": {
appName: testAppName,
inName: testJobName,
envName: "test",
skipConfirmation: false,
mockSel: func(m *mocks.MockconfigSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm(
fmt.Sprintf(fmtJobDeleteFromEnvConfirmPrompt, testJobName, "test"),
fmt.Sprintf(fmtJobDeleteFromEnvConfirmHelp, "test"),
gomock.Any(),
).Times(1).Return(true, nil)
},
wantedName: testJobName,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockPrompter := mocks.NewMockprompter(ctrl)
mockSel := mocks.NewMockconfigSelector(ctrl)
test.mockPrompt(mockPrompter)
test.mockSel(mockSel)
opts := deleteJobOpts{
deleteJobVars: deleteJobVars{
skipConfirmation: test.skipConfirmation,
appName: test.appName,
name: test.inName,
envName: test.envName,
},
prompt: mockPrompter,
sel: mockSel,
}
got := opts.Ask()
if got != nil {
require.Equal(t, test.wantedError, got)
} else {
require.Equal(t, test.wantedName, opts.name)
}
})
}
}
type deleteJobMocks struct {
store *mocks.Mockstore
secretsmanager *mocks.MocksecretsManager
sessProvider *mocks.MocksessionProvider
appCFN *mocks.MockjobRemoverFromApp
spinner *mocks.Mockprogress
jobCFN *mocks.MockwlDeleter
ecr *mocks.MockimageRemover
ecs *mocks.MocktaskStopper
}
func TestDeleteJobOpts_Execute(t *testing.T) {
mockJobName := "resizer"
mockEnvName := "test"
mockAppName := "badgoose"
mockEnv := &config.Environment{
App: mockAppName,
Name: mockEnvName,
ManagerRoleARN: "some-arn",
Region: "us-west-2",
}
mockEnvs := []*config.Environment{mockEnv}
mockApp := &config.Application{
Name: mockAppName,
}
mockRepo := fmt.Sprintf("%s/%s", mockAppName, mockJobName)
testError := errors.New("some error")
tests := map[string]struct {
inAppName string
inEnvName string
inJobName string
setupMocks func(mocks deleteJobMocks)
wantedError error
}{
"happy path with no environment passed in as flag": {
inAppName: mockAppName,
inJobName: mockJobName,
setupMocks: func(mocks deleteJobMocks) {
gomock.InOrder(
// appEnvironments
mocks.store.EXPECT().ListEnvironments(gomock.Eq(mockAppName)).Times(1).Return(mockEnvs, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil),
// deleteStacks
mocks.jobCFN.EXPECT().DeleteWorkload(gomock.Any()).Return(nil),
// delete orphan tasks
mocks.spinner.EXPECT().Start(fmt.Sprintf(fmtJobTasksStopStart, mockJobName, mockEnvName)),
mocks.ecs.EXPECT().StopWorkloadTasks(mockAppName, mockEnvName, mockJobName).Return(nil),
mocks.spinner.EXPECT().Stop(log.Ssuccessf(fmtJobTasksStopComplete, mockJobName, mockEnvName)),
mocks.sessProvider.EXPECT().DefaultWithRegion(gomock.Any()).Return(&session.Session{}, nil),
// emptyECRRepos
mocks.ecr.EXPECT().ClearRepository(mockRepo).Return(nil),
// removeJobFromApp
mocks.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil),
mocks.appCFN.EXPECT().RemoveJobFromApp(mockApp, mockJobName).Return(nil),
// deleteSSMParam
mocks.store.EXPECT().DeleteJob(mockAppName, mockJobName).Return(nil),
)
},
wantedError: nil,
},
// A job can be deployed to multiple
// environments - and deleting it in one
// should not delete it form the entire app.
"happy path with environment passed in as flag": {
inAppName: mockAppName,
inJobName: mockJobName,
inEnvName: mockEnvName,
setupMocks: func(mocks deleteJobMocks) {
gomock.InOrder(
// appEnvironments
mocks.store.EXPECT().GetEnvironment(mockAppName, mockEnvName).Times(1).Return(mockEnv, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil),
// deleteStacks
mocks.jobCFN.EXPECT().DeleteWorkload(gomock.Any()).Return(nil),
// delete orphan tasks
mocks.spinner.EXPECT().Start(fmt.Sprintf(fmtJobTasksStopStart, mockJobName, mockEnvName)),
mocks.ecs.EXPECT().StopWorkloadTasks(mockAppName, mockEnvName, mockJobName).Return(nil),
mocks.spinner.EXPECT().Stop(log.Ssuccessf(fmtJobTasksStopComplete, mockJobName, mockEnvName)),
// It should **not** emptyECRRepos
mocks.ecr.EXPECT().ClearRepository(gomock.Any()).Return(nil).Times(0),
// It should **not** removeJobFromApp
mocks.appCFN.EXPECT().RemoveJobFromApp(gomock.Any(), gomock.Any()).Return(nil).Times(0),
// It should **not** deleteSSMParam
mocks.store.EXPECT().DeleteJob(gomock.Any(), gomock.Any()).Return(nil).Times(0),
)
},
wantedError: nil,
},
"errors when deleting stack": {
inAppName: mockAppName,
inJobName: mockJobName,
inEnvName: mockEnvName,
setupMocks: func(mocks deleteJobMocks) {
gomock.InOrder(
// appEnvironments
mocks.store.EXPECT().GetEnvironment(mockAppName, mockEnvName).Times(1).Return(mockEnv, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil),
// deleteStacks
mocks.jobCFN.EXPECT().DeleteWorkload(gomock.Any()).Return(testError),
)
},
wantedError: fmt.Errorf("delete job stack: %w", testError),
},
"errors when deleting orphan tasks: failed to stop tasks": {
inAppName: mockAppName,
inJobName: mockJobName,
inEnvName: mockEnvName,
setupMocks: func(mocks deleteJobMocks) {
gomock.InOrder(
// appEnvironments
mocks.store.EXPECT().GetEnvironment(mockAppName, mockEnvName).Times(1).Return(mockEnv, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil),
// deleteStacks
mocks.jobCFN.EXPECT().DeleteWorkload(gomock.Any()).Return(nil),
// delete orphan tasks
mocks.spinner.EXPECT().Start(fmt.Sprintf(fmtJobTasksStopStart, mockJobName, mockEnvName)),
mocks.ecs.EXPECT().StopWorkloadTasks(mockAppName, mockEnvName, mockJobName).Return(testError),
mocks.spinner.EXPECT().Stop(log.Serrorf(fmtJobTasksStopFailed, mockJobName, mockEnvName, fmt.Errorf("some error"))),
)
},
wantedError: fmt.Errorf("stop tasks for environment test: some error"),
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
// GIVEN
mockstore := mocks.NewMockstore(ctrl)
mockSecretsManager := mocks.NewMocksecretsManager(ctrl)
mockSession := mocks.NewMocksessionProvider(ctrl)
mockAppCFN := mocks.NewMockjobRemoverFromApp(ctrl)
mockJobCFN := mocks.NewMockwlDeleter(ctrl)
mockSpinner := mocks.NewMockprogress(ctrl)
mockImageRemover := mocks.NewMockimageRemover(ctrl)
mockTaskStopper := mocks.NewMocktaskStopper(ctrl)
mockGetJobCFN := func(_ *session.Session) wlDeleter {
return mockJobCFN
}
mockGetImageRemover := func(_ *session.Session) imageRemover {
return mockImageRemover
}
mockNewTaskStopper := func(_ *session.Session) taskStopper {
return mockTaskStopper
}
mocks := deleteJobMocks{
store: mockstore,
secretsmanager: mockSecretsManager,
sessProvider: mockSession,
appCFN: mockAppCFN,
spinner: mockSpinner,
jobCFN: mockJobCFN,
ecr: mockImageRemover,
ecs: mockTaskStopper,
}
test.setupMocks(mocks)
opts := deleteJobOpts{
deleteJobVars: deleteJobVars{
appName: test.inAppName,
name: test.inJobName,
envName: test.inEnvName,
},
store: mockstore,
sess: mockSession,
spinner: mockSpinner,
appCFN: mockAppCFN,
newWlDeleter: mockGetJobCFN,
newImageRemover: mockGetImageRemover,
newTaskStopper: mockNewTaskStopper,
}
// WHEN
err := opts.Execute()
// THEN
if test.wantedError != nil {
require.EqualError(t, err, test.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 499 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/spf13/cobra"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/aws/tags"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
)
type deployJobOpts struct {
deployWkldVars
store store
ws wsWlDirReader
unmarshal func(in []byte) (manifest.DynamicWorkload, error)
newInterpolator func(app, env string) interpolator
cmd execRunner
sessProvider *sessions.Provider
newJobDeployer func() (workloadDeployer, error)
envFeaturesDescriber versionCompatibilityChecker
sel wsSelector
prompt prompter
gitShortCommit string
diffWriter io.Writer
// cached variables
targetApp *config.Application
targetEnv *config.Environment
envSess *session.Session
appliedDynamicMft manifest.DynamicWorkload
rootUserARN string
}
func newJobDeployOpts(vars deployWkldVars) (*deployJobOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("job deploy"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
prompter := prompt.New()
opts := &deployJobOpts{
deployWkldVars: vars,
store: store,
ws: ws,
unmarshal: manifest.UnmarshalWorkload,
sel: selector.NewLocalWorkloadSelector(prompter, store, ws),
prompt: prompter,
sessProvider: sessProvider,
newInterpolator: newManifestInterpolator,
cmd: exec.NewCmd(),
diffWriter: os.Stdout,
}
opts.newJobDeployer = func() (workloadDeployer, error) {
// NOTE: Defined as a struct member to facilitate unit testing.
return newJobDeployer(opts)
}
return opts, nil
}
func newJobDeployer(o *deployJobOpts) (workloadDeployer, error) {
raw, err := o.ws.ReadWorkloadManifest(o.name)
if err != nil {
return nil, fmt.Errorf("read manifest file for %s: %w", o.name, err)
}
ovrdr, err := deploy.NewOverrider(o.ws.WorkloadOverridesPath(o.name), o.appName, o.envName, afero.NewOsFs(), o.sessProvider)
if err != nil {
return nil, err
}
content := o.appliedDynamicMft.Manifest()
in := deploy.WorkloadDeployerInput{
SessionProvider: o.sessProvider,
Name: o.name,
App: o.targetApp,
Env: o.targetEnv,
Image: deploy.ContainerImageIdentifier{
CustomTag: o.imageTag,
GitShortCommitTag: o.gitShortCommit,
},
Mft: content,
RawMft: raw,
EnvVersionGetter: o.envFeaturesDescriber,
Overrider: ovrdr,
}
var deployer workloadDeployer
switch t := content.(type) {
case *manifest.ScheduledJob:
deployer, err = deploy.NewJobDeployer(&in)
default:
return nil, fmt.Errorf("unknown manifest type %T while creating the CloudFormation stack", t)
}
if err != nil {
return nil, fmt.Errorf("initiate workload deployer: %w", err)
}
return deployer, nil
}
// Validate returns an error if the user inputs are invalid.
func (o *deployJobOpts) Validate() error {
if o.appName == "" {
return errNoAppInWorkspace
}
if o.name != "" {
if err := o.validateJobName(); err != nil {
return err
}
}
if o.envName != "" {
if err := o.validateEnvName(); err != nil {
return err
}
}
return nil
}
// Ask prompts the user for any required fields that are not provided.
func (o *deployJobOpts) Ask() error {
if err := o.askJobName(); err != nil {
return err
}
if err := o.askEnvName(); err != nil {
return err
}
return nil
}
// Execute builds and pushes the container image for the job.
func (o *deployJobOpts) Execute() error {
if !o.clientConfigured {
if err := o.configureClients(); err != nil {
return err
}
}
mft, err := workloadManifest(&workloadManifestInput{
name: o.name,
appName: o.appName,
envName: o.envName,
interpolator: o.newInterpolator(o.appName, o.envName),
ws: o.ws,
unmarshal: o.unmarshal,
sess: o.envSess,
})
if err != nil {
return err
}
o.appliedDynamicMft = mft
if err := validateWorkloadManifestCompatibilityWithEnv(o.ws, o.envFeaturesDescriber, mft, o.envName); err != nil {
return err
}
deployer, err := o.newJobDeployer()
if err != nil {
return err
}
serviceInRegion, err := deployer.IsServiceAvailableInRegion(o.targetEnv.Region)
if err != nil {
return fmt.Errorf("check if Scheduled Job(s) is available in region %s: %w", o.targetEnv.Region, err)
}
if !serviceInRegion {
log.Warningf(`Scheduled Job might not be available in region %s; proceed with caution.
`, o.targetEnv.Region)
}
uploadOut, err := deployer.UploadArtifacts()
if err != nil {
return fmt.Errorf("upload deploy resources for job %s: %w", o.name, err)
}
if o.showDiff {
output, err := deployer.GenerateCloudFormationTemplate(&deploy.GenerateCloudFormationTemplateInput{
StackRuntimeConfiguration: deploy.StackRuntimeConfiguration{
RootUserARN: o.rootUserARN,
Tags: o.targetApp.Tags,
EnvFileARNs: uploadOut.EnvFileARNs,
ImageDigests: uploadOut.ImageDigests,
AddonsURL: uploadOut.AddonsURL,
CustomResourceURLs: uploadOut.CustomResourceURLs,
},
})
if err != nil {
return fmt.Errorf("generate the template for job %q against environment %q: %w", o.name, o.envName, err)
}
if err := diff(deployer, output.Template, o.diffWriter); err != nil {
var errHasDiff *errHasDiff
if !errors.As(err, &errHasDiff) {
return err
}
}
contd, err := o.prompt.Confirm(continueDeploymentPrompt, "")
if err != nil {
return fmt.Errorf("ask whether to continue with the deployment: %w", err)
}
if !contd {
return nil
}
}
if _, err = deployer.DeployWorkload(&deploy.DeployWorkloadInput{
StackRuntimeConfiguration: deploy.StackRuntimeConfiguration{
ImageDigests: uploadOut.ImageDigests,
EnvFileARNs: uploadOut.EnvFileARNs,
AddonsURL: uploadOut.AddonsURL,
RootUserARN: o.rootUserARN,
Tags: tags.Merge(o.targetApp.Tags, o.resourceTags),
CustomResourceURLs: uploadOut.CustomResourceURLs,
},
Options: deploy.Options{
DisableRollback: o.disableRollback,
},
}); err != nil {
if o.disableRollback {
stackName := stack.NameForWorkload(o.targetApp.Name, o.targetEnv.Name, o.name)
rollbackCmd := fmt.Sprintf("aws cloudformation rollback-stack --stack-name %s --role-arn %s", stackName, o.targetEnv.ExecutionRoleARN)
log.Infof(`It seems like you have disabled automatic stack rollback for this deployment. To debug, you can visit the AWS console to inspect the errors.
After fixing the deployment, you can:
1. Run %s to rollback the deployment.
2. Run %s to make a new deployment.
`, color.HighlightCode(rollbackCmd), color.HighlightCode("copilot job deploy"))
}
return fmt.Errorf("deploy job %s to environment %s: %w", o.name, o.envName, err)
}
log.Successf("Deployed %s.\n", color.HighlightUserInput(o.name))
return nil
}
func (o *deployJobOpts) configureClients() error {
o.gitShortCommit = imageTagFromGit(o.cmd) // Best effort assign git tag.
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return err
}
o.targetEnv = env
app, err := o.store.GetApplication(o.appName)
if err != nil {
return err
}
o.targetApp = app
// client to retrieve an application's resources created with CloudFormation
defaultSess, err := o.sessProvider.Default()
if err != nil {
return fmt.Errorf("create default session: %w", err)
}
envSess, err := o.sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
o.envSess = envSess
// client to retrieve caller identity.
caller, err := identity.New(defaultSess).Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
o.rootUserARN = caller.RootUserARN
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: o.appName,
Env: o.envName,
ConfigStore: o.store,
})
if err != nil {
return err
}
o.envFeaturesDescriber = envDescriber
return nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *deployJobOpts) RecommendActions() error {
return nil
}
func (o *deployJobOpts) validateJobName() error {
names, err := o.ws.ListJobs()
if err != nil {
return fmt.Errorf("list jobs in the workspace: %w", err)
}
for _, name := range names {
if o.name == name {
return nil
}
}
return fmt.Errorf("job %s not found in the workspace", color.HighlightUserInput(o.name))
}
func (o *deployJobOpts) validateEnvName() error {
if _, err := o.store.GetEnvironment(o.appName, o.envName); err != nil {
return fmt.Errorf("get environment %s configuration: %w", o.envName, err)
}
return nil
}
func (o *deployJobOpts) askJobName() error {
if o.name != "" {
return nil
}
name, err := o.sel.Job("Select a job from your workspace", "")
if err != nil {
return fmt.Errorf("select job: %w", err)
}
o.name = name
return nil
}
func (o *deployJobOpts) askEnvName() error {
if o.envName != "" {
return nil
}
name, err := o.sel.Environment("Select an environment", "", o.appName)
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
o.envName = name
return nil
}
// buildJobDeployCmd builds the `job deploy` subcommand.
func buildJobDeployCmd() *cobra.Command {
vars := deployWkldVars{}
cmd := &cobra.Command{
Use: "deploy",
Short: "Deploys a job to an environment.",
Long: `Deploys a job to an environment.`,
Example: `
Deploys a job named "report-gen" to a "test" environment.
/code $ copilot job deploy --name report-gen --env test
Deploys a job with additional resource tags.
/code $ copilot job deploy --resource-tags source/revision=bb133e7,deployment/initiator=manual`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newJobDeployOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", jobFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVar(&vars.imageTag, imageTagFlag, "", imageTagFlagDescription)
cmd.Flags().StringToStringVar(&vars.resourceTags, resourceTagsFlag, nil, resourceTagsFlagDescription)
cmd.Flags().BoolVar(&vars.disableRollback, noRollbackFlag, false, noRollbackFlagDescription)
cmd.Flags().BoolVar(&vars.showDiff, diffFlag, false, diffFlagDescription)
return cmd
}
| 378 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"strings"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestJobDeployOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inAppName string
inEnvName string
inJobName string
mockWs func(m *mocks.MockwsWlDirReader)
mockStore func(m *mocks.Mockstore)
wantedError error
}{
"no existing applications": {
mockWs: func(m *mocks.MockwsWlDirReader) {},
mockStore: func(m *mocks.Mockstore) {},
wantedError: errNoAppInWorkspace,
},
"with workspace error": {
inAppName: "phonetool",
inJobName: "resizer",
mockWs: func(m *mocks.MockwsWlDirReader) {
m.EXPECT().ListJobs().Return(nil, errors.New("some error"))
},
mockStore: func(m *mocks.Mockstore) {},
wantedError: errors.New("list jobs in the workspace: some error"),
},
"with job not in workspace": {
inAppName: "phonetool",
inJobName: "resizer",
mockWs: func(m *mocks.MockwsWlDirReader) {
m.EXPECT().ListJobs().Return([]string{}, nil)
},
mockStore: func(m *mocks.Mockstore) {},
wantedError: errors.New("job resizer not found in the workspace"),
},
"with unknown environment": {
inAppName: "phonetool",
inEnvName: "test",
mockWs: func(m *mocks.MockwsWlDirReader) {},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetEnvironment("phonetool", "test").
Return(nil, errors.New("unknown env"))
},
wantedError: errors.New("get environment test configuration: unknown env"),
},
"successful validation": {
inAppName: "phonetool",
inJobName: "resizer",
inEnvName: "test",
mockWs: func(m *mocks.MockwsWlDirReader) {
m.EXPECT().ListJobs().Return([]string{"resizer"}, nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetEnvironment("phonetool", "test").
Return(&config.Environment{Name: "test"}, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockWs := mocks.NewMockwsWlDirReader(ctrl)
mockStore := mocks.NewMockstore(ctrl)
tc.mockWs(mockWs)
tc.mockStore(mockStore)
opts := deployJobOpts{
deployWkldVars: deployWkldVars{
appName: tc.inAppName,
name: tc.inJobName,
envName: tc.inEnvName,
},
ws: mockWs,
store: mockStore,
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestJobDeployOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inAppName string
inEnvName string
inJobName string
inImageTag string
wantedCalls func(m *mocks.MockwsSelector)
wantedJobName string
wantedEnvName string
wantedImageTag string
wantedError error
}{
"prompts for environment name and job names": {
inAppName: "phonetool",
inImageTag: "latest",
wantedCalls: func(m *mocks.MockwsSelector) {
m.EXPECT().Job("Select a job from your workspace", "").Return("resizer", nil)
m.EXPECT().Environment("Select an environment", "", "phonetool").Return("prod-iad", nil)
},
wantedJobName: "resizer",
wantedEnvName: "prod-iad",
wantedImageTag: "latest",
},
"don't call selector if flags are provided": {
inAppName: "phonetool",
inEnvName: "prod-iad",
inJobName: "resizer",
inImageTag: "latest",
wantedCalls: func(m *mocks.MockwsSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any()).Times(0)
m.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedJobName: "resizer",
wantedEnvName: "prod-iad",
wantedImageTag: "latest",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSel := mocks.NewMockwsSelector(ctrl)
tc.wantedCalls(mockSel)
opts := deployJobOpts{
deployWkldVars: deployWkldVars{
appName: tc.inAppName,
name: tc.inJobName,
envName: tc.inEnvName,
imageTag: tc.inImageTag,
},
sel: mockSel,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError == nil {
require.NoError(t, err)
require.Equal(t, tc.wantedJobName, opts.name)
require.Equal(t, tc.wantedEnvName, opts.envName)
require.Equal(t, tc.wantedImageTag, opts.imageTag)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
func TestJobDeployOpts_Execute(t *testing.T) {
const (
mockAppName = "phonetool"
mockJobName = "upload"
mockEnvName = "prod-iad"
)
mockError := errors.New("some error")
testCases := map[string]struct {
inShowDiff bool
mock func(m *deployMocks)
wantedDiff string
wantedError error
}{
"error out if fail to read workload manifest": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return(nil, mockError)
},
wantedError: fmt.Errorf("read manifest file for upload: some error"),
},
"error out if fail to interpolate workload manifest": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", mockError)
},
wantedError: fmt.Errorf("interpolate environment variables for upload manifest: some error"),
},
"error if fail to get a list of available features from the environment": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return(nil, mockError)
},
wantedError: fmt.Errorf("get available features of the prod-iad environment stack: some error"),
},
"error if some required features are not available in the environment": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1", "mockFeature3"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
},
wantedError: fmt.Errorf(`environment "prod-iad" is on version "v1.mock" which does not support the "mockFeature3" feature`),
},
"error if failed to upload artifacts": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(nil, mockError)
},
wantedError: fmt.Errorf("upload deploy resources for job upload: some error"),
},
"error if failed to generate the template to show diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("generate the template for job %q against environment %q: some error", mockJobName, mockEnvName),
},
"error if failed to generate the diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("", errors.New("some error"))
},
wantedError: errors.New("some error"),
},
"write 'no changes' if there is no diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, nil)
},
wantedDiff: "No changes.\n",
},
"write the correct diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, nil)
},
wantedDiff: "mock diff",
},
"error if fail to ask whether to continue the deployment": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, errors.New("some error"))
},
wantedError: errors.New("ask whether to continue with the deployment: some error"),
},
"do not deploy if asked to": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, nil)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Times(0)
},
},
"deploy if asked to": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(true, nil)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Times(1)
},
},
"error if failed to deploy service": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockJobName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Return(nil, mockError)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
},
wantedError: fmt.Errorf("deploy job upload to environment prod-iad: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployMocks{
mockDeployer: mocks.NewMockworkloadDeployer(ctrl),
mockInterpolator: mocks.NewMockinterpolator(ctrl),
mockWsReader: mocks.NewMockwsWlDirReader(ctrl),
mockEnvFeaturesDescriber: mocks.NewMockversionCompatibilityChecker(ctrl),
mockPrompter: mocks.NewMockprompter(ctrl),
}
tc.mock(m)
opts := deployJobOpts{
deployWkldVars: deployWkldVars{
appName: mockAppName,
name: mockJobName,
envName: mockEnvName,
showDiff: tc.inShowDiff,
clientConfigured: true,
},
ws: m.mockWsReader,
newJobDeployer: func() (workloadDeployer, error) {
return m.mockDeployer, nil
},
newInterpolator: func(app, env string) interpolator {
return m.mockInterpolator
},
unmarshal: func(b []byte) (manifest.DynamicWorkload, error) {
return m.mockMft, nil
},
envFeaturesDescriber: m.mockEnvFeaturesDescriber,
prompt: m.mockPrompter,
diffWriter: m.mockDiffWriter,
targetApp: &config.Application{},
targetEnv: &config.Environment{},
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedError == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
if tc.wantedDiff != "" {
require.Equal(t, tc.wantedDiff, m.mockDiffWriter.String())
}
})
}
}
| 480 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerfile"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/initialize"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
var (
jobInitSchedulePrompt = "How would you like to " + color.Emphasize("schedule") + " this job?"
jobInitScheduleHelp = `How to determine this job's schedule. "Rate" lets you define the time between
executions and is good for jobs which need to run frequently. "Fixed Schedule"
lets you use a predefined or custom cron schedule and is good for less-frequent
jobs or those which require specific execution schedules.`
jobInitTypeHelp = fmt.Sprintf(`A %s is a task which is invoked on a set schedule, with optional retry logic.
To learn more see: https://git.io/JEEU4`, manifestinfo.ScheduledJobType)
)
var jobTypeHints = map[string]string{
manifestinfo.ScheduledJobType: "Scheduled event to State Machine to Fargate",
}
type initJobVars struct {
initWkldVars
timeout string
retries int
schedule string
}
type initJobOpts struct {
initJobVars
// Interfaces to interact with dependencies.
fs afero.Fs
store store
init jobInitializer
prompt prompter
dockerEngine dockerEngine
mftReader manifestReader
dockerfileSel dockerfileSelector
scheduleSelector scheduleSelector
// Outputs stored on successful actions.
manifestPath string
manifestExists bool
platform *manifest.PlatformString
// For workspace validation.
wsPendingCreation bool
wsAppName string
initParser func(path string) dockerfileParser
initEnvDescriber func(appName, envName string) (envDescriber, error)
newAppVersionGetter func(appName string) (versionGetter, error)
// Overridden in tests.
templateVersion string
}
func newInitJobOpts(vars initJobVars) (*initJobOpts, error) {
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
p := sessions.ImmutableProvider(sessions.UserAgentExtras("job init"))
sess, err := p.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(sess), ssm.New(sess), aws.StringValue(sess.Config.Region))
jobInitter := &initialize.WorkloadInitializer{
Store: store,
Ws: ws,
Prog: termprogress.NewSpinner(log.DiagnosticWriter),
Deployer: cloudformation.New(sess, cloudformation.WithProgressTracker(os.Stderr)),
}
prompter := prompt.New()
dockerfileSel, err := selector.NewDockerfileSelector(prompter, fs)
if err != nil {
return nil, err
}
return &initJobOpts{
initJobVars: vars,
fs: fs,
store: store,
init: jobInitter,
prompt: prompter,
dockerfileSel: dockerfileSel,
scheduleSelector: selector.NewStaticSelector(prompter),
dockerEngine: dockerengine.New(exec.NewCmd()),
mftReader: ws,
initParser: func(path string) dockerfileParser {
return dockerfile.New(fs, path)
},
initEnvDescriber: func(appName string, envName string) (envDescriber, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: store,
})
if err != nil {
return nil, err
}
return envDescriber, nil
},
newAppVersionGetter: func(appName string) (versionGetter, error) {
return describe.NewAppDescriber(appName)
},
wsAppName: tryReadingAppName(),
templateVersion: version.LatestTemplateVersion(),
}, nil
}
// Validate returns an error if the flag values passed by the user are invalid.
func (o *initJobOpts) Validate() error {
// If this app is pending creation, we'll skip validation.
if !o.wsPendingCreation {
if err := validateWorkspaceApp(o.wsAppName, o.appName, o.store); err != nil {
return err
}
o.appName = o.wsAppName
}
if o.dockerfilePath != "" && o.image != "" {
return fmt.Errorf("--%s and --%s cannot be specified together", dockerFileFlag, imageFlag)
}
if o.dockerfilePath != "" {
if _, err := o.fs.Stat(o.dockerfilePath); err != nil {
return err
}
}
if o.timeout != "" {
if err := validateTimeout(o.timeout); err != nil {
return err
}
}
if o.retries < 0 {
return errors.New("number of retries must be non-negative")
}
return nil
}
// Ask prompts for fields that are required but not passed in.
func (o *initJobOpts) Ask() error {
if o.wkldType != "" {
if err := validateJobType(o.wkldType); err != nil {
return err
}
} else {
if err := o.askJobType(); err != nil {
return err
}
}
if o.name == "" {
if err := o.askJobName(); err != nil {
return err
}
}
if err := validateJobName(o.name); err != nil {
return err
}
if err := o.validateDuplicateJob(); err != nil {
return err
}
if !o.wsPendingCreation {
localMft, err := o.mftReader.ReadWorkloadManifest(o.name)
if err == nil {
jobType, err := localMft.WorkloadType()
if err != nil {
return fmt.Errorf(`read "type" field for job %s from local manifest: %w`, o.name, err)
}
if o.wkldType != jobType {
return fmt.Errorf("manifest file for job %s exists with a different type %s", o.name, jobType)
}
log.Infof("Manifest file for job %s already exists. Skipping configuration.\n", o.name)
o.manifestExists = true
return nil
}
var errNotFound *workspace.ErrFileNotExists
if !errors.As(err, &errNotFound) {
return fmt.Errorf("read manifest file for job %s: %w", o.name, err)
}
}
dfSelected, err := o.askDockerfile()
if err != nil {
return err
}
if !dfSelected {
if err := o.askImage(); err != nil {
return err
}
}
if o.schedule == "" {
if err := o.askSchedule(); err != nil {
return err
}
}
if err := validateSchedule(o.schedule); err != nil {
return err
}
return nil
}
// envsWithPrivateSubnetsOnly returns the list of environments names deployed that contains only private subnets.
func envsWithPrivateSubnetsOnly(store store, initEnvDescriber func(string, string) (envDescriber, error), appName string) ([]string, error) {
envs, err := store.ListEnvironments(appName)
if err != nil {
return nil, fmt.Errorf("list environments for application %s: %w", appName, err)
}
var privateOnlyEnvs []string
for _, env := range envs {
envDescriber, err := initEnvDescriber(appName, env.Name)
if err != nil {
return nil, err
}
mft, err := envDescriber.Manifest()
if err != nil {
return nil, fmt.Errorf("read the manifest used to deploy environment %s: %w", env.Name, err)
}
envConfig, err := manifest.UnmarshalEnvironment(mft)
if err != nil {
return nil, fmt.Errorf("unmarshal the manifest used to deploy environment %s: %w", env.Name, err)
}
subnets := envConfig.Network.VPC.Subnets
if len(subnets.Public) == 0 && len(subnets.Private) != 0 {
privateOnlyEnvs = append(privateOnlyEnvs, env.Name)
}
}
return privateOnlyEnvs, err
}
// Execute writes the job's manifest file, creates an ECR repo, and stores the name in SSM.
func (o *initJobOpts) Execute() error {
if !o.allowAppDowngrade {
appVersionGetter, err := o.newAppVersionGetter(o.appName)
if err != nil {
return err
}
if err := validateAppVersion(appVersionGetter, o.appName, o.templateVersion); err != nil {
return err
}
}
// Check for a valid healthcheck and add it to the opts.
var hc manifest.ContainerHealthCheck
var err error
if o.dockerfilePath != "" {
hc, err = parseHealthCheck(o.initParser(o.dockerfilePath))
if err != nil {
log.Warningf("Cannot parse the HEALTHCHECK instruction from the Dockerfile: %v\n", err)
}
}
// If the user passes in an image, their docker engine isn't necessarily running, and we can't do anything with the platform because we're not building the Docker image.
if o.image == "" && !o.manifestExists {
platform, err := legitimizePlatform(o.dockerEngine, o.wkldType)
if err != nil {
return err
}
if platform != "" {
o.platform = &platform
}
}
envs, err := envsWithPrivateSubnetsOnly(o.store, o.initEnvDescriber, o.appName)
if err != nil {
return err
}
manifestPath, err := o.init.Job(&initialize.JobProps{
WorkloadProps: initialize.WorkloadProps{
App: o.appName,
Name: o.name,
Type: o.wkldType,
DockerfilePath: o.dockerfilePath,
Image: o.image,
Platform: manifest.PlatformArgsOrString{
PlatformString: o.platform,
},
PrivateOnlyEnvironments: envs,
},
Schedule: o.schedule,
HealthCheck: hc,
Timeout: o.timeout,
Retries: o.retries,
})
if err != nil {
return err
}
o.manifestPath = manifestPath
return nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *initJobOpts) RecommendActions() error {
logRecommendedActions([]string{
fmt.Sprintf("Update your manifest %s to change the defaults.", color.HighlightResource(o.manifestPath)),
fmt.Sprintf("Run %s to deploy your job to a %s environment.",
color.HighlightCode(fmt.Sprintf("copilot job deploy --name %s --env %s", o.name, defaultEnvironmentName)),
defaultEnvironmentName),
})
return nil
}
func (o *initJobOpts) validateDuplicateJob() error {
_, err := o.store.GetJob(o.appName, o.name)
if err == nil {
log.Errorf(`It seems like you are trying to init a job that already exists.
To recreate the job, please run:
1. %s. Note: The manifest file will not be deleted and will be used in Step 2.
If you'd prefer a new default manifest, please manually delete the existing one.
2. And then %s
`,
color.HighlightCode(fmt.Sprintf("copilot job delete --name %s", o.name)),
color.HighlightCode(fmt.Sprintf("copilot job init --name %s", o.name)))
return fmt.Errorf("job %s already exists", color.HighlightUserInput(o.name))
}
var errNoSuchJob *config.ErrNoSuchJob
if !errors.As(err, &errNoSuchJob) {
return fmt.Errorf("validate if job exists: %w", err)
}
return nil
}
func (o *initJobOpts) askJobType() error {
if o.wkldType != "" {
return nil
}
// short circuit since there's only one valid job type.
o.wkldType = manifestinfo.ScheduledJobType
return nil
}
func (o *initJobOpts) askJobName() error {
if o.name != "" {
return nil
}
name, err := o.prompt.Get(
fmt.Sprintf(fmtWkldInitNamePrompt, color.Emphasize("name"), "job"),
fmt.Sprintf(fmtWkldInitNameHelpPrompt, "job", o.appName),
func(val interface{}) error {
return validateJobName(val)
},
prompt.WithFinalMessage("Job name:"),
)
if err != nil {
return fmt.Errorf("get job name: %w", err)
}
o.name = name
return nil
}
func (o *initJobOpts) askImage() error {
if o.image != "" {
return nil
}
image, err := o.prompt.Get(wkldInitImagePrompt, wkldInitImagePromptHelp, nil,
prompt.WithFinalMessage("Image:"))
if err != nil {
return fmt.Errorf("get image location: %w", err)
}
o.image = image
return nil
}
// isDfSelected indicates if any Dockerfile is in use.
func (o *initJobOpts) askDockerfile() (isDfSelected bool, err error) {
if o.dockerfilePath != "" || o.image != "" {
return true, nil
}
if err = o.dockerEngine.CheckDockerEngineRunning(); err != nil {
var errDaemon *dockerengine.ErrDockerDaemonNotResponsive
switch {
case errors.Is(err, dockerengine.ErrDockerCommandNotFound):
log.Info("Docker command is not found; Copilot won't build from a Dockerfile.\n")
return false, nil
case errors.As(err, &errDaemon):
log.Info("Docker daemon is not responsive; Copilot won't build from a Dockerfile.\n")
return false, nil
default:
return false, fmt.Errorf("check if docker engine is running: %w", err)
}
}
df, err := o.dockerfileSel.Dockerfile(
fmt.Sprintf(fmtWkldInitDockerfilePrompt, color.HighlightUserInput(o.name)),
fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, color.HighlightUserInput(o.name)),
wkldInitDockerfileHelpPrompt,
wkldInitDockerfilePathHelpPrompt,
func(v interface{}) error {
return validatePath(afero.NewOsFs(), v)
},
)
if err != nil {
return false, fmt.Errorf("select Dockerfile: %w", err)
}
if df == selector.DockerfilePromptUseImage {
return false, nil
}
o.dockerfilePath = df
return true, nil
}
func (o *initJobOpts) askSchedule() error {
schedule, err := o.scheduleSelector.Schedule(
jobInitSchedulePrompt,
jobInitScheduleHelp,
validateSchedule,
validateRate,
)
if err != nil {
return fmt.Errorf("get schedule: %w", err)
}
o.schedule = schedule
return nil
}
func jobTypePromptOpts() []prompt.Option {
var options []prompt.Option
for _, jobType := range manifestinfo.JobTypes() {
options = append(options, prompt.Option{
Value: jobType,
Hint: jobTypeHints[jobType],
})
}
return options
}
// buildJobInitCmd builds the command for creating a new job.
func buildJobInitCmd() *cobra.Command {
vars := initJobVars{}
cmd := &cobra.Command{
Use: "init",
Short: "Creates a new scheduled job in an application.",
Example: `
Create a "reaper" scheduled task to run once per day.
/code $ copilot job init --name reaper --dockerfile ./frontend/Dockerfile --schedule "every 2 hours"
Create a "report-generator" scheduled task with retries.
/code $ copilot job init --name report-generator --schedule "@monthly" --retries 3 --timeout 900s`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newInitJobOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", jobFlagDescription)
cmd.Flags().StringVarP(&vars.wkldType, jobTypeFlag, typeFlagShort, "", jobTypeFlagDescription)
cmd.Flags().StringVarP(&vars.dockerfilePath, dockerFileFlag, dockerFileFlagShort, "", dockerFileFlagDescription)
cmd.Flags().StringVarP(&vars.schedule, scheduleFlag, scheduleFlagShort, "", scheduleFlagDescription)
cmd.Flags().StringVar(&vars.timeout, timeoutFlag, "", timeoutFlagDescription)
cmd.Flags().IntVar(&vars.retries, retriesFlag, 0, retriesFlagDescription)
cmd.Flags().StringVarP(&vars.image, imageFlag, imageFlagShort, "", imageFlagDescription)
cmd.Flags().BoolVar(&vars.allowAppDowngrade, allowDowngradeFlag, false, allowDowngradeFlagDescription)
cmd.Annotations = map[string]string{
"group": group.Develop,
}
return cmd
}
| 499 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"path/filepath"
"testing"
"time"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerfile"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/initialize"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/golang/mock/gomock"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
)
type initJobMocks struct {
mockPrompt *mocks.Mockprompter
mockDockerEngine *mocks.MockdockerEngine
mockMftReader *mocks.MockmanifestReader
mockStore *mocks.Mockstore
mockDockerfileSel *mocks.MockdockerfileSelector
mockScheduleSel *mocks.MockscheduleSelector
}
func TestJobInitOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inAppName string
inJobName string
inDockerfilePath string
inImage string
inTimeout string
inRetries int
setupMocks func(mocks initJobMocks)
mockFileSystem func(mockFS afero.Fs)
wantedErr error
}{
"fail if using different app name with the workspace": {
inAppName: "demo",
wantedErr: fmt.Errorf("cannot specify app demo because the workspace is already registered with app phonetool"),
},
"fail if cannot validate application": {
inAppName: "phonetool",
inDockerfilePath: "mockDockerfile",
inImage: "mockImage",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(nil, errors.New("some error"))
},
wantedErr: fmt.Errorf("get application phonetool configuration: some error"),
},
"invalid dockerfile directory path": {
inAppName: "phonetool",
inDockerfilePath: "./hello/Dockerfile",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("open %s: file does not exist", filepath.FromSlash("hello/Dockerfile")),
},
"invalid timeout duration; incorrect format": {
inAppName: "phonetool",
inTimeout: "30 minutes",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("timeout value 30 minutes is invalid: %s", errDurationInvalid),
},
"invalid timeout duration; subseconds": {
inAppName: "phonetool",
inTimeout: "30m45.5s",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("timeout value 30m45.5s is invalid: %s", errDurationBadUnits),
},
"invalid timeout duration; milliseconds": {
inAppName: "phonetool",
inTimeout: "3ms",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("timeout value 3ms is invalid: %s", errDurationBadUnits),
},
"invalid timeout; too short": {
inAppName: "phonetool",
inTimeout: "0s",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: errors.New("timeout value 0s is invalid: duration must be 1s or greater"),
},
"invalid number of times to retry": {
inAppName: "phonetool",
inRetries: -3,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: errors.New("number of retries must be non-negative"),
},
"fail if both image and dockerfile are set": {
inAppName: "phonetool",
inDockerfilePath: "mockDockerfile",
inImage: "mockImage",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("--dockerfile and --image cannot be specified together"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
mocks := initJobMocks{
mockStore: mockstore,
}
if tc.setupMocks != nil {
tc.setupMocks(mocks)
}
opts := initJobOpts{
initJobVars: initJobVars{
initWkldVars: initWkldVars{
appName: tc.inAppName,
name: tc.inJobName,
image: tc.inImage,
dockerfilePath: tc.inDockerfilePath,
},
timeout: tc.inTimeout,
retries: tc.inRetries,
},
store: mockstore,
fs: &afero.Afero{Fs: afero.NewMemMapFs()},
wsAppName: "phonetool",
}
if tc.mockFileSystem != nil {
tc.mockFileSystem(opts.fs)
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestJobInitOpts_Ask(t *testing.T) {
const (
mockAppName = "phonetool"
wantedJobType = manifestinfo.ScheduledJobType
wantedJobName = "cuteness-aggregator"
wantedDockerfilePath = "cuteness-aggregator/Dockerfile"
wantedImage = "mockImage"
wantedCronSchedule = "0 9-17 * * MON-FRI"
)
mockError := errors.New("mock error")
testCases := map[string]struct {
inJobType string
inJobName string
inImage string
inDockerfilePath string
inJobSchedule string
setupMocks func(mocks initJobMocks)
wantedErr error
wantedSchedule string
}{
"invalid job type": {
inJobType: "TestJobType",
wantedErr: errors.New(`invalid job type TestJobType: must be one of "Scheduled Job"`),
},
"invalid job name": {
inJobType: wantedJobType,
inJobName: "1234",
wantedErr: fmt.Errorf("job name 1234 is invalid: %s", errBasicNameRegexNotMatched),
},
"error if fail to get job name": {
inJobType: wantedJobType,
inJobName: "",
inDockerfilePath: wantedDockerfilePath,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockPrompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return("", mockError)
},
wantedErr: fmt.Errorf("get job name: mock error"),
},
"returns an error if job already exists": {
inJobType: wantedJobType,
inJobName: "",
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m initJobMocks) {
m.mockPrompt.EXPECT().Get(gomock.Eq("What do you want to name this job?"), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedJobName, nil)
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(&config.Workload{}, nil)
},
wantedErr: fmt.Errorf("job cuteness-aggregator already exists"),
},
"returns an error if fail to validate service existence": {
inJobType: wantedJobType,
inJobName: "",
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m initJobMocks) {
m.mockPrompt.EXPECT().Get(gomock.Eq("What do you want to name this job?"), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedJobName, nil)
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, mockError)
},
wantedErr: fmt.Errorf("validate if job exists: mock error"),
},
"prompt for job name": {
inJobType: wantedJobType,
inJobName: "",
inDockerfilePath: wantedDockerfilePath,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockPrompt.EXPECT().Get(gomock.Eq(
"What do you want to name this job?"),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(wantedJobName, nil)
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
},
wantedSchedule: wantedCronSchedule,
},
"error if fail to get local manifest": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: wantedDockerfilePath,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, mockError)
},
wantedErr: fmt.Errorf("read manifest file for job cuteness-aggregator: mock error"),
},
"error if manifest type doesn't match": {
inJobType: "Scheduled Job",
inJobName: wantedJobName,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return([]byte(`
type: Backend Service`), nil)
},
wantedErr: fmt.Errorf("manifest file for job cuteness-aggregator exists with a different type Backend Service"),
},
"skip asking questions if local manifest file exists": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: wantedDockerfilePath,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return([]byte(`name: cuteness-aggregator
type: Scheduled Job`), nil)
},
wantedSchedule: wantedCronSchedule,
},
"skip selecting Dockerfile if image flag is set": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inImage: "mockImage",
inDockerfilePath: "",
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
},
wantedSchedule: wantedCronSchedule,
},
"return error if fail to check if docker engine is running": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(errors.New("some error"))
},
wantedErr: fmt.Errorf("check if docker engine is running: some error"),
},
"skip selecting Dockerfile if docker command is not found": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("mockImage", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(dockerengine.ErrDockerCommandNotFound)
},
wantedSchedule: wantedCronSchedule,
},
"skip selecting Dockerfile if docker engine is not responsive": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("mockImage", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(&dockerengine.ErrDockerDaemonNotResponsive{})
},
wantedSchedule: wantedCronSchedule,
},
"returns an error if fail to get image location": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: "",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("", mockError)
m.mockDockerfileSel.EXPECT().Dockerfile(
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePrompt, wantedJobName)),
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, wantedJobName)),
gomock.Eq(wkldInitDockerfileHelpPrompt),
gomock.Eq(wkldInitDockerfilePathHelpPrompt),
gomock.Any(),
).Return("Use an existing image instead", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
wantedErr: fmt.Errorf("get image location: mock error"),
},
"using existing image": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inJobSchedule: wantedCronSchedule,
inDockerfilePath: "",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("mockImage", nil)
m.mockDockerfileSel.EXPECT().Dockerfile(
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePrompt, wantedJobName)),
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, wantedJobName)),
gomock.Eq(wkldInitDockerfileHelpPrompt),
gomock.Eq(wkldInitDockerfilePathHelpPrompt),
gomock.Any(),
).Return("Use an existing image instead", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
wantedSchedule: wantedCronSchedule,
},
"prompt for existing dockerfile": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: "",
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockDockerfileSel.EXPECT().Dockerfile(
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePrompt, color.HighlightUserInput(wantedJobName))),
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, color.HighlightUserInput(wantedJobName))),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("cuteness-aggregator/Dockerfile", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
wantedSchedule: wantedCronSchedule,
},
"error if fail to get dockerfile": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: "",
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockDockerfileSel.EXPECT().Dockerfile(
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePrompt, color.HighlightUserInput(wantedJobName))),
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, color.HighlightUserInput(wantedJobName))),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
wantedErr: fmt.Errorf("select Dockerfile: some error"),
},
"asks for schedule": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: wantedDockerfilePath,
inJobSchedule: "",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{})
m.mockScheduleSel.EXPECT().Schedule(
gomock.Eq(jobInitSchedulePrompt),
gomock.Eq(jobInitScheduleHelp),
gomock.Any(),
gomock.Any(),
).Return(wantedCronSchedule, nil)
},
wantedSchedule: wantedCronSchedule,
},
"error getting schedule": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: wantedDockerfilePath,
inJobSchedule: "",
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
m.mockScheduleSel.EXPECT().Schedule(
gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", fmt.Errorf("some error"))
},
wantedErr: fmt.Errorf("get schedule: some error"),
},
"valid schedule": {
inJobType: wantedJobType,
inJobName: wantedJobName,
inDockerfilePath: wantedDockerfilePath,
inJobSchedule: wantedCronSchedule,
setupMocks: func(m initJobMocks) {
m.mockStore.EXPECT().GetJob(mockAppName, wantedJobName).Return(nil, &config.ErrNoSuchJob{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedJobName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedJobName})
},
wantedSchedule: wantedCronSchedule,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := initJobMocks{
mockPrompt: mocks.NewMockprompter(ctrl),
mockDockerfileSel: mocks.NewMockdockerfileSelector(ctrl),
mockScheduleSel: mocks.NewMockscheduleSelector(ctrl),
mockDockerEngine: mocks.NewMockdockerEngine(ctrl),
mockMftReader: mocks.NewMockmanifestReader(ctrl),
mockStore: mocks.NewMockstore(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(m)
}
opts := &initJobOpts{
initJobVars: initJobVars{
initWkldVars: initWkldVars{
wkldType: tc.inJobType,
name: tc.inJobName,
image: tc.inImage,
dockerfilePath: tc.inDockerfilePath,
appName: mockAppName,
},
schedule: tc.inJobSchedule,
},
dockerfileSel: m.mockDockerfileSel,
scheduleSelector: m.mockScheduleSel,
store: m.mockStore,
dockerEngine: m.mockDockerEngine,
mftReader: m.mockMftReader,
prompt: m.mockPrompt,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
return
}
require.NoError(t, err)
require.Equal(t, wantedJobType, opts.wkldType)
require.Equal(t, wantedJobName, opts.name)
if opts.dockerfilePath != "" {
require.Equal(t, wantedDockerfilePath, opts.dockerfilePath)
}
if opts.image != "" {
require.Equal(t, wantedImage, opts.image)
}
require.Equal(t, tc.wantedSchedule, opts.schedule)
})
}
}
func TestJobInitOpts_Execute(t *testing.T) {
mockEnvironmentManifest := []byte(`name: test
type: Environment
network:
vpc:
id: 'vpc-mockid'
subnets:
private:
- id: 'subnet-1'
- id: 'subnet-2'
- id: 'subnet-3'
- id: 'subnet-4'`)
second := time.Second
zero := 0
testCases := map[string]struct {
mockJobInit func(m *mocks.MockjobInitializer)
mockDockerfile func(m *mocks.MockdockerfileParser)
mockDockerEngine func(m *mocks.MockdockerEngine)
mockStore func(m *mocks.Mockstore)
mockEnvDescriber func(m *mocks.MockenvDescriber)
inApp string
inName string
inType string
inDf string
inSchedule string
inManifestExists bool
wantedErr error
wantedManifestPath string
}{
"success on typical job props": {
inApp: "sample",
inName: "mailer",
inType: manifestinfo.ScheduledJobType,
inDf: "./Dockerfile",
inSchedule: "@hourly",
wantedManifestPath: "manifest/path",
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(&dockerfile.HealthCheck{
Cmd: []string{"mockCommand"},
Interval: second,
Timeout: second,
StartPeriod: second,
Retries: zero,
}, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockJobInit: func(m *mocks.MockjobInitializer) {
m.EXPECT().Job(&initialize.JobProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "mailer",
Type: "Scheduled Job",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
},
Schedule: "@hourly",
HealthCheck: manifest.ContainerHealthCheck{
Command: []string{"mockCommand"},
Interval: &second,
Retries: &zero,
Timeout: &second,
StartPeriod: &second,
},
}).Return("manifest/path", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
},
"fail to init job": {
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("").Return(nil, nil)
},
mockJobInit: func(m *mocks.MockjobInitializer) {
m.EXPECT().Job(gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: errors.New("some error"),
},
"doesn't attempt to detect and populate the platform if manifest already exists": {
inApp: "sample",
inName: "mailer",
inType: manifestinfo.ScheduledJobType,
inDf: "./Dockerfile",
inSchedule: "@hourly",
inManifestExists: true,
wantedManifestPath: "manifest/path",
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(&dockerfile.HealthCheck{
Cmd: []string{"mockCommand"},
Interval: second,
Timeout: second,
StartPeriod: second,
Retries: zero,
}, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Times(0)
m.EXPECT().GetPlatform().Times(0)
},
mockJobInit: func(m *mocks.MockjobInitializer) {
m.EXPECT().Job(&initialize.JobProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "mailer",
Type: "Scheduled Job",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
},
Schedule: "@hourly",
HealthCheck: manifest.ContainerHealthCheck{
Command: []string{"mockCommand"},
Interval: &second,
Retries: &zero,
Timeout: &second,
StartPeriod: &second,
},
}).Return("manifest/path", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
},
"doesn't complain if docker is unavailable": {
inApp: "sample",
inName: "mailer",
inType: manifestinfo.ScheduledJobType,
inDf: "./Dockerfile",
inSchedule: "@hourly",
wantedManifestPath: "manifest/path",
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(&dockerfile.HealthCheck{
Cmd: []string{"mockCommand"},
Interval: second,
Timeout: second,
StartPeriod: second,
Retries: zero,
}, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(dockerengine.ErrDockerCommandNotFound)
m.EXPECT().GetPlatform().Times(0)
},
mockJobInit: func(m *mocks.MockjobInitializer) {
m.EXPECT().Job(&initialize.JobProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "mailer",
Type: "Scheduled Job",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
},
Schedule: "@hourly",
HealthCheck: manifest.ContainerHealthCheck{
Command: []string{"mockCommand"},
Interval: &second,
Retries: &zero,
Timeout: &second,
StartPeriod: &second,
},
}).Return("manifest/path", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
},
"return error if platform detection fails": {
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("", "", errors.New("some error"))
},
wantedErr: errors.New("get docker engine platform: some error"),
},
"initialize a job in environments with only private subnets": {
inApp: "sample",
inName: "mailer",
inType: manifestinfo.ScheduledJobType,
inDf: "./Dockerfile",
inSchedule: "@hourly",
wantedManifestPath: "manifest/path",
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(&dockerfile.HealthCheck{
Cmd: []string{"mockCommand"},
Interval: second,
Timeout: second,
StartPeriod: second,
Retries: zero,
}, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockJobInit: func(m *mocks.MockjobInitializer) {
m.EXPECT().Job(&initialize.JobProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "mailer",
Type: "Scheduled Job",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
PrivateOnlyEnvironments: []string{"test"},
},
Schedule: "@hourly",
HealthCheck: manifest.ContainerHealthCheck{
Command: []string{"mockCommand"},
Interval: &second,
Retries: &zero,
Timeout: &second,
StartPeriod: &second,
},
}).Return("manifest/path", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return([]*config.Environment{
{
App: "sample",
Name: "test",
},
}, nil)
},
mockEnvDescriber: func(m *mocks.MockenvDescriber) {
m.EXPECT().Manifest().Return(mockEnvironmentManifest, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockJobInitializer := mocks.NewMockjobInitializer(ctrl)
mockDockerfile := mocks.NewMockdockerfileParser(ctrl)
mockDockerEngine := mocks.NewMockdockerEngine(ctrl)
mockStore := mocks.NewMockstore(ctrl)
mockEnvDescriber := mocks.NewMockenvDescriber(ctrl)
if tc.mockJobInit != nil {
tc.mockJobInit(mockJobInitializer)
}
if tc.mockDockerfile != nil {
tc.mockDockerfile(mockDockerfile)
}
if tc.mockDockerEngine != nil {
tc.mockDockerEngine(mockDockerEngine)
}
if tc.mockStore != nil {
tc.mockStore(mockStore)
}
if tc.mockEnvDescriber != nil {
tc.mockEnvDescriber(mockEnvDescriber)
}
opts := initJobOpts{
initJobVars: initJobVars{
initWkldVars: initWkldVars{
appName: tc.inApp,
name: tc.inName,
wkldType: tc.inType,
dockerfilePath: tc.inDf,
allowAppDowngrade: true,
},
schedule: tc.inSchedule,
},
init: mockJobInitializer,
initParser: func(s string) dockerfileParser {
return mockDockerfile
},
dockerEngine: mockDockerEngine,
manifestExists: tc.inManifestExists,
store: mockStore,
initEnvDescriber: func(string, string) (envDescriber, error) {
return mockEnvDescriber, nil
},
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedErr == nil {
require.NoError(t, err)
require.Equal(t, tc.wantedManifestPath, opts.manifestPath)
} else {
require.EqualError(t, err, tc.wantedErr.Error())
}
})
}
}
func Test_ValidateSchedule(t *testing.T) {
testCases := map[string]struct {
inSchedule string
wantedErr error
}{
"invalid schedule; not cron": {
inSchedule: "every 56 minutes",
wantedErr: fmt.Errorf("schedule every 56 minutes is invalid: %s", errScheduleInvalid),
},
"invalid schedule; cron interval in subseconds": {
inSchedule: "@every 75.9s",
wantedErr: fmt.Errorf("interval @every 75.9s is invalid: %s", errDurationBadUnits),
},
"invalid schedule; cron interval in milliseconds": {
inSchedule: "@every 3ms",
wantedErr: fmt.Errorf("interval @every 3ms is invalid: %s", errDurationBadUnits),
},
"invalid schedule; cron interval too frequent": {
inSchedule: "@every 30s",
wantedErr: errors.New("interval @every 30s is invalid: duration must be 1m0s or greater"),
},
"invalid schedule; cron interval is zero": {
inSchedule: "@every 0s",
wantedErr: errors.New("interval @every 0s is invalid: duration must be 1m0s or greater"),
},
"invalid schedule; cron interval duration improperly formed": {
inSchedule: "@every 5min",
wantedErr: errors.New("interval @every 5min must include a valid Go duration string (example: @every 1h30m)"),
},
"valid schedule; crontab": {
inSchedule: "* * * * *",
wantedErr: nil,
},
"valid schedule; predefined schedule": {
inSchedule: "@daily",
wantedErr: nil,
},
"valid schedule; interval": {
inSchedule: "@every 5m",
wantedErr: nil,
},
"valid schedule; interval with 0 for some units": {
inSchedule: "@every 1h0m0s",
wantedErr: nil,
},
"valid schedule; interval with carryover value for some units": {
inSchedule: "@every 0h60m60s",
wantedErr: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// WHEN
err := validateSchedule(tc.inSchedule)
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 922 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/cli/list"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/cobra"
)
const (
jobListAppNamePrompt = "Which application's jobs would you like to list?"
)
type listJobOpts struct {
listWkldVars
// Dependencies
sel appSelector
list workloadListWriter
}
func newListJobOpts(vars listWkldVars) (*listJobOpts, error) {
defaultSession, err := sessions.ImmutableProvider(sessions.UserAgentExtras("job ls")).Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
if err != nil {
return nil, err
}
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
jobLister := &list.JobListWriter{
Ws: ws,
Store: store,
Out: os.Stdout,
ShowLocalJobs: vars.shouldShowLocalWorkloads,
OutputJSON: vars.shouldOutputJSON,
}
return &listJobOpts{
listWkldVars: vars,
list: jobLister,
sel: selector.NewAppEnvSelector(prompt.New(), store),
}, nil
}
// Validate is a no-op for this command.
func (o *listJobOpts) Validate() error {
return nil
}
// Ask asks for fields that are required but not passed in.
func (o *listJobOpts) Ask() error {
if o.appName != "" {
return nil
}
name, err := o.sel.Application(jobListAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application name: %w", err)
}
o.appName = name
return nil
}
// Execute lists the jobs in the workspace or application.
func (o *listJobOpts) Execute() error {
if err := o.list.Write(o.appName); err != nil {
return err
}
return nil
}
func buildJobListCmd() *cobra.Command {
vars := listWkldVars{}
cmd := &cobra.Command{
Use: "ls",
Short: "Lists all the jobs in an application.",
Example: `
Lists all the jobs for the "myapp" application.
/code $ copilot job ls --app myapp`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newListJobOpts(vars)
if err != nil {
return err
}
if err := opts.Ask(); err != nil {
return err
}
return opts.Execute()
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.shouldShowLocalWorkloads, localFlag, false, localJobFlagDescription)
return cmd
}
| 118 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestListJobOpts_Execute(t *testing.T) {
ctrl := gomock.NewController(t)
mockError := fmt.Errorf("error")
mockLister := mocks.NewMockworkloadListWriter(ctrl)
defer ctrl.Finish()
testCases := map[string]struct {
opts listJobOpts
mocking func()
expectedErr error
}{
"with successful call to list.Jobs": {
opts: listJobOpts{
listWkldVars: listWkldVars{
shouldOutputJSON: true,
appName: "coolapp",
},
list: mockLister,
},
mocking: func() {
mockLister.EXPECT().
Write("coolapp").
Return(nil)
},
},
"with failed call to list.Jobs": {
opts: listJobOpts{
listWkldVars: listWkldVars{
appName: "coolapp",
},
list: mockLister,
},
mocking: func() {
mockLister.EXPECT().
Write(gomock.Eq("coolapp")).
Return(mockError)
},
expectedErr: fmt.Errorf("error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
tc.mocking()
err := tc.opts.Execute()
if tc.expectedErr != nil {
require.EqualError(t, tc.expectedErr, err.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestListJobOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inApp string
mockSel func(m *mocks.MockappSelector)
wantedApp string
}{
"with no flags set": {
mockSel: func(m *mocks.MockappSelector) {
m.EXPECT().Application(jobListAppNamePrompt, wkldAppNameHelpPrompt).Return("myapp", nil)
},
wantedApp: "myapp",
},
"with app flag set": {
mockSel: func(m *mocks.MockappSelector) {
m.EXPECT().Application(gomock.Any(), gomock.Any()).Times(0)
},
inApp: "myapp",
wantedApp: "myapp",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSel := mocks.NewMockappSelector(ctrl)
tc.mockSel(mockSel)
listApps := &listJobOpts{
listWkldVars: listWkldVars{
appName: tc.inApp,
},
sel: mockSel,
}
err := listApps.Ask()
require.NoError(t, err)
require.Equal(t, tc.wantedApp, listApps.appName, "expected application names to match")
})
}
}
| 114 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/logging"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
jobAppNamePrompt = "Which application does your job belong to?"
jobLogNamePrompt = "Which job's logs would you like to show?"
jobLogNameHelpPrompt = "The logs of the indicated deployed job will be shown."
defaultJobLogExecutionLimit = 1
)
type jobLogsVars struct {
wkldLogsVars
includeStateMachineLogs bool // Whether to include the logs from the state machine log streams
last int // The number of previous executions of the state machine to show.
}
type jobLogsOpts struct {
jobLogsVars
wkldLogOpts
// Cached variables.
targetEnv *config.Environment
}
func newJobLogOpts(vars jobLogsVars) (*jobLogsOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("job logs"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, configStore)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
opts := &jobLogsOpts{
jobLogsVars: vars,
wkldLogOpts: wkldLogOpts{
w: log.OutputWriter,
configStore: configStore,
deployStore: deployStore,
sel: selector.NewDeploySelect(prompt.New(), configStore, deployStore),
},
}
opts.initRuntimeClients = func() error {
env, err := opts.getTargetEnv()
if err != nil {
return fmt.Errorf("get environment: %w", err)
}
sess, err := sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
opts.logsSvc = logging.NewJobLogger(&logging.NewWorkloadLoggerOpts{
Sess: sess,
App: opts.appName,
Env: opts.envName,
Name: opts.name,
})
return nil
}
return opts, nil
}
// Validate returns an error if the values provided by flags are invalid.
func (o *jobLogsOpts) Validate() error {
if o.appName != "" {
if _, err := o.configStore.GetApplication(o.appName); err != nil {
return err
}
if o.envName != "" {
if _, err := o.configStore.GetEnvironment(o.appName, o.envName); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.configStore.GetJob(o.appName, o.name); err != nil {
return err
}
}
}
if o.since != 0 && o.humanStartTime != "" {
return errors.New("only one of --since or --start-time may be used")
}
if o.humanEndTime != "" && o.follow {
return errors.New("only one of --follow or --end-time may be used")
}
if o.since != 0 {
if o.since < 0 {
return fmt.Errorf("--since must be greater than 0")
}
// round up to the nearest second
o.startTime = parseSince(o.since)
}
if o.humanStartTime != "" {
startTime, err := parseRFC3339(o.humanStartTime)
if err != nil {
return fmt.Errorf(`invalid argument %s for "--start-time" flag: %w`, o.humanStartTime, err)
}
o.startTime = aws.Int64(startTime)
}
if o.humanEndTime != "" {
endTime, err := parseRFC3339(o.humanEndTime)
if err != nil {
return fmt.Errorf(`invalid argument %s for "--end-time" flag: %w`, o.humanEndTime, err)
}
o.endTime = aws.Int64(endTime)
}
if o.limit != 0 && (o.limit < cwGetLogEventsLimitMin || o.limit > cwGetLogEventsLimitMax) {
return fmt.Errorf("--limit %d is out-of-bounds, value must be between %d and %d", o.limit, cwGetLogEventsLimitMin, cwGetLogEventsLimitMax)
}
return nil
}
// Ask asks for fields that are required but not passed in.
func (o *jobLogsOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
return o.validateAndAskJobEnvName()
}
// Execute outputs logs of the job.
func (o *jobLogsOpts) Execute() error {
if err := o.initRuntimeClients(); err != nil {
return err
}
eventsWriter := logging.WriteHumanLogs
if o.shouldOutputJSON {
eventsWriter = logging.WriteJSONLogs
}
var limit *int64
if o.limit != 0 {
limit = aws.Int64(int64(o.limit))
}
// By default, only display the logs of the last execution of the job.
logStreamLimit := defaultJobLogExecutionLimit
if o.last != 0 {
logStreamLimit = o.last
}
err := o.logsSvc.WriteLogEvents(logging.WriteLogEventsOpts{
Follow: o.follow,
Limit: limit,
EndTime: o.endTime,
StartTime: o.startTime,
TaskIDs: o.taskIDs,
OnEvents: eventsWriter,
LogStreamLimit: logStreamLimit,
IncludeStateMachineLogs: o.includeStateMachineLogs,
})
if err != nil {
return fmt.Errorf("write log events for job %s: %w", o.name, err)
}
return nil
}
func (o *jobLogsOpts) getTargetEnv() (*config.Environment, error) {
if o.targetEnv != nil {
return o.targetEnv, nil
}
env, err := o.configStore.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, err
}
o.targetEnv = env
return o.targetEnv, nil
}
func (o *jobLogsOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.configStore.GetApplication(o.appName)
return err
}
app, err := o.sel.Application(jobAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *jobLogsOpts) validateAndAskJobEnvName() error {
if o.envName != "" {
if _, err := o.getTargetEnv(); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.configStore.GetJob(o.appName, o.name); err != nil {
return err
}
}
deployedJob, err := o.sel.DeployedJob(jobLogNamePrompt, jobLogNameHelpPrompt, o.appName, selector.WithEnv(o.envName), selector.WithName(o.name))
if err != nil {
return fmt.Errorf("select deployed jobs for application %s: %w", o.appName, err)
}
o.name = deployedJob.Name
o.envName = deployedJob.Env
return nil
}
// buildJobLogsCmd builds the command for displaying job logs in an application.
func buildJobLogsCmd() *cobra.Command {
vars := jobLogsVars{}
cmd := &cobra.Command{
Use: "logs",
Short: "Displays logs of a deployed job.",
Example: `
Displays logs of the job "my-job" in environment "test".
/code $ copilot job logs -n my-job -e test
Displays logs in the last hour.
/code $ copilot job logs --since 1h
Displays logs from the last execution of the job.
/code $ copilot job logs --last 1
Displays logs from specific task IDs.
/code $ copilot job logs --tasks 709c7ea,1de57fd
Displays logs in real time.
/code $ copilot job logs --follow
Displays container logs and state machine execution logs from the last execution.
/code $ copilot job logs --include-state-machine --last 1`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newJobLogOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.humanStartTime, startTimeFlag, "", startTimeFlagDescription)
cmd.Flags().StringVar(&vars.humanEndTime, endTimeFlag, "", endTimeFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.follow, followFlag, false, followFlagDescription)
cmd.Flags().DurationVar(&vars.since, sinceFlag, 0, sinceFlagDescription)
cmd.Flags().IntVar(&vars.limit, limitFlag, 0, limitFlagDescription)
cmd.Flags().IntVar(&vars.last, lastFlag, 1, lastFlagDescription)
cmd.Flags().StringSliceVar(&vars.taskIDs, tasksFlag, nil, tasksLogsFlagDescription)
cmd.Flags().BoolVar(&vars.includeStateMachineLogs, includeStateMachineLogsFlag, false, includeStateMachineLogsFlagDescription)
// There's no way to associate a specific execution with a task without parsing the logs of every state machine invocation.
cmd.MarkFlagsMutuallyExclusive(includeStateMachineLogsFlag, tasksFlag)
cmd.MarkFlagsMutuallyExclusive(followFlag, lastFlag)
return cmd
}
| 281 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"time"
"github.com/aws/copilot-cli/internal/pkg/logging"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestJobLogs_Validate(t *testing.T) {
const (
mockSince = 1 * time.Minute
mockStartTime = "1970-01-01T01:01:01+00:00"
mockBadStartTime = "badStartTime"
mockEndTime = "1971-01-01T01:01:01+00:00"
mockBadEndTime = "badEndTime"
)
testCases := map[string]struct {
inputApp string
inputSvc string
inputLimit int
inputLast int
inputFollow bool
inputEnvName string
inputStartTime string
inputEndTime string
inputSince time.Duration
inputStateMachine bool
mockstore func(m *mocks.Mockstore)
wantedError error
}{
"with no flag set": {
mockstore: func(m *mocks.Mockstore) {},
},
"skip validation if app flag is not set": {
inputSvc: "frontend",
inputEnvName: "test",
mockstore: func(m *mocks.Mockstore) {},
},
"invalid app name": {
inputApp: "my-app",
mockstore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication("my-app").Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("some error"),
},
"invalid env name": {
inputApp: "my-app",
inputEnvName: "test",
mockstore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication("my-app").Return(&config.Application{}, nil)
m.EXPECT().GetEnvironment("my-app", "test").Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("some error"),
},
"invalid svc name": {
inputApp: "my-app",
inputSvc: "frontend",
mockstore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication("my-app").Return(&config.Application{}, nil)
m.EXPECT().GetJob("my-app", "frontend").Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("some error"),
},
"returns error if since and startTime flags are set together": {
inputSince: mockSince,
inputStartTime: mockStartTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("only one of --since or --start-time may be used"),
},
"returns error if follow and endTime flags are set together": {
inputFollow: true,
inputEndTime: mockEndTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("only one of --follow or --end-time may be used"),
},
"returns error if invalid start time flag value": {
inputStartTime: mockBadStartTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("invalid argument badStartTime for \"--start-time\" flag: reading time value badStartTime: parsing time \"badStartTime\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"badStartTime\" as \"2006\""),
},
"returns error if invalid end time flag value": {
inputEndTime: mockBadEndTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("invalid argument badEndTime for \"--end-time\" flag: reading time value badEndTime: parsing time \"badEndTime\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"badEndTime\" as \"2006\""),
},
"returns error if invalid since flag value": {
inputSince: -mockSince,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("--since must be greater than 0"),
},
"returns error if limit value is below limit": {
inputLimit: -1,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("--limit -1 is out-of-bounds, value must be between 1 and 10000"),
},
"returns error if limit value is above limit": {
inputLimit: 10001,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("--limit 10001 is out-of-bounds, value must be between 1 and 10000"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
tc.mockstore(mockstore)
jobLogs := &jobLogsOpts{
jobLogsVars: jobLogsVars{
wkldLogsVars: wkldLogsVars{
follow: tc.inputFollow,
limit: tc.inputLimit,
envName: tc.inputEnvName,
humanStartTime: tc.inputStartTime,
humanEndTime: tc.inputEndTime,
since: tc.inputSince,
name: tc.inputSvc,
appName: tc.inputApp,
},
includeStateMachineLogs: tc.inputStateMachine,
last: tc.inputLast,
},
wkldLogOpts: wkldLogOpts{
configStore: mockstore,
},
}
// WHEN
err := jobLogs.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestJobLogs_Ask(t *testing.T) {
const (
inputApp = "my-app"
inputEnv = "my-env"
inputJob = "my-job"
)
testCases := map[string]struct {
inputApp string
inputJob string
inputEnvName string
setupMocks func(mocks wkldLogsMock)
wantedApp string
wantedEnv string
wantedJob string
wantedError error
}{
"validate app env and job with all flags passed in": {
inputApp: inputApp,
inputJob: inputJob,
inputEnvName: inputEnv,
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.configStore.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil),
m.configStore.EXPECT().GetEnvironment("my-app", "my-env").Return(&config.Environment{Name: "my-env"}, nil),
m.configStore.EXPECT().GetJob("my-app", "my-job").Return(&config.Workload{}, nil),
m.sel.EXPECT().DeployedJob(jobLogNamePrompt, jobLogNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(&selector.DeployedJob{
Env: "my-env",
Name: "my-job",
}, nil), // Let prompter handles the case when svc(env) is definite.
)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedJob: inputJob,
},
"prompt for app name": {
inputJob: inputJob,
inputEnvName: inputEnv,
setupMocks: func(m wkldLogsMock) {
m.sel.EXPECT().Application(jobAppNamePrompt, wkldAppNameHelpPrompt).Return("my-app", nil)
m.configStore.EXPECT().GetApplication(gomock.Any()).Times(0)
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetJob(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedJob(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(&selector.DeployedJob{
Env: "my-env",
Name: "my-job",
}, nil).AnyTimes()
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedJob: inputJob,
},
"returns error if fail to select app": {
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.sel.EXPECT().Application(jobAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error")),
)
},
wantedError: fmt.Errorf("select application: some error"),
},
"prompt for job and env": {
inputApp: "my-app",
setupMocks: func(m wkldLogsMock) {
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.configStore.EXPECT().GetJob(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedJob(jobLogNamePrompt, jobLogNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(&selector.DeployedJob{
Env: "my-env",
Name: "my-job",
}, nil)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedJob: inputJob,
},
"return error if fail to select deployed job": {
inputApp: inputApp,
setupMocks: func(m wkldLogsMock) {
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.configStore.EXPECT().GetJob(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedJob(jobLogNamePrompt, jobLogNameHelpPrompt, inputApp, gomock.Any(), gomock.Any()).
Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("select deployed jobs for application my-app: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
mockSel := mocks.NewMockdeploySelector(ctrl)
mocks := wkldLogsMock{
configStore: mockstore,
sel: mockSel,
}
tc.setupMocks(mocks)
jobLogs := &jobLogsOpts{
jobLogsVars: jobLogsVars{
wkldLogsVars: wkldLogsVars{
envName: tc.inputEnvName,
name: tc.inputJob,
appName: tc.inputApp,
},
},
wkldLogOpts: wkldLogOpts{
configStore: mockstore,
sel: mockSel,
},
}
// WHEN
err := jobLogs.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, jobLogs.appName, "expected app name to match")
require.Equal(t, tc.wantedJob, jobLogs.name, "expected job name to match")
require.Equal(t, tc.wantedEnv, jobLogs.envName, "expected service name to match")
}
})
}
}
func TestJobLogs_Execute(t *testing.T) {
mockStartTime := int64(123456789)
mockEndTime := int64(987654321)
mockLimit := int64(10)
var mockNilLimit *int64
testCases := map[string]struct {
inputJob string
follow bool
limit int
endTime int64
startTime int64
taskIDs []string
mocklogsSvc func(ctrl *gomock.Controller) logEventsWriter
last int
includeStateMachine bool
wantedError error
}{
"success": {
inputJob: "mockJob",
endTime: mockEndTime,
startTime: mockStartTime,
limit: 10,
last: 4,
includeStateMachine: true,
mocklogsSvc: func(ctrl *gomock.Controller) logEventsWriter {
m := mocks.NewMocklogEventsWriter(ctrl)
m.EXPECT().WriteLogEvents(gomock.Any()).Do(func(param logging.WriteLogEventsOpts) {
require.Equal(t, param.LogStreamLimit, 4)
require.Equal(t, param.EndTime, &mockEndTime)
require.Equal(t, param.StartTime, &mockStartTime)
require.Equal(t, param.Limit, &mockLimit)
require.Equal(t, param.IncludeStateMachineLogs, true)
}).Return(nil)
return m
},
wantedError: nil,
},
"success with no execution limit set": {
inputJob: "mockJob",
includeStateMachine: true,
mocklogsSvc: func(ctrl *gomock.Controller) logEventsWriter {
m := mocks.NewMocklogEventsWriter(ctrl)
m.EXPECT().WriteLogEvents(gomock.Any()).Do(func(param logging.WriteLogEventsOpts) {
require.Equal(t, param.LogStreamLimit, 1)
require.Equal(t, param.Limit, mockNilLimit)
require.Equal(t, param.IncludeStateMachineLogs, true)
}).Return(nil)
return m
},
wantedError: nil,
},
"success with no limit set": {
inputJob: "mockJob",
endTime: mockEndTime,
startTime: mockStartTime,
follow: true,
taskIDs: []string{"mockTaskID"},
mocklogsSvc: func(ctrl *gomock.Controller) logEventsWriter {
m := mocks.NewMocklogEventsWriter(ctrl)
m.EXPECT().WriteLogEvents(gomock.Any()).Do(func(param logging.WriteLogEventsOpts) {
require.Equal(t, param.TaskIDs, []string{"mockTaskID"})
require.Equal(t, param.EndTime, &mockEndTime)
require.Equal(t, param.StartTime, &mockStartTime)
require.Equal(t, param.Follow, true)
require.Equal(t, param.Limit, mockNilLimit)
}).Return(nil)
return m
},
wantedError: nil,
},
"returns error if fail to get event logs": {
inputJob: "mockJob",
mocklogsSvc: func(ctrl *gomock.Controller) logEventsWriter {
m := mocks.NewMocklogEventsWriter(ctrl)
m.EXPECT().WriteLogEvents(gomock.Any()).
Return(errors.New("some error"))
return m
},
wantedError: fmt.Errorf("write log events for job mockJob: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
svcLogs := &jobLogsOpts{
jobLogsVars: jobLogsVars{
wkldLogsVars: wkldLogsVars{
name: tc.inputJob,
follow: tc.follow,
limit: tc.limit,
taskIDs: tc.taskIDs,
},
includeStateMachineLogs: tc.includeStateMachine,
last: tc.last,
},
wkldLogOpts: wkldLogOpts{
startTime: &tc.startTime,
endTime: &tc.endTime,
initRuntimeClients: func() error { return nil },
logsSvc: tc.mocklogsSvc(ctrl),
},
}
// WHEN
err := svcLogs.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 447 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"github.com/spf13/cobra"
)
func newOverrideJobOpts(vars overrideWorkloadVars) (*overrideWorkloadOpts, error) {
cmd, err := newOverrideWorkloadOpts(vars)
if err != nil {
return nil, err
}
cmd.validateOrAskName = cmd.validateOrAskJobName
cmd.overrideOpts.packageCmd = cmd.newSvcPackageCmd // "job package" uses "svc package" under the hood.
return cmd, nil
}
func (o *overrideWorkloadOpts) validateOrAskJobName() error {
if o.name == "" {
return o.askJobName()
}
return o.validateJobName()
}
func (o *overrideWorkloadOpts) askJobName() error {
name, err := o.wsPrompt.Job("Which job's resources would you like to override?", "")
if err != nil {
return fmt.Errorf("select job name from workspace: %v", err)
}
o.name = name
return nil
}
func (o *overrideWorkloadOpts) validateJobName() error {
names, err := o.ws.ListJobs()
if err != nil {
return fmt.Errorf("list jobs in the workspace: %v", err)
}
if !contains(o.name, names) {
return fmt.Errorf("job %q does not exist in the workspace", o.name)
}
return nil
}
func buildJobOverrideCmd() *cobra.Command {
vars := overrideWorkloadVars{}
cmd := &cobra.Command{
Use: "override",
Short: "Override the AWS CloudFormation template of a job.",
Long: `Scaffold Infrastructure as Code (IaC) extension files for a job.
The generated files allow you to extend and override the Copilot-generated AWS CloudFormation template.
You can edit the files to change existing resource properties, delete
or add new resources to the job's template.`,
Example: `
Create a new Cloud Development Kit application to override the "report" job template.
/code $ copilot job override -n report --tool cdk`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newOverrideJobOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", jobFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", overrideEnvFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.iacTool, iacToolFlag, "", iacToolFlagDescription)
cmd.Flags().StringVar(&vars.cdkLang, cdkLanguageFlag, typescriptCDKLang, cdkLanguageFlagDescription)
cmd.Flags().BoolVar(&vars.skipResources, skipResourcesFlag, false, skipResourcesFlagDescription)
return cmd
}
| 77 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestOverrideJob_Ask(t *testing.T) {
t.Run("ask or validate job name", func(t *testing.T) {
testCases := map[string]struct {
name string
initMocks func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts)
wanted error
}{
"validation passes if job exists in local workspace": {
name: "reporter",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListJobs().Return([]string{"backend", "reporter", "worker"}, nil)
cmd.ws = mockWS
},
},
"return a wrapped error if local jobs cannot be retrieved from workspace": {
name: "reporter",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListJobs().Return(nil, errors.New("some error"))
cmd.ws = mockWS
},
wanted: errors.New("list jobs in the workspace: some error"),
},
"return an error if job does not exist in the workspace": {
name: "reporter",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListJobs().Return([]string{"payments"}, nil)
cmd.ws = mockWS
},
wanted: errors.New(`job "reporter" does not exist in the workspace`),
},
"should ask for the local job name if flag is not provided": {
name: "",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockPrompt := mocks.NewMockwsSelector(ctrl)
mockPrompt.EXPECT().Job(gomock.Any(), gomock.Any())
cmd.wsPrompt = mockPrompt
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockCfnPrompt := mocks.NewMockcfnSelector(ctrl)
mockCfnPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
vars := overrideVars{name: tc.name, appName: "demo", iacTool: "cdk"}
cmd := &overrideWorkloadOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mocks.NewMockstore(ctrl),
cfnPrompt: mockCfnPrompt,
packageCmd: func(_ stringWriteCloser) (executor, error) {
mockCmd := mocks.NewMockexecutor(ctrl)
mockCmd.EXPECT().Execute().AnyTimes()
return mockCmd, nil
},
spinner: &spinnerTestDouble{},
},
}
cmd.validateOrAskName = cmd.validateOrAskJobName
tc.initMocks(ctrl, cmd)
// WHEN
err := cmd.Ask()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
}
| 96 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.