From ee66afbce81e53c5bef380ceec5d7b74a6d8c71a Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 21 Jun 2023 11:26:49 +0200 Subject: [PATCH 1/7] INTMDB-878: [Terraform] Improve acceptance test setup to run in parallel & against cloud-dev - Network --- .github/workflows/acceptance-tests.yml | 60 +++++++++ ...rce_mongodbatlas_network_container_test.go | 121 ----------------- ...ce_mongodbatlas_network_containers_test.go | 126 ------------------ ...telink_endpoint_service_serverless_test.go | 118 ---------------- ...elink_endpoints_service_serverless_test.go | 74 ---------- ...e_mongodbatlas_serverless_instance_test.go | 50 ------- ..._mongodbatlas_serverless_instances_test.go | 48 ------- ...rce_mongodbatlas_network_container_test.go | 62 +++++++-- ...las_private_endpoint_regional_mode_test.go | 27 +++- ...as_privatelink_endpoint_serverless_test.go | 25 ++-- ...s_privatelink_endpoint_service_adl_test.go | 4 +- ...telink_endpoint_service_serverless_test.go | 59 +++++--- ..._mongodbatlas_privatelink_endpoint_test.go | 70 +++++----- ...e_mongodbatlas_serverless_instance_test.go | 58 ++++++-- 14 files changed, 268 insertions(+), 634 deletions(-) delete mode 100644 mongodbatlas/data_source_mongodbatlas_network_container_test.go delete mode 100644 mongodbatlas/data_source_mongodbatlas_network_containers_test.go delete mode 100644 mongodbatlas/data_source_mongodbatlas_privatelink_endpoint_service_serverless_test.go delete mode 100644 mongodbatlas/data_source_mongodbatlas_privatelink_endpoints_service_serverless_test.go delete mode 100644 mongodbatlas/data_source_mongodbatlas_serverless_instance_test.go delete mode 100644 mongodbatlas/data_source_mongodbatlas_serverless_instances_test.go diff --git a/.github/workflows/acceptance-tests.yml b/.github/workflows/acceptance-tests.yml index 41995a9de9..28b949d88b 100644 --- a/.github/workflows/acceptance-tests.yml +++ b/.github/workflows/acceptance-tests.yml @@ -25,6 +25,8 @@ jobs: backup_snapshots: ${{ steps.filter.outputs.backup_snapshots }} backup_schedule: ${{ steps.filter.outputs.backup_schedule }} project: ${{ steps.filter.outputs.project }} + serverless: ${{ steps.filter.outputs.serverless }} + network: ${{ steps.filter.outputs.network }} steps: - uses: actions/checkout@v3 if: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' || github.event_name == 'schedule'}} @@ -50,6 +52,12 @@ jobs: project: - 'mongodbatlas/**project**.go' - 'mongodbatlas/**access_list**.go' + serverless: + - 'mongodbatlas/**_serverless**.go' + network: + - 'mongodbatlas/**_network**.go' + - 'mongodbatlas/**_privatelink**.go' + - 'mongodbatlas/**_private_endpoint**.go' cluster_outage_simulation: needs: [ change-detection ] @@ -257,3 +265,55 @@ jobs: PARALLEL_GO_TEST: 20 TEST_REGEX: "^TestAccProject" run: make testacc + serverless: + needs: [ change-detection ] + if: ${{ needs.change-detection.outputs.serverless == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'schedule' }} + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + - name: Set up Go + uses: actions/setup-go@v4 + with: + go-version: "1.20" + - name: Acceptance Tests + env: + MONGODB_ATLAS_PUBLIC_KEY: ${{ secrets.MONGODB_ATLAS_PUBLIC_KEY_CLOUD_DEV }} + MONGODB_ATLAS_PRIVATE_KEY: ${{ secrets.MONGODB_ATLAS_PRIVATE_KEY_CLOUD_DEV }} + MONGODB_ATLAS_ORG_ID: ${{ vars.MONGODB_ATLAS_ORG_ID_CLOUD_DEV }} + MONGODB_ATLAS_BASE_URL: ${{ vars.MONGODB_ATLAS_BASE_URL }} + SKIP_TEST_EXTERNAL_CREDENTIALS: ${{ vars.SKIP_TEST_EXTERNAL_CREDENTIALS }} + ACCTEST_TIMEOUT: ${{ vars.ACCTEST_TIMEOUT }} + TF_LOG: ${{ vars.LOG_LEVEL }} + TF_ACC: 1 + PARALLEL_GO_TEST: 20 + TEST_REGEX: "^TestAccServerless" + run: make testacc + network: + needs: [ change-detection ] + if: ${{ needs.change-detection.outputs.network == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'schedule' }} + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + - name: Set up Go + uses: actions/setup-go@v4 + with: + go-version: "1.20" + - name: Acceptance Tests + env: + MONGODB_ATLAS_PUBLIC_KEY: ${{ secrets.MONGODB_ATLAS_PUBLIC_KEY_CLOUD_DEV_NETWORK }} + MONGODB_ATLAS_PRIVATE_KEY: ${{ secrets.MONGODB_ATLAS_PRIVATE_KEY_CLOUD_DEV_NETWORK }} + MONGODB_ATLAS_ORG_ID: ${{ vars.MONGODB_ATLAS_ORG_ID_CLOUD_DEV_NETWORK }} + MONGODB_ATLAS_PROJECT_ID: ${{ vars.MONGODB_ATLAS_PROJECT_ID_CLOUD_DEV_NETWORK }} + MONGODB_ATLAS_BASE_URL: ${{ vars.MONGODB_ATLAS_BASE_URL }} + SKIP_TEST_EXTERNAL_CREDENTIALS: ${{ vars.SKIP_TEST_EXTERNAL_CREDENTIALS }} + MONGODB_ATLAS_ENABLE_BETA: ${{ vars.MONGODB_ATLAS_ENABLE_BETA }} + MONGODB_ATLAS_ENDPOINT_ID: ${{ vars.MONGODB_ATLAS_AWS_ENDPOINT_ID_NETWORK }} + ACCTEST_TIMEOUT: ${{ vars.ACCTEST_TIMEOUT }} + AWS_REGION: ${{ vars.AWS_REGION }} + TF_LOG: ${{ vars.LOG_LEVEL }} + TF_ACC: 1 + PARALLEL_GO_TEST: 20 + TEST_REGEX: "^TestAccNetwork" + run: make testacc diff --git a/mongodbatlas/data_source_mongodbatlas_network_container_test.go b/mongodbatlas/data_source_mongodbatlas_network_container_test.go deleted file mode 100644 index 609c56d6f1..0000000000 --- a/mongodbatlas/data_source_mongodbatlas_network_container_test.go +++ /dev/null @@ -1,121 +0,0 @@ -package mongodbatlas - -import ( - "fmt" - "os" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - matlas "go.mongodb.org/atlas/mongodbatlas" -) - -func TestAccNetworkDSNetworkContainer_basic(t *testing.T) { - var container matlas.Container - - randInt := acctest.RandIntRange(0, 255) - - resourceName := "mongodbatlas_network_container.test_ds" - cidrBlock := fmt.Sprintf("10.8.%d.0/24", randInt) - dataSourceName := "data.mongodbatlas_network_container.test_ds" - orgID := os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName := acctest.RandomWithPrefix("test-acc") - - providerName := "AWS" - - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - ProviderFactories: testAccProviderFactories, - CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, - Steps: []resource.TestStep{ - { - Config: testAccMongoDBAtlasNetworkContainerDSConfig(projectName, orgID, cidrBlock), - Check: resource.ComposeTestCheckFunc( - testAccCheckMongoDBAtlasNetworkContainerExists(resourceName, &container), - testAccCheckMongoDBAtlasNetworkContainerAttributes(&container, providerName), - resource.TestCheckResourceAttrSet(resourceName, "project_id"), - resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), - resource.TestCheckResourceAttrSet(resourceName, "provisioned"), - resource.TestCheckResourceAttrSet(dataSourceName, "project_id"), - resource.TestCheckResourceAttr(dataSourceName, "provider_name", providerName), - resource.TestCheckResourceAttrSet(dataSourceName, "provisioned"), - ), - }, - }, - }) -} - -func TestAccNetworkDSNetworkContainer_WithGCPRegions(t *testing.T) { - var container matlas.Container - - randInt := acctest.RandIntRange(0, 255) - - resourceName := "mongodbatlas_network_container.test_ds" - cidrBlock := fmt.Sprintf("10.%d.0.0/21", randInt) - dataSourceName := "data.mongodbatlas_network_container.test_ds" - orgID := os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName := acctest.RandomWithPrefix("test-acc") - - providerName := "GCP" - - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - ProviderFactories: testAccProviderFactories, - CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, - Steps: []resource.TestStep{ - { - Config: testAccMongoDBAtlasNetworkContainerDSWithGCPRegionsConfig(projectName, orgID, cidrBlock), - Check: resource.ComposeTestCheckFunc( - testAccCheckMongoDBAtlasNetworkContainerExists(resourceName, &container), - testAccCheckMongoDBAtlasNetworkContainerAttributes(&container, providerName), - resource.TestCheckResourceAttrSet(resourceName, "project_id"), - resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), - resource.TestCheckResourceAttrSet(resourceName, "provisioned"), - resource.TestCheckResourceAttrSet(dataSourceName, "project_id"), - ), - }, - }, - }) -} - -func testAccMongoDBAtlasNetworkContainerDSConfig(projectName, orgID, cidrBlock string) string { - return fmt.Sprintf(` - resource "mongodbatlas_project" "test" { - name = "%s" - org_id = "%s" - } - - resource "mongodbatlas_network_container" "test_ds" { - project_id = "${mongodbatlas_project.test.id}" - atlas_cidr_block = "%s" - provider_name = "AWS" - region_name = "US_EAST_1" - } - - data "mongodbatlas_network_container" "test_ds" { - project_id = mongodbatlas_network_container.test_ds.project_id - container_id = mongodbatlas_network_container.test_ds.id - } - `, projectName, orgID, cidrBlock) -} - -func testAccMongoDBAtlasNetworkContainerDSWithGCPRegionsConfig(projectName, orgID, cidrBlock string) string { - return fmt.Sprintf(` - resource "mongodbatlas_project" "test" { - name = "%s" - org_id = "%s" - } - - resource "mongodbatlas_network_container" "test_ds" { - project_id = "${mongodbatlas_project.test.id}" - atlas_cidr_block = "%s" - provider_name = "GCP" - regions = ["US_EAST_4", "US_WEST_3"] - } - - data "mongodbatlas_network_container" "test_ds" { - project_id = mongodbatlas_network_container.test_ds.project_id - container_id = mongodbatlas_network_container.test_ds.id - } - `, projectName, orgID, cidrBlock) -} diff --git a/mongodbatlas/data_source_mongodbatlas_network_containers_test.go b/mongodbatlas/data_source_mongodbatlas_network_containers_test.go deleted file mode 100644 index 593808f9bf..0000000000 --- a/mongodbatlas/data_source_mongodbatlas_network_containers_test.go +++ /dev/null @@ -1,126 +0,0 @@ -package mongodbatlas - -import ( - "fmt" - "os" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - matlas "go.mongodb.org/atlas/mongodbatlas" -) - -func TestAccNetworkDSNetworkContainers_basic(t *testing.T) { - var container matlas.Container - - randInt := acctest.RandIntRange(0, 255) - - resourceName := "mongodbatlas_network_container.test" - cidrBlock := fmt.Sprintf("10.8.%d.0/24", randInt) - dataSourceName := "data.mongodbatlas_network_containers.test" - orgID := os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName := acctest.RandomWithPrefix("test-acc") - - providerName := "AWS" - - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - ProviderFactories: testAccProviderFactories, - CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, - Steps: []resource.TestStep{ - { - Config: testAccMongoDBAtlasNetworkContainersDSConfig(projectName, orgID, cidrBlock), - Check: resource.ComposeTestCheckFunc( - testAccCheckMongoDBAtlasNetworkContainerExists(resourceName, &container), - testAccCheckMongoDBAtlasNetworkContainerAttributes(&container, providerName), - resource.TestCheckResourceAttrSet(resourceName, "project_id"), - resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), - resource.TestCheckResourceAttrSet(resourceName, "provisioned"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.#"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.id"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.atlas_cidr_block"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.provider_name"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.provisioned"), - ), - }, - }, - }) -} -func TestAccNetworkDSNetworkContainers_WithGCPRegions(t *testing.T) { - var container matlas.Container - - randInt := acctest.RandIntRange(0, 255) - - resourceName := "mongodbatlas_network_container.test" - cidrBlock := fmt.Sprintf("10.%d.0.0/21", randInt) - dataSourceName := "data.mongodbatlas_network_containers.test" - orgID := os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName := acctest.RandomWithPrefix("test-acc") - - providerName := "GCP" - - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - ProviderFactories: testAccProviderFactories, - CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, - Steps: []resource.TestStep{ - { - Config: testAccMongoDBAtlasNetworkContainersDSWithGCPRegionsConfig(projectName, orgID, cidrBlock), - Check: resource.ComposeTestCheckFunc( - testAccCheckMongoDBAtlasNetworkContainerExists(resourceName, &container), - testAccCheckMongoDBAtlasNetworkContainerAttributes(&container, providerName), - resource.TestCheckResourceAttrSet(resourceName, "project_id"), - resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), - resource.TestCheckResourceAttrSet(resourceName, "provisioned"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.#"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.id"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.atlas_cidr_block"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.provider_name"), - resource.TestCheckResourceAttrSet(dataSourceName, "results.0.provisioned"), - ), - }, - }, - }) -} - -func testAccMongoDBAtlasNetworkContainersDSConfig(projectName, orgID, cidrBlock string) string { - return fmt.Sprintf(` - resource "mongodbatlas_project" "test" { - name = "%s" - org_id = "%s" - } - - resource "mongodbatlas_network_container" "test" { - project_id = "${mongodbatlas_project.test.id}" - atlas_cidr_block = "%s" - provider_name = "AWS" - region_name = "US_EAST_1" - } - - data "mongodbatlas_network_containers" "test" { - project_id = "${mongodbatlas_network_container.test.project_id}" - provider_name = "AWS" - } - `, projectName, orgID, cidrBlock) -} - -func testAccMongoDBAtlasNetworkContainersDSWithGCPRegionsConfig(projectName, orgID, cidrBlock string) string { - return fmt.Sprintf(` - resource "mongodbatlas_project" "test" { - name = "%s" - org_id = "%s" - } - - resource "mongodbatlas_network_container" "test" { - project_id = mongodbatlas_project.test.id - atlas_cidr_block = "%s" - provider_name = "GCP" - regions = ["US_EAST_4", "US_WEST_3"] - } - - data "mongodbatlas_network_containers" "test" { - project_id = mongodbatlas_network_container.test.project_id - provider_name = "GCP" - } - `, projectName, orgID, cidrBlock) -} diff --git a/mongodbatlas/data_source_mongodbatlas_privatelink_endpoint_service_serverless_test.go b/mongodbatlas/data_source_mongodbatlas_privatelink_endpoint_service_serverless_test.go deleted file mode 100644 index dfc8c30c5d..0000000000 --- a/mongodbatlas/data_source_mongodbatlas_privatelink_endpoint_service_serverless_test.go +++ /dev/null @@ -1,118 +0,0 @@ -package mongodbatlas - -import ( - "context" - "fmt" - "os" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" -) - -func TestAccNetworkDSPrivateLinkEndpointServiceServerless_basic(t *testing.T) { - var ( - resourceName = "data.mongodbatlas_privatelink_endpoint_service_serverless.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") - instanceName = "dsserverless" - commentOrigin = "create" - ) - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - ProviderFactories: testAccProviderFactories, - CheckDestroy: testAccDSCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessDestroy, - Steps: []resource.TestStep{ - { - Config: testAccDSMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, instanceName, commentOrigin), - Check: resource.ComposeTestCheckFunc( - testAccDSCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessExists(resourceName), - resource.TestCheckResourceAttr(resourceName, "comment", commentOrigin), - ), - }, - }, - }) -} - -func testAccDSCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessDestroy(state *terraform.State) error { - conn := testAccProvider.Meta().(*MongoDBClient).Atlas - - for _, rs := range state.RootModule().Resources { - if rs.Type != "data.mongodbatlas_privatelink_endpoint_service_serverless" { - continue - } - - ids := decodeStateID(rs.Primary.ID) - - privateLink, _, err := conn.ServerlessPrivateEndpoints.Get(context.Background(), ids["project_id"], ids["instance_name"], ids["endpoint_id"]) - if err == nil && privateLink != nil { - return fmt.Errorf("endpoint_id (%s) still exists", ids["endpoint_id"]) - } - } - - return nil -} - -func testAccDSMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, instanceName, comment string) string { - return fmt.Sprintf(` - - data "mongodbatlas_privatelink_endpoint_service_serverless" "test" { - project_id = mongodbatlas_privatelink_endpoint_service_serverless.test.project_id - instance_name = mongodbatlas_serverless_instance.test.name - endpoint_id = mongodbatlas_privatelink_endpoint_service_serverless.test.endpoint_id - } - - resource "mongodbatlas_privatelink_endpoint_serverless" "test" { - project_id = "%[1]s" - instance_name = mongodbatlas_serverless_instance.test.name - provider_name = "AWS" - } - - - resource "mongodbatlas_privatelink_endpoint_service_serverless" "test" { - project_id = "%[1]s" - instance_name = "%[2]s" - endpoint_id = mongodbatlas_privatelink_endpoint_serverless.test.endpoint_id - provider_name = "AWS" - comment = "%[3]s" - } - - resource "mongodbatlas_serverless_instance" "test" { - project_id = "%[1]s" - name = "%[2]s" - provider_settings_backing_provider_name = "AWS" - provider_settings_provider_name = "SERVERLESS" - provider_settings_region_name = "US_EAST_1" - continuous_backup_enabled = true - - lifecycle { - ignore_changes = [connection_strings_private_endpoint_srv] - } - } - - `, projectID, instanceName, comment) -} - -func testAccDSCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessExists(resourceName string) resource.TestCheckFunc { - return func(s *terraform.State) error { - conn := testAccProvider.Meta().(*MongoDBClient).Atlas - - rs, ok := s.RootModule().Resources[resourceName] - if !ok { - return fmt.Errorf("not found: %s", resourceName) - } - - if rs.Primary.ID == "" { - return fmt.Errorf("no ID is set") - } - - ids := decodeStateID(rs.Primary.ID) - - _, _, err := conn.ServerlessPrivateEndpoints.Get(context.Background(), ids["project_id"], ids["instance_name"], ids["endpoint_id"]) - if err == nil { - return nil - } - - return fmt.Errorf("endpoint_id (%s) does not exist", ids["endpoint_id"]) - } -} diff --git a/mongodbatlas/data_source_mongodbatlas_privatelink_endpoints_service_serverless_test.go b/mongodbatlas/data_source_mongodbatlas_privatelink_endpoints_service_serverless_test.go deleted file mode 100644 index d7aad88823..0000000000 --- a/mongodbatlas/data_source_mongodbatlas_privatelink_endpoints_service_serverless_test.go +++ /dev/null @@ -1,74 +0,0 @@ -package mongodbatlas - -import ( - "fmt" - "os" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" -) - -func TestAccNetworkDSPrivateLinkEndpointsServiceServerless_basic(t *testing.T) { - datasourceName := "data.mongodbatlas_privatelink_endpoints_service_serverless.test" - projectID := os.Getenv("MONGODB_ATLAS_PROJECT_ID") - instanceID := "serverless" - comments := "Test Comments" - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - ProviderFactories: testAccProviderFactories, - Steps: []resource.TestStep{ - { - Config: testAccMongoDBAtlasPrivateLinkEndpointsServerlessDataSourceConfig(projectID, instanceID, comments), - Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttrSet(datasourceName, "project_id"), - resource.TestCheckResourceAttrSet(datasourceName, "results.#"), - resource.TestCheckResourceAttrSet(datasourceName, "instance_name"), - ), - }, - }, - }) -} - -func testAccMongoDBAtlasPrivateLinkEndpointsServerlessDataSourceConfig(projectID, instanceID, comments string) string { - return fmt.Sprintf(` - data "mongodbatlas_privatelink_endpoint_service_serverless" "test" { - project_id = mongodbatlas_privatelink_endpoint_service_serverless.test.project_id - instance_name = mongodbatlas_serverless_instance.test.name - endpoint_id = mongodbatlas_privatelink_endpoint_service_serverless.test.endpoint_id - } - - data "mongodbatlas_privatelink_endpoints_service_serverless" "test" { - project_id = mongodbatlas_privatelink_endpoint_service_serverless.test.project_id - instance_name = mongodbatlas_serverless_instance.test.name - } - - resource "mongodbatlas_privatelink_endpoint_serverless" "test" { - project_id = "%[1]s" - instance_name = mongodbatlas_serverless_instance.test.name - provider_name = "AWS" - } - - - resource "mongodbatlas_privatelink_endpoint_service_serverless" "test" { - project_id = "%[1]s" - instance_name = "%[2]s" - endpoint_id = mongodbatlas_privatelink_endpoint_serverless.test.endpoint_id - provider_name = "AWS" - comment = "%[3]s" - } - - resource "mongodbatlas_serverless_instance" "test" { - project_id = "%[1]s" - name = "%[2]s" - provider_settings_backing_provider_name = "AWS" - provider_settings_provider_name = "SERVERLESS" - provider_settings_region_name = "US_EAST_1" - continuous_backup_enabled = true - - lifecycle { - ignore_changes = [connection_strings_private_endpoint_srv] - } - } - `, projectID, instanceID, comments) -} diff --git a/mongodbatlas/data_source_mongodbatlas_serverless_instance_test.go b/mongodbatlas/data_source_mongodbatlas_serverless_instance_test.go deleted file mode 100644 index d9b66404cf..0000000000 --- a/mongodbatlas/data_source_mongodbatlas_serverless_instance_test.go +++ /dev/null @@ -1,50 +0,0 @@ -package mongodbatlas - -import ( - "fmt" - "os" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" -) - -func TestAccClusterDSServerlessInstance_byName(t *testing.T) { - var ( - instanceName = acctest.RandomWithPrefix("test-serverless-instance") - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") - datasourceName = "data.mongodbatlas_serverless_instance.test_two" - ) - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t); testAccPreCheckBetaFeatures(t) }, - ProviderFactories: testAccProviderFactories, - CheckDestroy: testAccCheckMongoDBAtlasServerlessInstanceDestroy, - Steps: []resource.TestStep{ - { - Config: testAccMongoDBAtlasServerlessInstanceDSConfig(projectID, instanceName), - Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttrSet(datasourceName, "name"), - resource.TestCheckResourceAttrSet(datasourceName, "project_id"), - resource.TestCheckResourceAttrSet(datasourceName, "state_name"), - resource.TestCheckResourceAttrSet(datasourceName, "create_date"), - resource.TestCheckResourceAttrSet(datasourceName, "mongo_db_version"), - resource.TestCheckResourceAttrSet(datasourceName, "continuous_backup_enabled"), - resource.TestCheckResourceAttrSet(datasourceName, "termination_protection_enabled"), - ), - }, - }, - }) -} - -func testAccMongoDBAtlasServerlessInstanceDSConfig(projectID, name string) string { - return fmt.Sprintf(` - %s - - data "mongodbatlas_serverless_instance" "test_two" { - name = mongodbatlas_serverless_instance.test.name - project_id = mongodbatlas_serverless_instance.test.project_id - } - - `, testAccMongoDBAtlasServerlessInstanceConfig(projectID, name, true)) -} diff --git a/mongodbatlas/data_source_mongodbatlas_serverless_instances_test.go b/mongodbatlas/data_source_mongodbatlas_serverless_instances_test.go deleted file mode 100644 index b77984fca6..0000000000 --- a/mongodbatlas/data_source_mongodbatlas_serverless_instances_test.go +++ /dev/null @@ -1,48 +0,0 @@ -package mongodbatlas - -import ( - "fmt" - "os" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" -) - -func TestAccClusterDSServerlessInstances_basic(t *testing.T) { - var ( - clusterName = acctest.RandomWithPrefix("test-acc-serverless") - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") - datasourceName = "data.mongodbatlas_serverless_instances.data_serverless" - ) - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t); testAccPreCheckBetaFeatures(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckMongoDBAtlasServerlessInstanceDestroy, - Steps: []resource.TestStep{ - { - Config: testAccMongoDBAtlasServerlessInstancesDSConfig(projectID, clusterName), - Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttrSet(datasourceName, "project_id"), - resource.TestCheckResourceAttrSet(datasourceName, "results.#"), - resource.TestCheckResourceAttrSet(datasourceName, "results.0.id"), - resource.TestCheckResourceAttrSet(datasourceName, "results.0.name"), - resource.TestCheckResourceAttrSet(datasourceName, "results.0.state_name"), - resource.TestCheckResourceAttrSet(datasourceName, "results.0.continuous_backup_enabled"), - resource.TestCheckResourceAttrSet(datasourceName, "results.0.termination_protection_enabled"), - ), - }, - }, - }) -} - -func testAccMongoDBAtlasServerlessInstancesDSConfig(projectID, name string) string { - return fmt.Sprintf(` - %s - - data "mongodbatlas_serverless_instances" "data_serverless" { - project_id = mongodbatlas_serverless_instance.test.project_id - } - `, testAccMongoDBAtlasServerlessInstanceConfig(projectID, name, true)) -} diff --git a/mongodbatlas/resource_mongodbatlas_network_container_test.go b/mongodbatlas/resource_mongodbatlas_network_container_test.go index a5a85e5094..0d1baf90c6 100644 --- a/mongodbatlas/resource_mongodbatlas_network_container_test.go +++ b/mongodbatlas/resource_mongodbatlas_network_container_test.go @@ -19,6 +19,8 @@ func TestAccNetworkRSNetworkContainer_basicAWS(t *testing.T) { randInt = acctest.RandIntRange(0, 255) randIntUpdated = acctest.RandIntRange(0, 255) resourceName = "mongodbatlas_network_container.test" + dataSourceName = "data.mongodbatlas_network_container.test_ds" + dataSourceContainersName = "data.mongodbatlas_network_containers.test" cidrBlock = fmt.Sprintf("10.8.%d.0/24", randInt) cidrBlockUpdated = fmt.Sprintf("10.8.%d.0/24", randIntUpdated) providerName = "AWS" @@ -26,8 +28,8 @@ func TestAccNetworkRSNetworkContainer_basicAWS(t *testing.T) { projectName = acctest.RandomWithPrefix("test-acc") ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, Steps: []resource.TestStep{ @@ -39,6 +41,15 @@ func TestAccNetworkRSNetworkContainer_basicAWS(t *testing.T) { resource.TestCheckResourceAttrSet(resourceName, "project_id"), resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), resource.TestCheckResourceAttrSet(resourceName, "provisioned"), + resource.TestCheckResourceAttrSet(dataSourceName, "project_id"), + resource.TestCheckResourceAttr(dataSourceName, "provider_name", providerName), + resource.TestCheckResourceAttrSet(dataSourceName, "provisioned"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.#"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.id"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.atlas_cidr_block"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.provider_name"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.provisioned"), + ), }, { @@ -68,8 +79,8 @@ func TestAccNetworkRSNetworkContainer_basicAzure(t *testing.T) { projectName = acctest.RandomWithPrefix("test-acc") ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, Steps: []resource.TestStep{ @@ -110,8 +121,8 @@ func TestAccNetworkRSNetworkContainer_basicGCP(t *testing.T) { projectName = acctest.RandomWithPrefix("test-acc") ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, Steps: []resource.TestStep{ @@ -144,14 +155,16 @@ func TestAccNetworkRSNetworkContainer_WithRegionsGCP(t *testing.T) { container matlas.Container randInt = acctest.RandIntRange(0, 255) resourceName = "mongodbatlas_network_container.test" + dataSourceName = "data.mongodbatlas_network_container.test" + dataSourceContainersName = "data.mongodbatlas_network_containers.test" cidrBlock = fmt.Sprintf("10.%d.0.0/21", randInt) providerName = "GCP" orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") projectName = acctest.RandomWithPrefix("test-acc") ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, Steps: []resource.TestStep{ @@ -163,6 +176,12 @@ func TestAccNetworkRSNetworkContainer_WithRegionsGCP(t *testing.T) { resource.TestCheckResourceAttrSet(resourceName, "project_id"), resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), resource.TestCheckResourceAttrSet(resourceName, "provisioned"), + resource.TestCheckResourceAttrSet(dataSourceName, "project_id"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.#"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.id"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.atlas_cidr_block"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.provider_name"), + resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.provisioned"), ), }, }, @@ -179,8 +198,8 @@ func TestAccNetworkRSNetworkContainer_importBasic(t *testing.T) { projectName = acctest.RandomWithPrefix("test-acc") ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasNetworkContainerDestroy, Steps: []resource.TestStep{ @@ -270,11 +289,22 @@ func testAccMongoDBAtlasNetworkContainerConfigAWS(projectName, orgID, cidrBlock, } resource "mongodbatlas_network_container" "test" { - project_id = "${mongodbatlas_project.test.id}" + project_id = mongodbatlas_project.test.id atlas_cidr_block = "%s" provider_name = "%s" region_name = "%s" } + + data "mongodbatlas_network_container" "test_ds" { + project_id = mongodbatlas_network_container.test_ds.project_id + container_id = mongodbatlas_network_container.test_ds.id + } + + data "mongodbatlas_network_containers" "test" { + project_id = "${mongodbatlas_network_container.test.project_id}" + provider_name = "AWS" + } + `, projectName, orgID, cidrBlock, providerName, region) } @@ -322,5 +352,15 @@ func testAccMongoDBAtlasNetworkContainerConfigGCPWithRegions(projectName, orgID, provider_name = "%s" regions = ["US_EAST_4", "US_WEST_3"] } + + data "mongodbatlas_network_container" "test" { + project_id = mongodbatlas_network_container.test.project_id + container_id = mongodbatlas_network_container.test.id + } + + data "mongodbatlas_network_containers" "test" { + project_id = mongodbatlas_network_container.test.project_id + provider_name = "GCP" + } `, projectName, orgID, cidrBlock, providerName) } diff --git a/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go b/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go index 928b5707d0..22bd8bb6a3 100644 --- a/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go +++ b/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go @@ -73,17 +73,17 @@ func TestAccNetworkRSPrivateEndpointRegionalMode_basic(t *testing.T) { var ( resourceSuffix = "atlasrm" resourceName = fmt.Sprintf("mongodbatlas_private_endpoint_regional_mode.%s", resourceSuffix) - - projectID = os.Getenv("MONGODB_ATLAS_NETWORK_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") ) - resource.Test(t, resource.TestCase{ + resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateEndpointRegionalModeDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, projectID, false), + Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix,orgID, projectName, false), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateEndpointRegionalModeExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), @@ -92,7 +92,7 @@ func TestAccNetworkRSPrivateEndpointRegionalMode_basic(t *testing.T) { ), }, { - Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, projectID, true), + Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, orgID, projectName, true), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateEndpointRegionalModeExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), @@ -120,13 +120,13 @@ func testAccMongoDBAtlasPrivateEndpointRegionalModeClusterData(clusterResourceNa func testAccMongoDBAtlasPrivateEndpointRegionalModeConfigWithDependencies(resourceName, projectID string, enabled bool, dependencies []string) string { resources := make([]string, len(dependencies)+1) - resources[0] = testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceName, projectID, enabled) + resources[0] = testAccMongoDBAtlasPrivateEndpointRegionalModeConfigNoProject(resourceName, projectID, enabled) copy(resources[1:], dependencies) return strings.Join(resources, "\n\n") } -func testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceName, projectID string, enabled bool) string { +func testAccMongoDBAtlasPrivateEndpointRegionalModeConfigNoProject(resourceName, projectID string, enabled bool) string { return fmt.Sprintf(` resource "mongodbatlas_private_endpoint_regional_mode" %[1]q { project_id = %[2]q @@ -135,6 +135,19 @@ func testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceName, projectI `, resourceName, projectID, enabled) } +func testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceName, orgID, projectName string, enabled bool) string { + return fmt.Sprintf(` + resource "mongodbatlas_project" "test" { + name = %[3]q + org_id = %[2]q + } + resource "mongodbatlas_private_endpoint_regional_mode" %[1]q { + project_id = mongodbatlas_project.test.id + enabled = %[4]t + } + `, resourceName, orgID, projectName, enabled) +} + func testAccCheckMongoDBAtlasPrivateEndpointRegionalModeExists(resourceName string) resource.TestCheckFunc { return func(s *terraform.State) error { fmt.Printf("==========================================================================\n") diff --git a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_serverless_test.go b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_serverless_test.go index aad4fbb23a..c3670c2a19 100644 --- a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_serverless_test.go +++ b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_serverless_test.go @@ -6,24 +6,26 @@ import ( "os" "testing" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" ) -func TestAccNetworkRSPrivateLinkEndpointServerless_basic(t *testing.T) { +func TestAccServerlessPrivateLinkEndpoint_basic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint_serverless.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") instanceName = "serverlessplink" ) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointServerlessDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(projectID, instanceName, true), + Config: testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(orgID, projectName, instanceName, true), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateLinkEndpointServerlessExists(resourceName), resource.TestCheckResourceAttr(resourceName, "instance_name", instanceName), @@ -33,25 +35,26 @@ func TestAccNetworkRSPrivateLinkEndpointServerless_basic(t *testing.T) { }) } -func TestAccNetworkRSPrivateLinkEndpointServerless_importBasic(t *testing.T) { +func TestAccServerlessPrivateLinkEndpoint_importBasic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint_serverless.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") instanceName = "serverlessimport" ) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointServerlessDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(projectID, instanceName, true), + Config: testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(orgID, projectName, instanceName, true), Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttr(resourceName, "instance_name", instanceName), ), }, { - Config: testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(projectID, instanceName, false), + Config: testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(orgID, projectName, instanceName, false), ResourceName: resourceName, ImportStateIdFunc: testAccCheckMongoDBAtlasPrivateLinkEndpointServerlessImportStateIDFunc(resourceName), ImportState: true, @@ -81,7 +84,7 @@ func testAccCheckMongoDBAtlasPrivateLinkEndpointServerlessDestroy(state *terrafo return nil } -func testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(projectID, instanceName string, ignoreConnectionStrings bool) string { +func testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(orgID, projectName, instanceName string, ignoreConnectionStrings bool) string { return fmt.Sprintf(` resource "mongodbatlas_privatelink_endpoint_serverless" "test" { @@ -91,7 +94,7 @@ func testAccMongoDBAtlasPrivateLinkEndpointServerlessConfig(projectID, instanceN } %s - `, testAccMongoDBAtlasServerlessInstanceConfig(projectID, instanceName, ignoreConnectionStrings)) + `, testAccMongoDBAtlasServerlessInstanceConfig(orgID, projectName, instanceName, ignoreConnectionStrings)) } func testAccCheckMongoDBAtlasPrivateLinkEndpointServerlessExists(resourceName string) resource.TestCheckFunc { diff --git a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_adl_test.go b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_adl_test.go index 95766e829d..975d0e7ea4 100644 --- a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_adl_test.go +++ b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_adl_test.go @@ -14,7 +14,7 @@ func TestAccNetworkRSPrivateLinkEndpointServiceADL_basic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint_service_adl.test" projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") - endpointID = "vpce-jjg5e24qp93513h03" + endpointID = os.Getenv("MONGODB_ATLAS_ENDPOINT_ID") commentOrigin = "this is a comment for adl private link endpoint" commentUpdate = "this is a comment for adl private link endpoint UPDATED" ) @@ -52,7 +52,7 @@ func TestAccNetworkRSPrivateLinkEndpointServiceADL_importBasic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint_service_adl.test" projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") - endpointID = "vpce-jjg5e24qp93513h03" + endpointID = os.Getenv("MONGODB_ATLAS_ENDPOINT_ID") commentOrigin = "this is a comment for adl private link endpoint" ) resource.Test(t, resource.TestCase{ diff --git a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go index 7311eeebb1..a3aee3e098 100644 --- a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go +++ b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go @@ -6,56 +6,65 @@ import ( "os" "testing" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" ) -func TestAccNetworkRSPrivateLinkEndpointServiceServerless_basic(t *testing.T) { +func TestAccServerlessPrivateLinkEndpointService_basic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint_service_serverless.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") - instanceName = "serverlesssrv" + datasourceName = "data.mongodbatlas_privatelink_endpoint_service_serverless.test" + datasourceEndpointsName = "data.mongodbatlas_privatelink_endpoints_service_serverless.test" + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") + instanceName = acctest.RandomWithPrefix("test-acc-serverless") commentOrigin = "this is a comment for serverless private link endpoint" ) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, instanceName, commentOrigin), + Config: testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(orgID, projectName, instanceName, commentOrigin), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessExists(resourceName), resource.TestCheckResourceAttr(resourceName, "provider_name", "AWS"), resource.TestCheckResourceAttr(resourceName, "comment", commentOrigin), + resource.TestCheckResourceAttr(datasourceName, "comment", commentOrigin), + resource.TestCheckResourceAttrSet(datasourceEndpointsName, "project_id"), + resource.TestCheckResourceAttrSet(datasourceEndpointsName, "results.#"), + resource.TestCheckResourceAttrSet(datasourceEndpointsName, "instance_name"), ), }, }, }) } -func TestAccNetworkRSPrivateLinkEndpointServiceServerless_importBasic(t *testing.T) { +func TestAccServerlessPrivateLinkEndpointService_importBasic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint_service_serverless.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") - instanceName = "serverlesssrvimport" + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") + instanceName = acctest.RandomWithPrefix("test-acc-serverless") commentOrigin = "this is a comment for serverless private link endpoint" ) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasSearchIndexDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, instanceName, commentOrigin), + Config: testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(orgID, projectName, instanceName, commentOrigin), Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttr(resourceName, "provider_name", "AWS"), resource.TestCheckResourceAttr(resourceName, "comment", commentOrigin), ), }, { - Config: testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, instanceName, commentOrigin), + Config: testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(orgID, projectName, instanceName, commentOrigin), ResourceName: resourceName, ImportStateIdFunc: testAccCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessImportStateIDFunc(resourceName), ImportState: true, @@ -84,11 +93,16 @@ func testAccCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessDestroy(state * return nil } -func testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, instanceName, comment string) string { +func testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(orgID, projectName, instanceName, comment string) string { return fmt.Sprintf(` + resource "mongodbatlas_project" "test" { + name = %[2]q + org_id = %[1]q + } + resource "mongodbatlas_privatelink_endpoint_serverless" "test" { - project_id = "%[1]s" + project_id = mongodbatlas_project.test.id instance_name = mongodbatlas_serverless_instance.test.name provider_name = "AWS" } @@ -99,12 +113,12 @@ func testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, in instance_name = mongodbatlas_privatelink_endpoint_serverless.test.instance_name endpoint_id = mongodbatlas_privatelink_endpoint_serverless.test.endpoint_id provider_name = "AWS" - comment = "%[3]s" + comment = %[4]q } resource "mongodbatlas_serverless_instance" "test" { - project_id = "%[1]s" - name = "%[2]s" + project_id = mongodbatlas_project.test.id + name = %[3]q provider_settings_backing_provider_name = "AWS" provider_settings_provider_name = "SERVERLESS" provider_settings_region_name = "US_EAST_1" @@ -120,7 +134,18 @@ func testAccMongoDBAtlasPrivateLinkEndpointServiceServerlessConfig(projectID, in name = mongodbatlas_serverless_instance.test.name } - `, projectID, instanceName, comment) + data "mongodbatlas_privatelink_endpoints_service_serverless" "test" { + project_id = mongodbatlas_privatelink_endpoint_service_serverless.test.project_id + instance_name = mongodbatlas_serverless_instance.test.name + } + + data "mongodbatlas_privatelink_endpoint_service_serverless" "test" { + project_id = mongodbatlas_privatelink_endpoint_service_serverless.test.project_id + instance_name = mongodbatlas_serverless_instance.test.name + endpoint_id = mongodbatlas_privatelink_endpoint_service_serverless.test.endpoint_id + } + + `, orgID, projectName, instanceName, comment) } func testAccCheckMongoDBAtlasPrivateLinkEndpointServiceServerlessExists(resourceName string) resource.TestCheckFunc { diff --git a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_test.go b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_test.go index 6d424277e8..b645055394 100644 --- a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_test.go +++ b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_test.go @@ -6,6 +6,7 @@ import ( "os" "testing" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" ) @@ -13,25 +14,24 @@ import ( func TestAccNetworkRSPrivateLinkEndpointAWS_basic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") region = "us-east-1" providerName = "AWS" ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(projectID, providerName, region), + Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(orgID, projectName, providerName, region), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateLinkEndpointExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), resource.TestCheckResourceAttrSet(resourceName, "provider_name"), resource.TestCheckResourceAttrSet(resourceName, "region"), - - resource.TestCheckResourceAttr(resourceName, "project_id", projectID), resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), resource.TestCheckResourceAttr(resourceName, "region", region), ), @@ -43,25 +43,24 @@ func TestAccNetworkRSPrivateLinkEndpointAWS_basic(t *testing.T) { func TestAccNetworkRSPrivateLinkEndpointAWS_import(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") region = "us-east-1" providerName = "AWS" ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(projectID, providerName, region), + Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(orgID, projectName, providerName, region), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateLinkEndpointExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), resource.TestCheckResourceAttrSet(resourceName, "provider_name"), resource.TestCheckResourceAttrSet(resourceName, "region"), - - resource.TestCheckResourceAttr(resourceName, "project_id", projectID), resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), resource.TestCheckResourceAttr(resourceName, "region", region), ), @@ -78,25 +77,24 @@ func TestAccNetworkRSPrivateLinkEndpointAWS_import(t *testing.T) { func TestAccNetworkRSPrivateLinkEndpointAzure_basic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") region = "US_EAST_2" providerName = "AZURE" ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(projectID, providerName, region), + Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(orgID, projectName, providerName, region), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateLinkEndpointExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), resource.TestCheckResourceAttrSet(resourceName, "provider_name"), resource.TestCheckResourceAttrSet(resourceName, "region"), - - resource.TestCheckResourceAttr(resourceName, "project_id", projectID), resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), resource.TestCheckResourceAttr(resourceName, "region", region), ), @@ -108,25 +106,24 @@ func TestAccNetworkRSPrivateLinkEndpointAzure_basic(t *testing.T) { func TestAccNetworkRSPrivateLinkEndpointAzure_import(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") region = "US_EAST_2" providerName = "AZURE" ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(projectID, providerName, region), + Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(orgID, projectName, providerName, region), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateLinkEndpointExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), resource.TestCheckResourceAttrSet(resourceName, "provider_name"), resource.TestCheckResourceAttrSet(resourceName, "region"), - - resource.TestCheckResourceAttr(resourceName, "project_id", projectID), resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), resource.TestCheckResourceAttr(resourceName, "region", region), ), @@ -144,25 +141,24 @@ func TestAccNetworkRSPrivateLinkEndpointAzure_import(t *testing.T) { func TestAccNetworkRSPrivateLinkEndpointGCP_basic(t *testing.T) { var ( resourceName = "mongodbatlas_privatelink_endpoint.test" - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") region = "us-central1" providerName = "GCP" ) - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateLinkEndpointDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(projectID, providerName, region), + Config: testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(orgID, projectName, providerName, region), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateLinkEndpointExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), resource.TestCheckResourceAttrSet(resourceName, "provider_name"), resource.TestCheckResourceAttrSet(resourceName, "region"), - - resource.TestCheckResourceAttr(resourceName, "project_id", projectID), resource.TestCheckResourceAttr(resourceName, "provider_name", providerName), resource.TestCheckResourceAttr(resourceName, "region", region), ), @@ -231,12 +227,16 @@ func testAccCheckMongoDBAtlasPrivateLinkEndpointDestroy(s *terraform.State) erro return nil } -func testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(projectID, providerName, region string) string { +func testAccMongoDBAtlasPrivateLinkEndpointConfigBasic(orgID, projectName, providerName, region string) string { return fmt.Sprintf(` + resource "mongodbatlas_project" "test" { + name = %[2]q + org_id = %[1]q + } resource "mongodbatlas_privatelink_endpoint" "test" { - project_id = "%s" - provider_name = "%s" - region = "%s" + project_id = mongodbatlas_project.test.id + provider_name = %[3]q + region = %[4]q } - `, projectID, providerName, region) + `, orgID, projectName, providerName, region) } diff --git a/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go b/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go index 94751ede29..df1382e466 100644 --- a/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go +++ b/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go @@ -12,25 +12,41 @@ import ( matlas "go.mongodb.org/atlas/mongodbatlas" ) -func TestAccClusterRSServerlessInstance_basic(t *testing.T) { +func TestAccServerlessInstance_basic(t *testing.T) { var ( serverlessInstance matlas.Cluster resourceName = "mongodbatlas_serverless_instance.test" instanceName = acctest.RandomWithPrefix("test-acc-serverless") - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") + datasourceName = "data.mongodbatlas_serverless_instance.test_two" + datasourceInstancesName = "data.mongodbatlas_serverless_instances.data_serverless" ) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t); testAccPreCheckBetaFeatures(t) }, + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasServerlessInstanceDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasServerlessInstanceConfig(projectID, instanceName, true), + Config: testAccMongoDBAtlasServerlessInstanceConfig(orgID, projectName, instanceName, true), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasServerlessInstanceExists(resourceName, &serverlessInstance), - resource.TestCheckResourceAttr(resourceName, "project_id", projectID), resource.TestCheckResourceAttr(resourceName, "name", instanceName), resource.TestCheckResourceAttr(resourceName, "termination_protection_enabled", "false"), + resource.TestCheckResourceAttrSet(datasourceName, "name"), + resource.TestCheckResourceAttrSet(datasourceName, "project_id"), + resource.TestCheckResourceAttrSet(datasourceName, "state_name"), + resource.TestCheckResourceAttrSet(datasourceName, "create_date"), + resource.TestCheckResourceAttrSet(datasourceName, "mongo_db_version"), + resource.TestCheckResourceAttrSet(datasourceName, "continuous_backup_enabled"), + resource.TestCheckResourceAttrSet(datasourceName, "termination_protection_enabled"), + resource.TestCheckResourceAttrSet(datasourceInstancesName, "project_id"), + resource.TestCheckResourceAttrSet(datasourceInstancesName, "results.#"), + resource.TestCheckResourceAttrSet(datasourceInstancesName, "results.0.id"), + resource.TestCheckResourceAttrSet(datasourceInstancesName, "results.0.name"), + resource.TestCheckResourceAttrSet(datasourceInstancesName, "results.0.state_name"), + resource.TestCheckResourceAttrSet(datasourceInstancesName, "results.0.continuous_backup_enabled"), + resource.TestCheckResourceAttrSet(datasourceInstancesName, "results.0.termination_protection_enabled"), testAccCheckConnectionStringPrivateEndpointIsPresentWithNoElement(resourceName), ), }, @@ -38,20 +54,21 @@ func TestAccClusterRSServerlessInstance_basic(t *testing.T) { }) } -func TestAccClusterRSServerlessInstance_importBasic(t *testing.T) { +func TestAccServerlessInstance_importBasic(t *testing.T) { var ( resourceName = "mongodbatlas_serverless_instance.test" instanceName = acctest.RandomWithPrefix("test-acc-serverless") - projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") ) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t); testAccPreCheckBetaFeatures(t) }, + PreCheck: func() { testAccPreCheckBasic(t)}, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasServerlessInstanceDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasServerlessInstanceConfig(projectID, instanceName, true), + Config: testAccMongoDBAtlasServerlessInstanceConfig(orgID, projectName, instanceName, true), }, { ResourceName: resourceName, @@ -134,7 +151,7 @@ func testAccCheckConnectionStringPrivateEndpointIsPresentWithNoElement(resourceN } } -func testAccMongoDBAtlasServerlessInstanceConfig(projectID, name string, ignoreConnectionStrings bool) string { +func testAccMongoDBAtlasServerlessInstanceConfig(orgID, projectName, name string, ignoreConnectionStrings bool) string { lifecycle := "" if ignoreConnectionStrings { @@ -147,16 +164,29 @@ func testAccMongoDBAtlasServerlessInstanceConfig(projectID, name string, ignoreC } return fmt.Sprintf(` + resource "mongodbatlas_project" "test" { + name = %[2]q + org_id = %[1]q + } resource "mongodbatlas_serverless_instance" "test" { - project_id = "%[1]s" - name = "%[2]s" + project_id = mongodbatlas_project.test.id + name = %[3]q provider_settings_backing_provider_name = "AWS" provider_settings_provider_name = "SERVERLESS" provider_settings_region_name = "US_EAST_1" continuous_backup_enabled = true - %[3]s + %[4]s + } + + data "mongodbatlas_serverless_instance" "test_two" { + name = mongodbatlas_serverless_instance.test.name + project_id = mongodbatlas_serverless_instance.test.project_id + } + + data "mongodbatlas_serverless_instances" "data_serverless" { + project_id = mongodbatlas_serverless_instance.test.project_id } - `, projectID, name, lifecycle) + `, orgID, projectName, name, lifecycle) } From 79e31774cb1cdf3f7a12ef219d6026fbed087922 Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 21 Jun 2023 11:27:08 +0200 Subject: [PATCH 2/7] make fmt --- ...rce_mongodbatlas_network_container_test.go | 37 +++++++++---------- ...las_private_endpoint_regional_mode_test.go | 6 +-- ...telink_endpoint_service_serverless_test.go | 12 +++--- ...e_mongodbatlas_serverless_instance_test.go | 18 ++++----- 4 files changed, 36 insertions(+), 37 deletions(-) diff --git a/mongodbatlas/resource_mongodbatlas_network_container_test.go b/mongodbatlas/resource_mongodbatlas_network_container_test.go index 0d1baf90c6..ac40de75c8 100644 --- a/mongodbatlas/resource_mongodbatlas_network_container_test.go +++ b/mongodbatlas/resource_mongodbatlas_network_container_test.go @@ -15,17 +15,17 @@ import ( func TestAccNetworkRSNetworkContainer_basicAWS(t *testing.T) { var ( - container matlas.Container - randInt = acctest.RandIntRange(0, 255) - randIntUpdated = acctest.RandIntRange(0, 255) - resourceName = "mongodbatlas_network_container.test" - dataSourceName = "data.mongodbatlas_network_container.test_ds" + container matlas.Container + randInt = acctest.RandIntRange(0, 255) + randIntUpdated = acctest.RandIntRange(0, 255) + resourceName = "mongodbatlas_network_container.test" + dataSourceName = "data.mongodbatlas_network_container.test_ds" dataSourceContainersName = "data.mongodbatlas_network_containers.test" - cidrBlock = fmt.Sprintf("10.8.%d.0/24", randInt) - cidrBlockUpdated = fmt.Sprintf("10.8.%d.0/24", randIntUpdated) - providerName = "AWS" - orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName = acctest.RandomWithPrefix("test-acc") + cidrBlock = fmt.Sprintf("10.8.%d.0/24", randInt) + cidrBlockUpdated = fmt.Sprintf("10.8.%d.0/24", randIntUpdated) + providerName = "AWS" + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") ) resource.ParallelTest(t, resource.TestCase{ @@ -49,7 +49,6 @@ func TestAccNetworkRSNetworkContainer_basicAWS(t *testing.T) { resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.atlas_cidr_block"), resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.provider_name"), resource.TestCheckResourceAttrSet(dataSourceContainersName, "results.0.provisioned"), - ), }, { @@ -152,15 +151,15 @@ func TestAccNetworkRSNetworkContainer_basicGCP(t *testing.T) { func TestAccNetworkRSNetworkContainer_WithRegionsGCP(t *testing.T) { var ( - container matlas.Container - randInt = acctest.RandIntRange(0, 255) - resourceName = "mongodbatlas_network_container.test" - dataSourceName = "data.mongodbatlas_network_container.test" + container matlas.Container + randInt = acctest.RandIntRange(0, 255) + resourceName = "mongodbatlas_network_container.test" + dataSourceName = "data.mongodbatlas_network_container.test" dataSourceContainersName = "data.mongodbatlas_network_containers.test" - cidrBlock = fmt.Sprintf("10.%d.0.0/21", randInt) - providerName = "GCP" - orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName = acctest.RandomWithPrefix("test-acc") + cidrBlock = fmt.Sprintf("10.%d.0.0/21", randInt) + providerName = "GCP" + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") ) resource.ParallelTest(t, resource.TestCase{ diff --git a/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go b/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go index 22bd8bb6a3..24c75ad6bb 100644 --- a/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go +++ b/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go @@ -73,8 +73,8 @@ func TestAccNetworkRSPrivateEndpointRegionalMode_basic(t *testing.T) { var ( resourceSuffix = "atlasrm" resourceName = fmt.Sprintf("mongodbatlas_private_endpoint_regional_mode.%s", resourceSuffix) - orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName = acctest.RandomWithPrefix("test-acc") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc") ) resource.ParallelTest(t, resource.TestCase{ @@ -83,7 +83,7 @@ func TestAccNetworkRSPrivateEndpointRegionalMode_basic(t *testing.T) { CheckDestroy: testAccCheckMongoDBAtlasPrivateEndpointRegionalModeDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix,orgID, projectName, false), + Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, orgID, projectName, false), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateEndpointRegionalModeExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), diff --git a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go index a3aee3e098..b7f4025c48 100644 --- a/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go +++ b/mongodbatlas/resource_mongodbatlas_privatelink_endpoint_service_serverless_test.go @@ -13,13 +13,13 @@ import ( func TestAccServerlessPrivateLinkEndpointService_basic(t *testing.T) { var ( - resourceName = "mongodbatlas_privatelink_endpoint_service_serverless.test" - datasourceName = "data.mongodbatlas_privatelink_endpoint_service_serverless.test" + resourceName = "mongodbatlas_privatelink_endpoint_service_serverless.test" + datasourceName = "data.mongodbatlas_privatelink_endpoint_service_serverless.test" datasourceEndpointsName = "data.mongodbatlas_privatelink_endpoints_service_serverless.test" - orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName = acctest.RandomWithPrefix("test-acc-serverless") - instanceName = acctest.RandomWithPrefix("test-acc-serverless") - commentOrigin = "this is a comment for serverless private link endpoint" + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") + instanceName = acctest.RandomWithPrefix("test-acc-serverless") + commentOrigin = "this is a comment for serverless private link endpoint" ) resource.ParallelTest(t, resource.TestCase{ diff --git a/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go b/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go index df1382e466..d6dec7acc3 100644 --- a/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go +++ b/mongodbatlas/resource_mongodbatlas_serverless_instance_test.go @@ -14,12 +14,12 @@ import ( func TestAccServerlessInstance_basic(t *testing.T) { var ( - serverlessInstance matlas.Cluster - resourceName = "mongodbatlas_serverless_instance.test" - instanceName = acctest.RandomWithPrefix("test-acc-serverless") - orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName = acctest.RandomWithPrefix("test-acc-serverless") - datasourceName = "data.mongodbatlas_serverless_instance.test_two" + serverlessInstance matlas.Cluster + resourceName = "mongodbatlas_serverless_instance.test" + instanceName = acctest.RandomWithPrefix("test-acc-serverless") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") + datasourceName = "data.mongodbatlas_serverless_instance.test_two" datasourceInstancesName = "data.mongodbatlas_serverless_instances.data_serverless" ) resource.ParallelTest(t, resource.TestCase{ @@ -58,12 +58,12 @@ func TestAccServerlessInstance_importBasic(t *testing.T) { var ( resourceName = "mongodbatlas_serverless_instance.test" instanceName = acctest.RandomWithPrefix("test-acc-serverless") - orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName = acctest.RandomWithPrefix("test-acc-serverless") + orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") + projectName = acctest.RandomWithPrefix("test-acc-serverless") ) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheckBasic(t)}, + PreCheck: func() { testAccPreCheckBasic(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasServerlessInstanceDestroy, Steps: []resource.TestStep{ From f575276700bae60566d278c22ba4a5d91f7078e0 Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 21 Jun 2023 11:30:43 +0200 Subject: [PATCH 3/7] Update provider_test.go --- mongodbatlas/provider_test.go | 7 ------- 1 file changed, 7 deletions(-) diff --git a/mongodbatlas/provider_test.go b/mongodbatlas/provider_test.go index 95b1546fe8..f7aa7beb0a 100644 --- a/mongodbatlas/provider_test.go +++ b/mongodbatlas/provider_test.go @@ -72,13 +72,6 @@ func testAccPreCheckGov(tb testing.TB) { } } -func testAccPreCheckBetaFeatures(tb testing.TB) { - enableFeatures, _ := strconv.ParseBool(os.Getenv("MONGODB_ATLAS_ENABLE_BETA")) - if !enableFeatures { - tb.Fatal("`MONGODB_ATLAS_ENABLE_BETA` must be set to `true` in order to run beta features") - } -} - func testAccPreCheckGPCEnv(tb testing.TB) { if os.Getenv("GCP_SERVICE_ACCOUNT_KEY") == "" || os.Getenv("GCP_KEY_VERSION_RESOURCE_ID") == "" { tb.Fatal("`GCP_SERVICE_ACCOUNT_KEY` and `GCP_KEY_VERSION_RESOURCE_ID` must be set for acceptance testing") From f85cff017ee5fb72f7fea6adcd7f3208affcbf9b Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 21 Jun 2023 11:32:05 +0200 Subject: [PATCH 4/7] Update provider_test.go --- mongodbatlas/provider_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/mongodbatlas/provider_test.go b/mongodbatlas/provider_test.go index f7aa7beb0a..1367cf099b 100644 --- a/mongodbatlas/provider_test.go +++ b/mongodbatlas/provider_test.go @@ -2,7 +2,6 @@ package mongodbatlas import ( "os" - "strconv" "strings" "testing" From 94e2d6726b022f665ecf79fec21a6d16ebe753cd Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 21 Jun 2023 11:54:36 +0200 Subject: [PATCH 5/7] fixes --- ...ce_mongodbatlas_private_endpoint_regional_mode_test.go | 2 +- .../resource_mongodbatlas_network_container_test.go | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/mongodbatlas/data_source_mongodbatlas_private_endpoint_regional_mode_test.go b/mongodbatlas/data_source_mongodbatlas_private_endpoint_regional_mode_test.go index dc2629f35c..3fd51b7886 100644 --- a/mongodbatlas/data_source_mongodbatlas_private_endpoint_regional_mode_test.go +++ b/mongodbatlas/data_source_mongodbatlas_private_endpoint_regional_mode_test.go @@ -13,7 +13,7 @@ import ( func TestAccNetworkDSPrivateEndpointRegionalMode_basic(t *testing.T) { resourceName := "mongodbatlas_private_endpoint_regional_mode.test" - projectID := os.Getenv("MONGODB_ATLAS_NETWORK_PROJECT_ID") + projectID := os.Getenv("MONGODB_ATLAS_PROJECT_ID") resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, diff --git a/mongodbatlas/resource_mongodbatlas_network_container_test.go b/mongodbatlas/resource_mongodbatlas_network_container_test.go index ac40de75c8..cc35f7c6e4 100644 --- a/mongodbatlas/resource_mongodbatlas_network_container_test.go +++ b/mongodbatlas/resource_mongodbatlas_network_container_test.go @@ -19,7 +19,7 @@ func TestAccNetworkRSNetworkContainer_basicAWS(t *testing.T) { randInt = acctest.RandIntRange(0, 255) randIntUpdated = acctest.RandIntRange(0, 255) resourceName = "mongodbatlas_network_container.test" - dataSourceName = "data.mongodbatlas_network_container.test_ds" + dataSourceName = "data.mongodbatlas_network_container.test" dataSourceContainersName = "data.mongodbatlas_network_containers.test" cidrBlock = fmt.Sprintf("10.8.%d.0/24", randInt) cidrBlockUpdated = fmt.Sprintf("10.8.%d.0/24", randIntUpdated) @@ -294,9 +294,9 @@ func testAccMongoDBAtlasNetworkContainerConfigAWS(projectName, orgID, cidrBlock, region_name = "%s" } - data "mongodbatlas_network_container" "test_ds" { - project_id = mongodbatlas_network_container.test_ds.project_id - container_id = mongodbatlas_network_container.test_ds.id + data "mongodbatlas_network_container" "test" { + project_id = mongodbatlas_network_container.test.project_id + container_id = mongodbatlas_network_container.test.id } data "mongodbatlas_network_containers" "test" { From 699c257e9d4404bf54434d39abdbc41a8fb02f1b Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 21 Jun 2023 11:59:53 +0200 Subject: [PATCH 6/7] Update resource_mongodbatlas_private_endpoint_regional_mode_test.go --- ...las_private_endpoint_regional_mode_test.go | 21 +++++++------------ 1 file changed, 8 insertions(+), 13 deletions(-) diff --git a/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go b/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go index 24c75ad6bb..13be26768c 100644 --- a/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go +++ b/mongodbatlas/resource_mongodbatlas_private_endpoint_regional_mode_test.go @@ -73,17 +73,16 @@ func TestAccNetworkRSPrivateEndpointRegionalMode_basic(t *testing.T) { var ( resourceSuffix = "atlasrm" resourceName = fmt.Sprintf("mongodbatlas_private_endpoint_regional_mode.%s", resourceSuffix) - orgID = os.Getenv("MONGODB_ATLAS_ORG_ID") - projectName = acctest.RandomWithPrefix("test-acc") + projectID = os.Getenv("MONGODB_ATLAS_PROJECT_ID") ) - resource.ParallelTest(t, resource.TestCase{ + resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, ProviderFactories: testAccProviderFactories, CheckDestroy: testAccCheckMongoDBAtlasPrivateEndpointRegionalModeDestroy, Steps: []resource.TestStep{ { - Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, orgID, projectName, false), + Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, projectID, false), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateEndpointRegionalModeExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), @@ -92,7 +91,7 @@ func TestAccNetworkRSPrivateEndpointRegionalMode_basic(t *testing.T) { ), }, { - Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, orgID, projectName, true), + Config: testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceSuffix, projectID, true), Check: resource.ComposeTestCheckFunc( testAccCheckMongoDBAtlasPrivateEndpointRegionalModeExists(resourceName), resource.TestCheckResourceAttrSet(resourceName, "project_id"), @@ -135,17 +134,13 @@ func testAccMongoDBAtlasPrivateEndpointRegionalModeConfigNoProject(resourceName, `, resourceName, projectID, enabled) } -func testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceName, orgID, projectName string, enabled bool) string { +func testAccMongoDBAtlasPrivateEndpointRegionalModeConfig(resourceName, projectID string, enabled bool) string { return fmt.Sprintf(` - resource "mongodbatlas_project" "test" { - name = %[3]q - org_id = %[2]q - } resource "mongodbatlas_private_endpoint_regional_mode" %[1]q { - project_id = mongodbatlas_project.test.id - enabled = %[4]t + project_id = %[2]q + enabled = %[3]t } - `, resourceName, orgID, projectName, enabled) + `, resourceName, projectID, enabled) } func testAccCheckMongoDBAtlasPrivateEndpointRegionalModeExists(resourceName string) resource.TestCheckFunc { From f4f0f8aa66fa2a512a8c36b76c1a9494f61bfc9b Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 21 Jun 2023 12:18:19 +0200 Subject: [PATCH 7/7] Update automated-test-acceptances.yml --- .../workflows/automated-test-acceptances.yml | 30 ------------------- 1 file changed, 30 deletions(-) diff --git a/.github/workflows/automated-test-acceptances.yml b/.github/workflows/automated-test-acceptances.yml index 69a37108a2..d75dcc8ab2 100644 --- a/.github/workflows/automated-test-acceptances.yml +++ b/.github/workflows/automated-test-acceptances.yml @@ -84,36 +84,6 @@ jobs: ACCTEST_TIMEOUT: ${{ vars.ACCTEST_TIMEOUT }} TEST_REGEX: "^TestAccConfig" run: make testacc - - acceptance-tests-network: - if: ${{ github.event.label.name == 'run-testacc' || github.event.label.name == 'run-testacc-project-network' || github.ref == 'refs/heads/master' }} - needs: [ authorize ] - runs-on: ubuntu-latest - steps: - - name: Checkout - uses: actions/checkout@v3 - - name: Set up Go - uses: actions/setup-go@v4 - with: - go-version: "1.20" - - name: Acceptance Tests - env: - MONGODB_ATLAS_PUBLIC_KEY: ${{ secrets.MONGODB_ATLAS_PUBLIC_KEY }} - MONGODB_ATLAS_PRIVATE_KEY: ${{ secrets.MONGODB_ATLAS_PRIVATE_KEY }} - MONGODB_ATLAS_PROJECT_ID: ${{ secrets.MONGODB_ATLAS_PROJECT_ID }} - MONGODB_ATLAS_ORG_ID: ${{ secrets.MONGODB_ATLAS_ORG_ID }} - MONGODB_ATLAS_DB_USERNAME: ${{ secrets.MONGODB_ATLAS_DB_USERNAME }} - MONGODB_ATLAS_TEAMS_IDS: ${{ secrets.MONGODB_ATLAS_TEAMS_IDS }} - CA_CERT: ${{ secrets.CA_CERT }} - MONGODB_ATLAS_API_KEYS_IDS: ${{ secrets.MONGODB_ATLAS_API_KEYS_IDS }} - MONGODB_ATLAS_NETWORK_PROJECT_ID: ${{ secrets.MONGODB_ATLAS_NETWORK_PROJECT_ID }} - SKIP_TEST_EXTERNAL_CREDENTIALS: ${{ vars.SKIP_TEST_EXTERNAL_CREDENTIALS }} - SKIP_TEST: ${{ vars.SKIP_TEST }} - AWS_REGION: ${{ vars.AWS_REGION }} - MONGODB_ATLAS_ENABLE_BETA: ${{ vars.MONGODB_ATLAS_ENABLE_BETA }} - ACCTEST_TIMEOUT: ${{ vars.ACCTEST_TIMEOUT }} - TEST_REGEX: "^TestAccNetwork" - run: make testacc acceptance-tests-gov: if: ${{ github.event.label.name == 'run-testacc-gov' }}