add apigateway stage integration tests

Author: tomasdembelli

adapters/apigateway-stage.go

@@ -100,15 +100,18 @@ func NewAPIGatewayStageAdapter(client *apigateway.Client, accountID string, regi
 		DisableList: true,
 		SearchFunc: func(ctx context.Context, client *apigateway.Client, scope string, query string) ([]*types.Stage, error) {
 			f := strings.Split(query, "/")
-			var restAPIID string
-			var deploymentID string
+			var input *apigateway.GetStagesInput
 
 			switch len(f) {
 			case 1:
-				restAPIID = f[0]
+				input = &apigateway.GetStagesInput{
+					RestApiId: &f[0],
+				}
 			case 2:
-				restAPIID = f[0]
-				deploymentID = f[1]
+				input = &apigateway.GetStagesInput{
+					RestApiId:    &f[0],
+					DeploymentId: &f[1],
+				}
 			default:
 				return nil, &sdp.QueryError{
 					ErrorType: sdp.QueryError_NOTFOUND,
@@ -119,10 +122,7 @@ func NewAPIGatewayStageAdapter(client *apigateway.Client, accountID string, regi
 				}
 			}
 
-			out, err := client.GetStages(ctx, &apigateway.GetStagesInput{
-				RestApiId:    &restAPIID,
-				DeploymentId: &deploymentID,
-			})
+			out, err := client.GetStages(ctx, input)
 			if err != nil {
 				return nil, err
 			}
@@ -148,7 +148,7 @@ var stageAdapterMetadata = Metadata.Register(&sdp.AdapterMetadata{
 		Get:               true,
 		Search:            true,
 		GetDescription:    "Get an API Gateway Stage by its rest API ID and stage name: rest-api-id/stage-name",
-		SearchDescription: "Search for API Gateway Stages by their rest API ID or with rest API ID and their stage name: rest-api-id/stage-name",
+		SearchDescription: "Search for API Gateway Stages by their rest API ID or with rest API ID and deployment-id: rest-api-id/deployment-id",
 	},
 	PotentialLinks: []string{"wafv2-web-acl"},
 })

adapters/integration/apigateway/apigateway_test.go

@@ -87,6 +87,13 @@ func APIGateway(t *testing.T) {
 		t.Fatalf("failed to validate APIGateway deployment adapter: %v", err)
 	}
 
+	stageSource := adapters.NewAPIGatewayStageAdapter(testClient, accountID, testAWSConfig.Region)
+
+	err = stageSource.Validate()
+	if err != nil {
+		t.Fatalf("failed to validate APIGateway stage adapter: %v", err)
+	}
+
 	// Tests ----------------------------------------------------------------------------------------------------------
 
 	scope := adapterhelpers.FormatScope(accountID, testAWSConfig.Region)
@@ -458,5 +465,76 @@ func APIGateway(t *testing.T) {
 		t.Fatalf("expected deployment ID %s, got %s", deploymentID, deploymentIDFromSearch)
 	}
 
+	// Search stages by restApiID
+	stages, err := stageSource.Search(ctx, scope, restApiID, true)
+	if err != nil {
+		t.Fatalf("failed to search APIGateway stages: %v", err)
+	}
+
+	if len(stages) == 0 {
+		t.Fatalf("no stages found")
+	}
+
+	stageUniqueAttribute := stages[0].GetUniqueAttribute()
+
+	stageID, err := integration.GetUniqueAttributeValueBySignificantAttribute(
+		stageUniqueAttribute,
+		"StageName",
+		"dev",
+		stages,
+		true,
+	)
+	if err != nil {
+		t.Fatalf("failed to get stage ID: %v", err)
+	}
+
+	// Get stage
+	query = fmt.Sprintf("%s/dev", restApiID)
+	stage, err := stageSource.Get(ctx, scope, query, true)
+	if err != nil {
+		t.Fatalf("failed to get APIGateway stage: %v", err)
+	}
+
+	stageIDFromGet, err := integration.GetUniqueAttributeValueBySignificantAttribute(
+		stageUniqueAttribute,
+		"StageName",
+		"dev",
+		[]*sdp.Item{stage},
+		true,
+	)
+	if err != nil {
+		t.Fatalf("failed to get stage ID from get: %v", err)
+	}
+
+	if stageID != stageIDFromGet {
+		t.Fatalf("expected stage ID %s, got %s", stageID, stageIDFromGet)
+	}
+
+	// Search stage by restApiID/deploymentID
+	query = fmt.Sprintf("%s/%s", restApiID, deploymentID)
+	stagesFromSearch, err := stageSource.Search(ctx, scope, query, true)
+	if err != nil {
+		t.Fatalf("failed to search APIGateway stages: %v", err)
+	}
+
+	if len(stagesFromSearch) == 0 {
+		t.Fatalf("no stages found")
+	}
+
+	stageIDFromSearch, err := integration.GetUniqueAttributeValueBySignificantAttribute(
+		stageUniqueAttribute,
+		"StageName",
+		"dev",
+		stagesFromSearch,
+		true,
+	)
+	if err != nil {
+		t.Fatalf("failed to get stage ID from search: %v", err)
+	}
+
+	if stageID != stageIDFromSearch {
+		t.Fatalf("expected stage ID %s, got %s", stageID, stageIDFromSearch)
+	}
+
 	t.Log("APIGateway integration test completed")
 }

adapters/integration/apigateway/create.go

@@ -229,26 +229,55 @@ func createAuthorizer(ctx context.Context, logger *slog.Logger, client *apigatew
 	return nil
 }
 
-func createDeployment(ctx context.Context, logger *slog.Logger, client *apigateway.Client, restAPIID string) error {
+func createDeployment(ctx context.Context, logger *slog.Logger, client *apigateway.Client, restAPIID string) (*string, error) {
 	// check if a deployment with the same name already exists
 	id, err := findDeploymentByDescription(ctx, client, restAPIID, "test-deployment")
 	if err != nil {
 		if errors.As(err, new(integration.NotFoundError)) {
 			logger.InfoContext(ctx, "Creating deployment")
 		} else {
-			return err
+			return nil, err
 		}
 	}
 
 	if id != nil {
 		logger.InfoContext(ctx, "Deployment already exists")
-		return nil
+		return id, nil
 	}
 
-	_, err = client.CreateDeployment(ctx, &apigateway.CreateDeploymentInput{
+	resp, err := client.CreateDeployment(ctx, &apigateway.CreateDeploymentInput{
 		RestApiId:   &restAPIID,
 		Description: adapterhelpers.PtrString("test-deployment"),
 	})
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Id, nil
+}
+
+func createStage(ctx context.Context, logger *slog.Logger, client *apigateway.Client, restAPIID, deploymentID string) error {
+	// check if a stage with the same name already exists
+	stgName := "dev"
+	err := findStageByName(ctx, client, restAPIID, stgName)
+	if err != nil {
+		if errors.As(err, new(integration.NotFoundError)) {
+			logger.InfoContext(ctx, "Creating stage")
+		} else {
+			return err
+		}
+	}
+
+	if err == nil {
+		logger.InfoContext(ctx, "Stage already exists")
+		return nil
+	}
+
+	_, err = client.CreateStage(ctx, &apigateway.CreateStageInput{
+		RestApiId:    &restAPIID,
+		DeploymentId: &deploymentID,
+		StageName:    &stgName,
+	})
 	if err != nil {
 		return err
 	}

adapters/integration/apigateway/find.go

@@ -169,3 +169,26 @@ func findDeploymentByDescription(ctx context.Context, client *apigateway.Client,
 
 	return nil, integration.NewNotFoundError(integration.ResourceName(integration.APIGateway, deploymentSrc, description))
 }
+
+func findStageByName(ctx context.Context, client *apigateway.Client, restAPIID, name string) error {
+	result, err := client.GetStage(ctx, &apigateway.GetStageInput{
+		RestApiId: &restAPIID,
+		StageName: &name,
+	})
+	if err != nil {
+		var notFoundErr *types.NotFoundException
+		if errors.As(err, &notFoundErr) {
+			return integration.NewNotFoundError(integration.ResourceName(
+				integration.APIGateway,
+				stageSrc,
+				name,
+			))
+		}
+	}
+
+	if result == nil {
+		return integration.NewNotFoundError(name)
+	}
+
+	return nil
+}

adapters/integration/apigateway/setup.go

@@ -17,6 +17,7 @@ const (
 	apiKeySrc         = "api-key"
 	authorizerSrc     = "authorizer"
 	deploymentSrc     = "deployment"
+	stageSrc          = "stage"
 )
 
 func setup(ctx context.Context, logger *slog.Logger, client *apigateway.Client) error {
@@ -71,7 +72,13 @@ func setup(ctx context.Context, logger *slog.Logger, client *apigateway.Client)
 	}
 
 	// Create Deployment
-	err = createDeployment(ctx, logger, client, *restApiID)
+	deploymentID, err := createDeployment(ctx, logger, client, *restApiID)
+	if err != nil {
+		return err
+	}
+
+	// Create Stage
+	err = createStage(ctx, logger, client, *restApiID, *deploymentID)
 	if err != nil {
 		return err
 	}