Merge pull request #3494 from Azure/ARO-22966-democluster-use-RPAPI

Convert cluster/nodepool operations to use RP API

Author: openshift-merge-bot[bot]

nonlocal-e2e-specs.txt

@@ -13,9 +13,6 @@
   "should allow API access only from authorized VM IP",
   "should be able to create a cluster with an external auth config and get the external auth config",
   "should be able to create an HCP cluster and custom node pool osDisk size using bicep template",
-  "should be able to lifecycle and confirm external auth on a cluster",
-  "should be able to list HCP clusters without node pools at both subscription and resource group levels",
   "should confirm the HCP cluster is deleted (not found)",
-  "should create an HCP cluster and validate TLS certificates",
-  "should not be able to create a 4.18 HCP cluster"
+  "should create an HCP cluster and validate TLS certificates"
 ]

test/e2e-setup/bicep/modules/customer-infra.bicep

@@ -1,5 +1,5 @@
 @description('If set to true, the cluster will not be deleted automatically after few days.')
-param persistTagValue bool
+param persistTagValue bool = false
 
 @description('Network Security Group Name')
 param customerNsgName string = 'customer-nsg'

test/e2e/cluster_create_missing_info.go

@@ -38,12 +38,10 @@ var _ = Describe("Customer", func() {
 			labels.RequireNothing,
 			labels.Critical,
 			labels.Negative,
+			labels.AroRpApiCompatible,
 			func(ctx context.Context) {
 				const (
-					customerNetworkSecurityGroupName = "customer-nsg-name"
-					customerVnetName                 = "customer-vnet-name"
-					customerVnetSubnetName           = "customer-vnet-subnet1"
-					customerClusterName              = "illegal-hcp-cluster"
+					customerClusterName = "illegal-hcp-cluster"
 				)
 				tc := framework.NewTestContext()
 
@@ -56,64 +54,28 @@ var _ = Describe("Customer", func() {
 				resourceGroup, err := tc.NewResourceGroup(ctx, "illegal-ocp-version", tc.Location())
 				Expect(err).NotTo(HaveOccurred())
 
-				By("creating a customer-infra")
-				customerInfraDeploymentResult, err := tc.CreateBicepTemplateAndWait(ctx,
-					framework.WithTemplateFromFS(TestArtifactsFS, "test-artifacts/generated-test-artifacts/modules/customer-infra.json"),
-					framework.WithDeploymentName("customer-infra"),
-					framework.WithScope(framework.BicepDeploymentScopeResourceGroup),
-					framework.WithClusterResourceGroup(*resourceGroup.Name),
-					framework.WithParameters(map[string]interface{}{
-						"persistTagValue":        false,
-						"customerNsgName":        customerNetworkSecurityGroupName,
-						"customerVnetName":       customerVnetName,
-						"customerVnetSubnetName": customerVnetSubnetName,
-					}),
-					framework.WithTimeout(45*time.Minute),
-				)
-				Expect(err).NotTo(HaveOccurred())
+				By("creating cluster parameters with invalid version")
+				clusterParams := framework.NewDefaultClusterParams()
+				clusterParams.ClusterName = customerClusterName
+				clusterParams.OpenshiftVersionId = version
+				managedResourceGroupName := framework.SuffixName(*resourceGroup.Name, "managed", 64)
+				clusterParams.ManagedResourceGroupName = managedResourceGroupName
 
-				By("creating/reusing managed identities")
-				keyVaultName, err := framework.GetOutputValue(customerInfraDeploymentResult, "keyVaultName")
-				Expect(err).NotTo(HaveOccurred())
-				managedIdentityDeploymentResult, err := tc.DeployManagedIdentities(ctx,
-					customerClusterName,
-					framework.WithTemplateFromFS(TestArtifactsFS, "test-artifacts/generated-test-artifacts/modules/managed-identities.json"),
-					framework.WithClusterResourceGroup(*resourceGroup.Name),
-					framework.WithParameters(map[string]interface{}{
-						"nsgName":      customerNetworkSecurityGroupName,
-						"vnetName":     customerVnetName,
-						"subnetName":   customerVnetSubnetName,
-						"keyVaultName": keyVaultName,
-					}),
+				By("creating customer resources")
+				clusterParams, err = tc.CreateClusterCustomerResources(ctx,
+					resourceGroup,
+					clusterParams,
+					map[string]interface{}{},
+					TestArtifactsFS,
 				)
 				Expect(err).NotTo(HaveOccurred())
 
-				By("creating the hcp cluster")
-				userAssignedIdentities, err := framework.GetOutputValue(managedIdentityDeploymentResult, "userAssignedIdentitiesValue")
-				Expect(err).NotTo(HaveOccurred())
-				identity, err := framework.GetOutputValue(managedIdentityDeploymentResult, "identityValue")
-				Expect(err).NotTo(HaveOccurred())
-				etcdEncryptionKeyName, err := framework.GetOutputValue(customerInfraDeploymentResult, "etcdEncryptionKeyName")
-				Expect(err).NotTo(HaveOccurred())
-				managedResourceGroupName := framework.SuffixName(*resourceGroup.Name, "managed", 64)
-				_, err = tc.CreateBicepTemplateAndWait(ctx,
-					framework.WithTemplateFromFS(TestArtifactsFS, "test-artifacts/generated-test-artifacts/modules/cluster.json"),
-					framework.WithDeploymentName("cluster"),
-					framework.WithScope(framework.BicepDeploymentScopeResourceGroup),
-					framework.WithClusterResourceGroup(*resourceGroup.Name),
-					framework.WithParameters(map[string]interface{}{
-						"openshiftVersionId":          version,
-						"clusterName":                 customerClusterName,
-						"managedResourceGroupName":    managedResourceGroupName,
-						"nsgName":                     customerNetworkSecurityGroupName,
-						"subnetName":                  customerVnetSubnetName,
-						"vnetName":                    customerVnetName,
-						"userAssignedIdentitiesValue": userAssignedIdentities,
-						"identityValue":               identity,
-						"keyVaultName":                keyVaultName,
-						"etcdEncryptionKeyName":       etcdEncryptionKeyName,
-					}),
-					framework.WithTimeout(45*time.Minute),
+				By("attempting to create the hcp cluster with invalid version")
+				err = tc.CreateHCPClusterFromParam(ctx,
+					GinkgoLogr,
+					*resourceGroup.Name,
+					clusterParams,
+					45*time.Minute,
 				)
 				Expect(err).To(HaveOccurred())
 				Expect(err).To(MatchError(MatchRegexp("Version .* (doesn't exist|is disabled)")))

test/e2e/cluster_list_no_infra.go

@@ -36,20 +36,20 @@ var _ = Describe("Customer", func() {
 		labels.RequireNothing,
 		labels.Positive,
 		labels.Medium,
+		labels.AroRpApiCompatible,
 		func(ctx context.Context) {
-			const createClustersCount = 2
-
 			tc := framework.NewTestContext()
 			openshiftControlPlaneVersionId := framework.DefaultOpenshiftControlPlaneVersionId()
 
+			var resourceGroups []*armresources.ResourceGroup
+			var clusterNames []string
+			const createClustersCount = 2
+
 			if tc.UsePooledIdentities() {
 				err := tc.AssignIdentityContainers(ctx, createClustersCount, 60*time.Second)
 				Expect(err).NotTo(HaveOccurred())
 			}
 
-			var resourceGroups []*armresources.ResourceGroup
-			var clusterNames []string
-
 			for range createClustersCount {
 				By("creating resource group for cluster listing test")
 				resourceGroup, err := tc.NewResourceGroup(ctx, "cluster-listing", tc.Location())
@@ -59,24 +59,28 @@ var _ = Describe("Customer", func() {
 				clusterName := "list-test-cluster-" + rand.String(6)
 				clusterNames = append(clusterNames, clusterName)
 
-				By("creating cluster without node pool using cluster-only template: " + clusterName)
-
-				identities, usePooledForCluster, err := tc.ResolveIdentitiesForTemplate(*resourceGroup.Name)
+				By("creating cluster without node pool: " + clusterName)
+				clusterParams := framework.NewDefaultClusterParams()
+				clusterParams.ClusterName = clusterName
+				clusterParams.OpenshiftVersionId = openshiftControlPlaneVersionId
+				managedResourceGroupName := framework.SuffixName(*resourceGroup.Name, "managed", 64)
+				clusterParams.ManagedResourceGroupName = managedResourceGroupName
+
+				By("creating customer resources for cluster: " + clusterName)
+				clusterParams, err = tc.CreateClusterCustomerResources(ctx,
+					resourceGroup,
+					clusterParams,
+					map[string]interface{}{},
+					TestArtifactsFS,
+				)
 				Expect(err).NotTo(HaveOccurred())
 
-				_, err = tc.CreateBicepTemplateAndWait(ctx,
-					framework.WithTemplateFromFS(TestArtifactsFS, "test-artifacts/generated-test-artifacts/cluster-only.json"),
-					framework.WithDeploymentName("cluster-only"),
-					framework.WithScope(framework.BicepDeploymentScopeResourceGroup),
-					framework.WithClusterResourceGroup(*resourceGroup.Name),
-					framework.WithParameters(map[string]any{
-						"openshiftControlPlaneVersionId": openshiftControlPlaneVersionId,
-						"clusterName":                    clusterName,
-						"persistTagValue":                false,
-						"identities":                     identities,
-						"usePooledIdentities":            usePooledForCluster,
-					}),
-					framework.WithTimeout(45*time.Minute),
+				By("creating HCP cluster: " + clusterName)
+				err = tc.CreateHCPClusterFromParam(ctx,
+					GinkgoLogr,
+					*resourceGroup.Name,
+					clusterParams,
+					45*time.Minute,
 				)
 				Expect(err).NotTo(HaveOccurred())
 			}

test/e2e/external_auth_list_and_verify.go

@@ -17,7 +17,6 @@ package e2e
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"time"
 
@@ -27,7 +26,6 @@ import (
 	"k8s.io/apimachinery/pkg/util/rand"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
-	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources"
 
 	hcpsdk "github.com/Azure/ARO-HCP/test/sdk/resourcemanager/redhatopenshifthcp/armredhatopenshifthcp"
 	"github.com/Azure/ARO-HCP/test/util/framework"
@@ -43,7 +41,10 @@ var _ = Describe("Customer", func() {
 	dummyUID := "00000000-0000-0000-0000-000000000000"
 
 	It("should be able to lifecycle and confirm external auth on a cluster",
-		labels.RequireNothing, labels.High, labels.Positive,
+		labels.RequireNothing,
+		labels.High,
+		labels.Positive,
+		labels.AroRpApiCompatible,
 		func(ctx context.Context) {
 			clusterName := testingPrefix + rand.String(6)
 			tc := framework.NewTestContext()
@@ -57,53 +58,30 @@ var _ = Describe("Customer", func() {
 			resourceGroup, err := tc.NewResourceGroup(ctx, testingPrefix, tc.Location())
 			Expect(err).NotTo(HaveOccurred())
 
-			By("starting cluster-only template deployment")
-			deploymentsClient := tc.GetARMResourcesClientFactoryOrDie(ctx).NewDeploymentsClient()
-
-			// Prepare the template and parameters
-			templateBytes := framework.Must(TestArtifactsFS.ReadFile("test-artifacts/generated-test-artifacts/cluster-only.json"))
-			bicepTemplateMap := map[string]interface{}{}
-			err = json.Unmarshal(templateBytes, &bicepTemplateMap)
-			Expect(err).NotTo(HaveOccurred())
-
-			identities, usePooled, err := tc.ResolveIdentitiesForTemplate(*resourceGroup.Name)
+			By("creating cluster parameters")
+			clusterParams := framework.NewDefaultClusterParams()
+			clusterParams.ClusterName = clusterName
+			managedResourceGroupName := framework.SuffixName(*resourceGroup.Name, "managed", 64)
+			clusterParams.ManagedResourceGroupName = managedResourceGroupName
+
+			By("creating customer resources")
+			clusterParams, err = tc.CreateClusterCustomerResources(ctx,
+				resourceGroup,
+				clusterParams,
+				map[string]interface{}{},
+				TestArtifactsFS,
+			)
 			Expect(err).NotTo(HaveOccurred())
 
-			bicepParameters := map[string]interface{}{
-				"clusterName": map[string]interface{}{
-					"value": clusterName,
-				},
-				"identities": map[string]interface{}{
-					"value": identities,
-				},
-				"usePooledIdentities": map[string]interface{}{
-					"value": usePooled,
-				},
-			}
-
-			// Create ARO HCP cluster
-			timeout := 45 * time.Minute
-			deploymentCtx, deploymentCancel := context.WithTimeoutCause(ctx, timeout, fmt.Errorf("timeout '%f' minutes exceeded during external auth list and verify test", timeout.Minutes()))
-			defer deploymentCancel()
-
-			deploymentResp, err := deploymentsClient.BeginCreateOrUpdate(
-				deploymentCtx,
+			By("creating HCP cluster")
+			err = tc.CreateHCPClusterFromParam(ctx,
+				GinkgoLogr,
 				*resourceGroup.Name,
-				clusterName,
-				armresources.Deployment{
-					Properties: &armresources.DeploymentProperties{
-						Template:   bicepTemplateMap,
-						Parameters: bicepParameters,
-						Mode:       to.Ptr(armresources.DeploymentModeIncremental),
-					},
-				},
-				nil,
+				clusterParams,
+				45*time.Minute,
 			)
 			Expect(err).NotTo(HaveOccurred())
 
-			_, err = deploymentResp.PollUntilDone(deploymentCtx, nil)
-			Expect(err).NotTo(HaveOccurred())
-
 			expectedExternalAuth := hcpsdk.ExternalAuth{
 				Name: to.Ptr(testingPrefix),
 				Properties: &hcpsdk.ExternalAuthProperties{

test/testdata/zz_fixture_TestMainListSuitesForEachSuite_dev_cd_check_paralleldev_cd_check_parallel.txt

@@ -3,9 +3,11 @@ Customer should be able to test admin credentials before cluster ready, then ful
 Customer should be able to create node pools with ARM64-based VMs
 Customer should be able to create an HCP cluster with custom autoscaling
 Customer should be able to create a HCP cluster without CNI
+Customer should be able to list HCP clusters without node pools at both subscription and resource group levels
 Update HCPOpenShiftCluster Positive creates a cluster and updates tags with a PATCH request
 Customer should be able to create several HCP clusters in their customer resource group, but not in the same managed resource group
 Customer should be able to create an HCP cluster using bicep templates
+Customer should be able to lifecycle and confirm external auth on a cluster
 Customer should be able to create an HCP cluster with Image Registry not present
 Engineering should be able to retrieve kusto logs for a cluster and services
 Customer should be able to create a cluster with default autoscaling and a nodepool with autoscaling enabled

test/testdata/zz_fixture_TestMainListSuitesForEachSuite_rp_api_compat_all_parallel_01rp_api_compat_all_parallel_development.txt

@@ -3,12 +3,15 @@ Customer should be able to test admin credentials before cluster ready, then ful
 Customer should be able to create node pools with ARM64-based VMs
 Customer should be able to create an HCP cluster with custom autoscaling
 Customer should reject cluster creation with unreasonably high MaxNodesTotal
+Customer should not be able to create a 4.18 HCP cluster
 Customer should be able to create a HCP cluster without CNI
+Customer should be able to list HCP clusters without node pools at both subscription and resource group levels
 Customer should not be able to deploy 2 identically named clusters within the same resource group
 Customer should not be able to deploy cluster with invalid name
 Update HCPOpenShiftCluster Positive creates a cluster and updates tags with a PATCH request
 Customer should be able to create several HCP clusters in their customer resource group, but not in the same managed resource group
 Customer should be able to create an HCP cluster using bicep templates
+Customer should be able to lifecycle and confirm external auth on a cluster
 Customer should be able to create an HCP cluster with Image Registry not present
 Engineering should be able to retrieve kusto logs for a cluster and services
 Customer should be able to create a cluster with default autoscaling and a nodepool with autoscaling enabled

test/testdata/zz_fixture_TestMainListSuitesForEachSuite_rp_api_compat_all_parallelrp_api_compat_all_parallel.txt

@@ -3,12 +3,15 @@ Customer should be able to test admin credentials before cluster ready, then ful
 Customer should be able to create node pools with ARM64-based VMs
 Customer should be able to create an HCP cluster with custom autoscaling
 Customer should reject cluster creation with unreasonably high MaxNodesTotal
+Customer should not be able to create a 4.18 HCP cluster
 Customer should be able to create a HCP cluster without CNI
+Customer should be able to list HCP clusters without node pools at both subscription and resource group levels
 Customer should not be able to deploy 2 identically named clusters within the same resource group
 Customer should not be able to deploy cluster with invalid name
 Update HCPOpenShiftCluster Positive creates a cluster and updates tags with a PATCH request
 Customer should be able to create several HCP clusters in their customer resource group, but not in the same managed resource group
 Customer should be able to create an HCP cluster using bicep templates
+Customer should be able to lifecycle and confirm external auth on a cluster
 Customer should be able to create an HCP cluster with Image Registry not present
 Customer should be able to create a cluster with default autoscaling and a nodepool with autoscaling enabled
 Customer should reject nodepool creation with both replicas and autoscaling configured