def test_container_create_with_acr(self, resource_group, resource_group_location): container_group_name = self.create_random_name('clicontainer', 16) registry_username = '******' registry_server = '{}.azurecr.io'.format(registry_username) image = '{}/nginx:latest'.format(registry_server) password = '******' self.cmd( 'container create -g {} -n {} --image {} --registry-password {}'. format(resource_group, container_group_name, image, password), checks=[ JMESPathCheck('name', container_group_name), JMESPathCheck('location', resource_group_location), JMESPathCheck('provisioningState', 'Succeeded'), JMESPathCheck('osType', 'Linux'), JMESPathCheck('containers[0].image', image), JMESPathCheck('imageRegistryCredentials[0].server', registry_server), JMESPathCheck('imageRegistryCredentials[0].username', registry_username), JMESPathCheckExists('containers[0].resources.requests.cpu'), JMESPathCheckExists( 'containers[0].resources.requests.memoryInGb') ])
def test_container_azure_file_volume_mount(self, resource_group, resource_group_location): container_group_name = self.create_random_name('clicontainer', 16) azure_file_volume_share_name = 'testshare' azure_file_volume_account_name = 'ccondemostore1' azure_file_volume_account_key = 'mockstorageaccountkey' azure_file_volume_mount_path = '/mnt/azfile' create_cmd = 'container create -g {} -n {} --image nginx --azure-file-volume-share-name {} ' \ '--azure-file-volume-account-name {} --azure-file-volume-account-key {} ' \ '--azure-file-volume-mount-path {}'.format(resource_group, container_group_name, azure_file_volume_share_name, azure_file_volume_account_name, azure_file_volume_account_key, azure_file_volume_mount_path) self.cmd(create_cmd, checks=[ JMESPathCheck('name', container_group_name), JMESPathCheck('location', resource_group_location), JMESPathCheck('provisioningState', 'Succeeded'), JMESPathCheck('osType', 'Linux'), JMESPathCheckExists('volumes'), JMESPathCheckExists('volumes[0].azureFile'), JMESPathCheck('volumes[0].azureFile.shareName', azure_file_volume_share_name), JMESPathCheck('volumes[0].azureFile.storageAccountName', azure_file_volume_account_name), JMESPathCheckExists('containers[0].volumeMounts'), JMESPathCheck('containers[0].volumeMounts[0].mountPath', azure_file_volume_mount_path) ])
def sf_test_good_cluster_health(self): self.cmd("az sf cluster health", checks=[ JMESPathCheckExists("aggregatedHealthState"), JMESPathCheck("applicationHealthStates[0].name", "fabric:/System"), JMESPathCheckExists("nodeHealthStates") ])
def sf_test_good_system_service_health(self): self.cmd( "az sf service health --service-id " "System/ClusterManagerService", checks=[ JMESPathCheck("name", "fabric:/System/ClusterManagerService"), JMESPathCheckExists("partitionHealthStates"), JMESPathCheckExists("healthEvents") ])
def sf_test_good_system_partition_health(self): self.cmd( "az sf partition health --partition-id " "00000000-0000-0000-0000-000000000001", checks=[ JMESPathCheck("partitionId", "00000000-0000-0000-0000-000000000001"), JMESPathCheckExists("replicaHealthStates"), JMESPathCheckExists("healthEvents") ])
def node_list_returns_non_empty_ids_and_names_test(self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False self.cmd("az sf node list", checks=[ JMESPathCheckExists("items[0].id.id"), JMESPathCheckExists("items[0].name") ])
def cluster_health_returns_aggregated_states_test(self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False self.cmd("az sf cluster health", checks=[ JMESPathCheckExists("aggregatedHealthState"), JMESPathCheck("applicationHealthStates[0].name", "fabric:/System"), JMESPathCheckExists("nodeHealthStates") ])
def node_system_type_list_returns_non_empty_list_test( self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False command = "az sf node service-type-list --application-id System --node-name {0}" command = command.format(test_node_name) self.cmd(command, checks=[ JMESPathCheckExists("[0].codePackageName"), JMESPathCheckExists("[0].serviceTypeName") ])
def verify_blob_upload_and_download(self, group, account, file_size_kb, blob_type, skip_download=False): container = self.create_random_name(prefix='cont', length=24) local_dir = self.create_temp_dir() local_file = self.create_temp_file(file_size_kb, full_random=True) blob_name = self.create_random_name(prefix='blob', length=24) account_key = self.cmd('storage account keys list -n {} -g {} --query "[0].value" -otsv' .format(account, group)).output self.set_env('AZURE_STORAGE_ACCOUNT', account) self.set_env('AZURE_STORAGE_KEY', account_key) self.cmd('storage container create -n {}'.format(container)) self.cmd('storage blob exists -n {} -c {}'.format(blob_name, container), checks=JMESPathCheck('exists', False)) self.cmd('storage blob upload -c {} -f "{}" -n {} --type {}' .format(container, local_file, blob_name, blob_type)) self.cmd('storage blob exists -n {} -c {}'.format(blob_name, container), checks=JMESPathCheck('exists', True)) self.cmd('storage blob show -n {} -c {}'.format(blob_name, container), checks=[JMESPathCheck('properties.contentLength', file_size_kb * 1024), JMESPathCheckExists('properties.pageRanges') if blob_type == 'page' else JMESPathCheck('properties.pageRanges', None)]) if not skip_download: downloaded = os.path.join(local_dir, 'test.file') self.cmd('storage blob download -n {} -c {} --file "{}"' .format(blob_name, container, downloaded)) self.assertTrue(os.path.isfile(downloaded), 'The file is not downloaded.') self.assertEqual(file_size_kb * 1024, os.stat(downloaded).st_size, 'The download file size is not right.')
def test_storage_blob_sas_permission_scenario(self, resource_group, storage_account): """ Test service SAS with stored access policy. A stored access policy is defined on a resource container, which can be a blob container, table, queue, or file share. The stored access policy can be used to manage constraints for one or more service shared access signatures. When you associate a service SAS with a stored access policy, the SAS inherits the constraints—the start time, expiry time, and permissions—defined for the stored access policy. """ expiry = (datetime.utcnow() + timedelta(hours=1)).strftime('%Y-%m-%dT%H:%MZ') account_info = self.get_account_info(resource_group, storage_account) container = self.create_container(account_info) local_file = self.create_temp_file(128, full_random=False) blob_name = self.create_random_name('blob', 16) policy = self.create_random_name('policy', 16) self.storage_cmd( 'storage container policy create -c {} -n {} --expiry {} --permissions acdlrw', account_info, container, policy, expiry) self.storage_cmd('storage container policy list -c {} ', account_info, container)\ .assert_with_checks(JMESPathCheckExists('{}.expiry'.format(policy)), JMESPathCheck('{}.permission'.format(policy), 'racwdl')) self.storage_cmd('storage container policy show -c {} -n {} ', account_info, container, policy, expiry)\ .assert_with_checks(JMESPathCheckExists('expiry'), JMESPathCheck('permission', 'racwdl')) sas = self.storage_cmd( 'storage blob generate-sas -n {} -c {} --policy-name {} -otsv ', account_info, blob_name, container, policy).output.strip() self.storage_cmd( 'storage blob upload -n {} -c {} -f "{}" --sas-token "{}" ', account_info, blob_name, container, local_file, sas) self.storage_cmd( 'storage container policy update -c {} -n {} --permissions acdlr', account_info, container, policy) self.storage_cmd('storage container policy show -c {} -n {} ', account_info, container, policy)\ .assert_with_checks(JMESPathCheckExists('expiry'), JMESPathCheck('permission', 'racdl')) self.storage_cmd('storage container policy delete -c {} -n {} ', account_info, container, policy) self.storage_cmd('storage container policy list -c {} ', account_info, container) \ .assert_with_checks(NoneCheck())
def service_list_returns_system_services_test(self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False command = "az sf service list --application-id System" self.cmd(command, checks=[JMESPathCheckExists("items")])
def node_load_returns_non_empty_load_metrics(self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False self.cmd("az sf node load --node-name {0}".format(test_node_name), checks=[JMESPathCheckExists("nodeLoadMetricInformation")])
def sf_test_good_system_partition_info(self): self.cmd( "az sf partition info --partition-id " "00000000-0000-0000-0000-000000000001", checks=[ JMESPathCheckExists("ServiceKind"), JMESPathCheck("partitionInformation.id", "00000000-0000-0000-0000-000000000001") ])
def cluster_code_version_returns_not_empty_test(self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False self.cmd("az sf cluster code-version", checks=[JMESPathCheckExists("[0].codeVersion")])
def test_batchai_cluster_with_nfs_and_azure_file_share( self, resource_group, storage_account): """Tests creation of a cluster with file server and Azure file share. 1. Create a file server and verify parameters. 2. Create a cluster and verify parameters. 3. Verify that cluster was able to start nodes. """ self._configure_environment(resource_group, storage_account) # Create a file share 'share' to be mounted on the cluster self.cmd('az storage share create -n share') self.cmd('batchai file-server create -n nfs -g {0} -c {1}'.format( resource_group, _data_file('file_server.json')), checks=[ JMESPathCheck('name', 'nfs'), JMESPathCheck('mountSettings.mountPoint', '/mnt/data'), JMESPathCheck('dataDisks.diskCount', 2), JMESPathCheck('dataDisks.diskSizeInGb', 10) ]) self.cmd( 'batchai cluster create -n cluster -g {0} -c {1} --nfs nfs --afs-name share -u alex -k {2}' .format(resource_group, _data_file('simple_cluster.json'), _data_file('key.txt')), checks=[ JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].accountName', storage_account), JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].azureFileUrl', 'https://{0}.file.core.windows.net/share'.format( storage_account)), JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].relativeMountPath', 'afs'), JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].credentialsInfo.accountKey', None), JMESPathCheck('userAccountSettings.adminUserName', 'alex'), JMESPathCheck('userAccountSettings.adminUserPassword', None), JMESPathCheck( 'nodeSetup.mountVolumes.fileServers[0].relativeMountPath', 'nfs') ]) # Give file server and cluster to finish preparation. time.sleep(NODE_STARTUP_TIME * 2) # Check the node in the cluster successfully started - was able to mount nfs and azure filesystem. self.cmd( 'batchai cluster show -n cluster -g {0}'.format(resource_group), checks=[JMESPathCheck('nodeStateCounts.idleNodeCount', 1)]) # Check the file server reports information about public ip. self.cmd( 'batchai file-server show -n nfs -g {0}'.format(resource_group), checks=[JMESPathCheckExists('mountSettings.fileServerPublicIp')])
def test_sqlvm_add_and_remove(self, resource_group, resource_group_location, domainvm, sqlvm1, storage_account): add_account_script = '\"Set-AdUser -UserPrincipalName [email protected] -Identity admin123 -PasswordNeverExpires $true\"' # add account to domain controller self.cmd('vm run-command invoke -n {} -g {} --command-id RunPowerShellScript --scripts {}' .format('adVM', resource_group, add_account_script)) parameters_string = ('location={} domainJoinUserName=domain\\\\admin123 domainJoinUserPassword=SecretPassword123 ' 'domainFQDN=domain.com vmList={}').format(resource_group_location, sqlvm1) # join vms to the domain self.cmd('group deployment create --name {} -g {} --template-uri {} --parameters {}' .format('joinvms', resource_group, 'https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/201-vm-domain-join-existing/azuredeploy.json', parameters_string)) # Create the sqlvm group sa = self.cmd('storage account show -n {} -g {}' .format(storage_account, resource_group)).get_output_in_json() key = self.cmd('storage account keys list -n {} -g {}' .format(storage_account, resource_group)).get_output_in_json() sqlvmgroup = self.cmd('sql vm group create -n {} -g {} -l {} -i {} -s {} -f {} -p {} -k {} -e {} -u {} --bootstrap-acc {}' .format('cligroup', resource_group, resource_group_location, 'SQL2017-WS2016', 'Enterprise', 'domain.com', 'admin123', key[0]['value'], 'admin123', sa['primaryEndpoints']['blob'], 'admin123')).get_output_in_json() # test create sqlvm1 self.cmd('sql vm create -n {} -g {} -l {} --connectivity-type {} --port {} --sql-auth-update-pwd {} --sql-auth-update-username {}' .format(sqlvm1, resource_group, resource_group_location, 'PRIVATE', 1433, 'admin123', 'SecretPassword123'), checks=[ JMESPathCheck('name', sqlvm1), JMESPathCheck('location', resource_group_location) ]).get_output_in_json() self.cmd('sql vm add-to-group -n {} -g {} -r {} -p {} -s {} -b {}' .format(sqlvm1, resource_group, sqlvmgroup['id'], 'SecretPassword123', 'SecretPassword123', 'SecretPassword123'), checks=[ JMESPathCheck('name', sqlvm1), JMESPathCheck('location', resource_group_location), JMESPathCheck('provisioningState', "Succeeded"), JMESPathCheckExists('sqlVirtualMachineGroupResourceId') ]) # Remove from group self.cmd('sql vm remove-from-group -n {} -g {}' .format(sqlvm1, resource_group), checks=[ JMESPathCheck('name', sqlvm1), JMESPathCheck('location', resource_group_location), JMESPathCheck('provisioningState', "Succeeded") ])
def app_health_returns_aggregated_and_name_test(self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False self.cmd("az sf application health --application-id \"System\"", checks=[ JMESPathCheck("name", "fabric:/System"), JMESPathCheckExists("aggregatedHealthState") ])
def system_partition_health_returns_aggregated_state_test( self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False command = "az sf partition health --partition-id 00000000-0000-0000-0000-000000000001" self.cmd(command, checks=[ JMESPathCheckExists("aggregatedHealthState"), JMESPathCheck("partitionId", "00000000-0000-0000-0000-000000000001") ])
def service_health_returns_system_services_aggregated_state_test( self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False command = "az sf service health --service-id System/FailoverManagerService" self.cmd(command, checks=[ JMESPathCheckExists("aggregatedHealthState"), JMESPathCheck("name", "fabric:/System/FailoverManagerService") ])
def test_aks_create_with_upgrade(self, resource_group, resource_group_location): loc = resource_group_location # override loc to westus2 loc = 'westus2' ssh_pubkey_file = self.generate_ssh_keys() aks_name = self.create_random_name('cliakstest', 16) dns_prefix = self.create_random_name('cliaksdns', 16) original_k8s_version = '1.7.7' # create ssh_pubkey_file = ssh_pubkey_file.replace('\\', '\\\\') create_cmd = 'aks create -g {} -n {} --dns-name-prefix {} --ssh-key-value {} --kubernetes-version {} -l {}' self.cmd(create_cmd.format(resource_group, aks_name, dns_prefix, ssh_pubkey_file, original_k8s_version, loc), checks=[ JMESPathCheckExists('properties.fqdn'), JMESPathCheck('properties.provisioningState', 'Succeeded') ]) # show self.cmd('aks show -g {} -n {}'.format(resource_group, aks_name), checks=[ JMESPathCheck( 'type', 'Microsoft.ContainerService/ManagedClusters'), JMESPathCheck('name', aks_name), JMESPathCheck('resourceGroup', resource_group), JMESPathCheck('properties.agentPoolProfiles[0].count', 3), JMESPathCheck('properties.agentPoolProfiles[0].vmSize', 'Standard_D2_v2'), JMESPathCheck('properties.dnsPrefix', dns_prefix), JMESPathCheck('properties.provisioningState', 'Succeeded'), JMESPathCheck('properties.kubernetesVersion', '1.7.7') ]) # upgrade new_k8s_version = '1.8.1' upgrade_cmd = 'aks upgrade -g {} -n {} --kubernetes-version {} --yes' self.cmd(upgrade_cmd.format(resource_group, aks_name, new_k8s_version), checks=[ JMESPathCheck('properties.provisioningState', 'Succeeded') ]) # show again self.cmd( 'aks show -g {} -n {}'.format(resource_group, aks_name), checks=[JMESPathCheck('properties.kubernetesVersion', '1.8.1')])
def replica_health_system_service_returns_aggregated_state_test( self, mock_config_parser): instance = mock_config_parser.return_value instance.no_verify_setting.return_value = False instance.ca_cert_info.return_value = False instance.connection_endpoint.return_value = test_endpoint instance.cert_info.return_value = False command = "az sf replica health --replica-id {0} --partition-id {1}" command = command.format(test_replica_id, test_partition_id) self.cmd(command, checks=[ JMESPathCheck("partitionId", test_partition_id), JMESPathCheck("replicaId", test_replica_id), JMESPathCheckExists("aggregatedHealthState") ])
def test_batchai_configless_cluster_and_nfs_creation( self, resource_group, storage_account): # Test creation of a cluster and nfs without configuration files. self._configure_environment(resource_group, storage_account) self.cmd('az storage share create -n share') self.cmd( 'az batchai file-server create -n nfs -g {0} -l eastus --vm-size STANDARD_D1 --storage-sku ' 'Standard_LRS --disk-count 2 --disk-size 10 -u alex -p Password_123' .format(resource_group)) self.cmd( 'az batchai cluster create -n cluster -g {0} -l eastus --afs-name share --nfs nfs ' '-i UbuntuLTS --vm-size STANDARD_D1 --min 1 --max 1 -u alex -p Password_123' .format(resource_group), checks=[ JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].accountName', storage_account), JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].azureFileUrl', 'https://{0}.file.core.windows.net/share'.format( storage_account)), JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].relativeMountPath', 'afs'), JMESPathCheck( 'nodeSetup.mountVolumes.azureFileShares[0].credentialsInfo.accountKey', None), JMESPathCheck('userAccountSettings.adminUserName', 'alex'), JMESPathCheck('userAccountSettings.adminUserPassword', None), JMESPathCheck( 'nodeSetup.mountVolumes.fileServers[0].relativeMountPath', 'nfs') ]) # Give file server and cluster to finish preparation. time.sleep(NODE_STARTUP_TIME * 2) # Check the node in the cluster successfully started - was able to mount nfs and azure filesystem. self.cmd( 'batchai cluster show -n cluster -g {0}'.format(resource_group), checks=[JMESPathCheck('nodeStateCounts.idleNodeCount', 1)]) # Check the file server reports information about public ip. self.cmd( 'batchai file-server show -n nfs -g {0}'.format(resource_group), checks=[JMESPathCheckExists('mountSettings.fileServerPublicIp')])
def test_storage_share_rm_with_access_tier(self): self.kwargs.update({ 'share': self.create_random_name('share', 24), 'new_share': self.create_random_name('share', 24) }) # Update with access tier self.cmd( 'storage share-rm create --storage-account {sa} -g {rg} -n {share}', checks={ JMESPathCheck('name', self.kwargs['share']), JMESPathCheck('accessTier', None) }) self.cmd( 'storage share-rm show --storage-account {sa} -g {rg} -n {share}', checks={ JMESPathCheck('name', self.kwargs['share']), JMESPathCheck('accessTier', 'TransactionOptimized') }) self.cmd( 'storage share-rm update --storage-account {sa} -g {rg} -n {share} --access-tier Hot', checks={ JMESPathCheck('name', self.kwargs['share']), JMESPathCheck('accessTier', 'Hot') }) self.cmd( 'storage share-rm show --storage-account {sa} -g {rg} -n {share}', checks={ JMESPathCheck('name', self.kwargs['share']), JMESPathCheck('accessTier', 'Hot'), JMESPathCheckExists('accessTierChangeTime') }) # Create with access tier self.cmd( 'storage share-rm create --storage-account {sa} -g {rg} -n {new_share} --access-tier Hot', checks={ JMESPathCheck('[0].name', self.kwargs['share']), JMESPathCheck('accessTier', 'Hot') })
def test_aks_create_default_service(self, resource_group, resource_group_location): # the simplest aks create scenario loc = resource_group_location # override loc to westus2 loc = 'westus2' ssh_pubkey_file = self.generate_ssh_keys() aks_name = self.create_random_name('cliakstest', 16) dns_prefix = self.create_random_name('cliaksdns', 16) # create ssh_pubkey_file = ssh_pubkey_file.replace('\\', '\\\\') create_cmd = 'aks create -g {} -n {} --dns-name-prefix {} --ssh-key-value {} -l {}' self.cmd(create_cmd.format(resource_group, aks_name, dns_prefix, ssh_pubkey_file, loc), checks=[ JMESPathCheckExists('properties.fqdn'), JMESPathCheck('properties.provisioningState', 'Succeeded') ]) # show self.cmd('aks show -g {} -n {}'.format(resource_group, aks_name), checks=[ JMESPathCheck( 'type', 'Microsoft.ContainerService/ManagedClusters'), JMESPathCheck('name', aks_name), JMESPathCheck('resourceGroup', resource_group), JMESPathCheck('properties.agentPoolProfiles[0].count', 3), JMESPathCheck('properties.agentPoolProfiles[0].vmSize', 'Standard_D2_v2'), JMESPathCheck('properties.dnsPrefix', dns_prefix) ]) # scale-up self.cmd( 'aks scale -g {} -n {} --agent-count 5'.format( resource_group, aks_name), checks=[JMESPathCheck('properties.agentPoolProfiles[0].count', 5)]) # show again self.cmd( 'aks show -g {} -n {}'.format(resource_group, aks_name), checks=[JMESPathCheck('properties.agentPoolProfiles[0].count', 5)])
def sf_test_application_lifecycle(self): self.cmd("az sf application upload --path {}".format( self.package_path)) self.cmd("az sf application provision " "--application-type-build-path {}".format(self.package_name)) self.cmd("az sf application type", checks=[ JMESPathCheck("items[0].name", self.application_type_name), JMESPathCheck("items[0].version", self.application_type_version) ]) self.cmd("az sf application create " "--app-type {} --version {} --name {}".format( self.application_type_name, self.application_type_version, self.application_name)) self.cmd("az sf application list", checks=[JMESPathCheck("items[0].id", self.application_id)]) self.cmd("az sf application health " "--application-id {}".format(self.application_id), checks=[ JMESPathCheck("name", self.application_name), JMESPathCheckExists("aggregatedHealthState") ]) self.cmd("az sf application delete --application-id {}".format( self.application_id)) self.cmd("az sf application unprovision " "--application-type-name {} " "--application-type-version {}".format( self.application_type_name, self.application_type_version))
def test_backup_vault(self, resource_group, resource_group_location, vault1, vault2): self.kwargs.update({ 'loc': resource_group_location, 'vault1': vault1, 'vault2': vault2 }) self.kwargs['vault3'] = self.create_random_name('clitest-vault', 50) self.cmd('backup vault create -n {vault3} -g {rg} -l {loc}', checks=[ self.check('name', '{vault3}'), self.check('resourceGroup', '{rg}'), self.check('location', '{loc}'), self.check('properties.provisioningState', 'Succeeded') ]) self.kwargs['vault4'] = self.create_random_name('clitest-vault', 50) self.cmd('backup vault create -n {vault4} -g {rg} -l {loc}', checks=[ self.check('name', '{vault4}'), self.check('resourceGroup', '{rg}'), self.check('location', '{loc}'), self.check('properties.provisioningState', 'Succeeded') ]) number_of_test_vaults = 4 self.cmd('backup vault list', checks=[ self.check("length([?resourceGroup == '{rg}'])", number_of_test_vaults), self.check("length([?name == '{vault1}'])", 1), self.check("length([?name == '{vault2}'])", 1), self.check("length([?name == '{vault3}'])", 1), self.check("length([?name == '{vault4}'])", 1) ]) self.cmd('backup vault list -g {rg}', checks=[ self.check("length(@)", number_of_test_vaults), self.check("length([?name == '{vault1}'])", 1), self.check("length([?name == '{vault2}'])", 1), self.check("length([?name == '{vault3}'])", 1), self.check("length([?name == '{vault4}'])", 1) ]) storage_model_types = [e.value for e in StorageType] vault_properties = self.cmd( 'backup vault backup-properties show -n {vault1} -g {rg} --query [0]', checks=[ JMESPathCheckExists( "contains({}, properties.storageModelType)".format( storage_model_types)), self.check('properties.storageTypeState', 'Unlocked'), self.check('resourceGroup', '{rg}') ]).get_output_in_json() if vault_properties['properties'][ 'storageModelType'] == StorageType.geo_redundant.value: new_storage_model = StorageType.locally_redundant.value else: new_storage_model = StorageType.geo_redundant.value self.kwargs['model'] = new_storage_model self.cmd( 'backup vault backup-properties set -n {vault1} -g {rg} --backup-storage-redundancy {model}' ) time.sleep(300) self.cmd( 'backup vault backup-properties show -n {vault1} -g {rg} --query [0]', checks=[ self.check('properties.storageModelType', new_storage_model) ]) self.cmd('backup vault delete -n {vault4} -g {rg} -y') self.cmd('backup vault list', checks=[ self.check("length([?resourceGroup == '{rg}'])", number_of_test_vaults - 1), self.check("length([?name == '{vault1}'])", 1), self.check("length([?name == '{vault2}'])", 1), self.check("length([?name == '{vault3}'])", 1) ])
def test_storage_blob_url_scenarios(self, resource_group, storage_account): account_info = self.get_account_info(resource_group, storage_account) container = self.create_container(account_info, prefix="con1") local_file1 = self.create_temp_file(128) local_file2 = self.create_temp_file(64) blob_name1 = "/".join( ["dir", self.create_random_name(prefix='blob', length=24)]) # set delete-policy to enable soft-delete self.storage_cmd( 'storage blob service-properties delete-policy update --enable true --days-retained 2', account_info) self.storage_cmd('storage blob service-properties delete-policy show', account_info).assert_with_checks( JMESPathCheck('enabled', True), JMESPathCheck('days', 2)) # Prepare blob self.storage_cmd('storage blob upload -c {} -f "{}" -n {} ', account_info, container, local_file1, blob_name1) expiry = (datetime.utcnow() + timedelta(hours=1)).strftime('%Y-%m-%dT%H:%MZ') blob_uri = self.storage_cmd( 'storage blob generate-sas -n {} -c {} --expiry {} --permissions ' 'rwad --https-only --full-uri -o tsv', account_info, blob_name1, container, expiry).output.strip() self.cmd('storage blob exists --blob-url {}'.format(blob_uri), checks=JMESPathCheck('exists', True)) self.cmd('storage blob show --blob-url {}'.format(blob_uri), checks=[ JMESPathCheck('name', blob_name1), JMESPathCheck('properties.contentLength', 128 * 1024), JMESPathCheck('properties.blobTier', 'Hot') ]) self.cmd( 'storage blob upload -f "{}" --blob-url {} --overwrite'.format( local_file2, blob_uri)) self.cmd('storage blob show --blob-url {}'.format(blob_uri), checks=[ JMESPathCheck('name', blob_name1), JMESPathCheck('properties.contentLength', 64 * 1024) ]) local_dir = self.create_temp_dir() downloaded = os.path.join(local_dir, 'test.file') self.cmd('storage blob download --blob-url {} -f "{}"'.format( blob_uri, downloaded)) self.assertTrue(os.path.isfile(downloaded), 'The file is not downloaded.') self.assertEqual(64 * 1024, os.stat(downloaded).st_size, 'The download file size is not right.') self.cmd( 'storage blob set-tier --blob-url {} --tier Cool'.format(blob_uri)) self.cmd('storage blob show --blob-url {}'.format(blob_uri), checks=[ JMESPathCheck('name', blob_name1), JMESPathCheck('properties.contentLength', 64 * 1024), JMESPathCheck('properties.blobTier', "Cool") ]) self.cmd('storage blob snapshot --blob-url {}'.format(blob_uri), checks=JMESPathCheckExists('snapshot')) self.storage_cmd('storage blob list -c {}', account_info, container)\ .assert_with_checks(JMESPathCheck('length(@)', 1)) self.cmd( 'storage blob delete --blob-url {} --delete-snapshots include '. format(blob_uri)) self.storage_cmd('storage blob list -c {}', account_info, container).assert_with_checks( JMESPathCheck('length(@)', 0)) self.cmd('storage blob undelete --blob-url {} '.format(blob_uri)) self.storage_cmd('storage blob list -c {}', account_info, container).assert_with_checks( JMESPathCheck('length(@)', 1))
def sf_test_good_system_app_health(self): self.cmd("az sf application health --application-id \"System\"", checks=[ JMESPathCheck("name", "fabric:/System"), JMESPathCheckExists("aggregatedHealthState") ])
def sf_test_good_cluster_config_version(self): self.cmd("az sf cluster config-version", checks=[JMESPathCheckExists("[0].configVersion")])
def sf_test_good_cluster_manifest(self): self.cmd("az sf cluster manifest", checks=[JMESPathCheckExists("manifest")])