def test_parser_error_spellchecker(self):
cli = DummyCli()
main_loader = MainCommandsLoader(cli)
cli.loader = main_loader
cli.loader.load_command_table(None)
parser = cli.parser_cls(cli)
parser.load_command_table(cli.loader)
logger_msgs = []
choice_lists = []
original_get_close_matches = difflib.get_close_matches
def mock_log_error(_, msg):
logger_msgs.append(msg)
def mock_get_close_matches(*args, **kwargs):
choice_lists.append(original_get_close_matches(*args, **kwargs))
# run multiple faulty commands and save error logs, as well as close matches
with mock.patch('logging.Logger.error', mock_log_error), \
mock.patch('difflib.get_close_matches', mock_get_close_matches):
faulty_cmd_args = [
'test module1 --opt enum_1', 'test extension1 --opt enum_1',
'test foo_bar --opt enum_3', 'test module --opt enum_3',
'test extension --opt enum_3'
]
for text in faulty_cmd_args:
with self.assertRaises(SystemExit):
parser.parse_args(text.split())
parser.parse_args('test module --opt enum_1'.split())
# assert the right type of error msg is logged for command vs argument parsing
self.assertEqual(len(logger_msgs), 5)
for msg in logger_msgs[:3]:
self.assertIn("not in the", msg)
self.assertIn("command group", msg)
for msg in logger_msgs[3:]:
self.assertIn("not a valid value for '--opt'.", msg)
# assert the right choices are matched as "close".
# If these don't hold, matching algorithm should be deemed flawed.
for choices in choice_lists[:2]:
self.assertEqual(len(choices), 1)
self.assertEqual(len(choice_lists[2]), 0)
for choices in choice_lists[3:]:
self.assertEqual(len(choices), 2)
for choice in ['enum_1', 'enum_2']:
self.assertIn(choice, choices)
def test_repository_show_manifests(self, mock_requests_get, mock_get_access_credentials, mock_get_registry_by_name):
cmd = mock.MagicMock()
cmd.cli_ctx = DummyCli()
encoded_manifests = json.dumps({'manifests': [
{
'digest': 'sha256:b972dda797ef258a7ea5738eb2109778c2bac6a99d1033e6c9f9bdb4fbd196e7',
'tags': ['testtag1', 'testtag2']
},
{
'digest': 'sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7',
'tags': ['testtag3']
}]}).encode()
response = mock.MagicMock()
response.headers = {}
response.status_code = 200
response.content = encoded_manifests
mock_requests_get.return_value = response
# Show manifests using Basic auth without detail
mock_get_registry_by_name.return_value = Registry(location='westus', sku=Sku(name='Standard')), 'testrg'
mock_get_access_credentials.return_value = 'testregistry.azurecr.io', 'username', 'password'
acr_repository_show_manifests(cmd, 'testregistry', 'testrepository')
mock_requests_get.assert_called_with(
method='get',
url='https://testregistry.azurecr.io/v2/_acr/testrepository/manifests/list',
headers=_get_authorization_header('username', 'password'),
params={
'n': 20,
'orderby': None
},
json=None,
verify=mock.ANY)
# Show manifests using Bearer auth with detail
mock_get_registry_by_name.return_value = Registry(location='westus', sku=Sku(name='Standard')), 'testrg'
mock_get_access_credentials.return_value = 'testregistry.azurecr.io', None, 'password'
acr_repository_show_manifests(cmd, 'testregistry', 'testrepository', top=10, orderby='time_desc', detail=True)
mock_requests_get.assert_called_with(
method='get',
url='https://testregistry.azurecr.io/acr/v1/testrepository/_manifests',
headers=_get_authorization_header(None, 'password'),
params={
'n': 10,
'orderby': 'timedesc'
},
json=None,
verify=mock.ANY)
def test_supported_api_version_max_constraint_semver(self):
cli = DummyCli()
cli.cloud = Cloud('TestCloud', profile='2017-01-01-profile')
test_profile = {
'2017-01-01-profile': {
ResourceType.MGMT_KEYVAULT: '7.0'
}
}
with mock.patch('azure.cli.core.profiles._shared.AZURE_API_PROFILES',
test_profile):
self.assertTrue(
supported_api_version(cli,
ResourceType.MGMT_KEYVAULT,
max_api='8.0'))
def test_configure_output_options(self):
from azure.cli.core._output import AzOutputProducer
from azure.cli.core.mock import DummyCli
from azure.cli.command_modules.configure._consts import OUTPUT_LIST
output_producer = AzOutputProducer(DummyCli())
cli_output_options = set(output_producer._FORMAT_DICT.keys())
configure_output_options = set(item["name"] for item in OUTPUT_LIST)
self.assertEqual(
cli_output_options, configure_output_options,
"\n{}'s output options: {}\ndon't match az configure's output options ({})."
.format(AzOutputProducer.__name__, cli_output_options,
configure_output_options))
def test_figure_out_storage_source(self):
test_data = 'https://av123images.blob.core.windows.net/images/TDAZBET.vhd'
src_blob_uri, src_disk, src_snapshot = _figure_out_storage_source(
DummyCli(), 'tg1', test_data)
self.assertFalse(src_disk)
self.assertFalse(src_snapshot)
self.assertEqual(src_blob_uri, test_data)
test_data = '/subscriptions/0b1f6471-1bf0-4dda-aec3-cb9272f09590/resourceGroups/JAVACSMRG6017/providers/Microsoft.Compute/disks/ex.vhd'
src_blob_uri, src_disk, src_snapshot = _figure_out_storage_source(
None, 'tg1', test_data)
self.assertEqual(src_disk, test_data)
self.assertFalse(src_snapshot)
self.assertFalse(src_blob_uri)
def test_supported_api_version_min_constraint(self):
cli = DummyCli()
cli.cloud = Cloud('TestCloud', profile='2017-01-01-profile')
test_profile = {
'2017-01-01-profile': {
ResourceType.MGMT_STORAGE: '2020-10-10'
}
}
with mock.patch('azure.cli.core.profiles._shared.AZURE_API_PROFILES',
test_profile):
self.assertTrue(
supported_api_version(cli,
ResourceType.MGMT_STORAGE,
min_api='2000-01-01'))
def test_add_get_cloud_with_invalid_profile(self):
# Cloud has profile that doesn't exist so an exception should be raised
cli = DummyCli()
profile = 'none-existent-profile'
c = Cloud('MyOwnCloud', profile=profile)
with mock.patch('azure.cli.core.cloud.CLOUD_CONFIG_FILE', tempfile.mkstemp()[1]) as\
config_file:
add_cloud(cli, c)
config = configparser.ConfigParser()
config.read(config_file)
self.assertTrue(c.name in config.sections())
self.assertEqual(config.get(c.name, 'profile'), profile)
with self.assertRaises(CLIError):
get_custom_clouds(cli)
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
dns_name = self.id_generator()
parameters = (
'adminUsername=admin123 adminPassword=SecretPassword123 location=westus '
'domainName=domain.com dnsPrefix={}').format(dns_name)
template = 'az deployment group create --name {} -g {} --template-uri {} --parameters {}'
execute(
DummyCli(),
template.format(
'domaintemplate', group,
'https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/application-workloads/active-directory/active-directory-new-domain/azuredeploy.json',
parameters))
return {self.parameter_name: name}
def setUp(self):
mock_logger = MagicMock()
mock_cmd = MagicMock()
mock_cmd.cli_ctx = DummyCli()
self._client = AzureDevopsBuildInteractive(cmd=mock_cmd,
logger=mock_logger,
functionapp_name=None,
organization_name=None,
project_name=None,
repository_name=None,
overwrite_yaml=None,
allow_force_push=None,
github_pat=None,
github_repository=None)
def test_supported_api_version_invalid_rt_for_profile(self):
cli = DummyCli()
cli.cloud = Cloud('TestCloud', profile='2017-01-01-profile')
test_profile = {
'2017-01-01-profile': {
ResourceType.MGMT_STORAGE: '2020-10-10'
}
}
with mock.patch('azure.cli.core.profiles._shared.AZURE_API_PROFILES',
test_profile):
with self.assertRaises(APIVersionException):
supported_api_version(cli,
ResourceType.MGMT_COMPUTE,
min_api='2020-01-01')
def __init__(self, name_prefix='clitest-vault', parameter_name='vault_name',
resource_group_location_parameter_name='resource_group_location',
resource_group_parameter_name='resource_group',
dev_setting_name='AZURE_CLI_TEST_DEV_BACKUP_ACCT_NAME', soft_delete=True):
super(VaultPreparer, self).__init__(name_prefix, 24)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.parameter_name = parameter_name
self.resource_group = None
self.resource_group_parameter_name = resource_group_parameter_name
self.location = None
self.resource_group_location_parameter_name = resource_group_location_parameter_name
self.dev_setting_value = os.environ.get(dev_setting_name, None)
self.soft_delete = soft_delete
def test_get_raw_token(self, get_raw_token_mock):
cmd = mock.MagicMock()
cmd.cli_ctx = DummyCli()
# arrange
get_raw_token_mock.return_value = (['bearer', 'token123', {'expiresOn': '2100-01-01'}], 'sub123', 'tenant123')
# action
result = get_access_token(cmd)
# assert
get_raw_token_mock.assert_called_with(mock.ANY, 'https://management.core.windows.net/', None, None)
expected_result = {
'tokenType': 'bearer',
'accessToken': 'token123',
'expiresOn': '2100-01-01',
'subscription': 'sub123',
'tenant': 'tenant123'
}
self.assertEqual(result, expected_result)
# assert it takes customized resource, subscription
resource = 'https://graph.microsoft.com/'
subscription_id = '00000001-0000-0000-0000-000000000000'
get_raw_token_mock.return_value = (['bearer', 'token123', {'expiresOn': '2100-01-01'}], subscription_id,
'tenant123')
result = get_access_token(cmd, subscription=subscription_id, resource=resource)
get_raw_token_mock.assert_called_with(mock.ANY, resource, subscription_id, None)
expected_result = {
'tokenType': 'bearer',
'accessToken': 'token123',
'expiresOn': '2100-01-01',
'subscription': subscription_id,
'tenant': 'tenant123'
}
self.assertEqual(result, expected_result)
# test get token with tenant
tenant_id = '00000000-0000-0000-0000-000000000000'
get_raw_token_mock.return_value = (['bearer', 'token123', {'expiresOn': '2100-01-01'}], None, tenant_id)
result = get_access_token(cmd, tenant=tenant_id)
get_raw_token_mock.assert_called_with(mock.ANY, 'https://management.core.windows.net/', None, tenant_id)
expected_result = {
'tokenType': 'bearer',
'accessToken': 'token123',
'expiresOn': '2100-01-01', # subscription shouldn't be present
'tenant': tenant_id
}
self.assertEqual(result, expected_result)
def test_monitor_resource_id(self):
from azure.cli.command_modules.monitor.validators import get_target_resource_validator
from azure.cli.core.mock import DummyCli
cmd = mock.MagicMock()
cmd.cli_ctx = DummyCli()
validator = get_target_resource_validator('name_or_id', True)
id = '/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-rg/providers/Microsoft.Compute/' \
'virtualMachines/vm1'
# must supply name or ID
ns = self._build_namespace()
with self.assertRaises(CLIError):
validator(cmd, ns)
# must only supply ID or name parameters
ns = self._build_namespace(id, 'my-rg', 'blahblah', 'stuff')
with self.assertRaises(CLIError):
validator(cmd, ns)
# error on invalid ID
ns = self._build_namespace('bad-id')
with self.assertRaises(CLIError):
validator(cmd, ns)
# allow Provider/Type syntax (same as resource commands)
ns = self._build_namespace('vm1', 'my-rg', None, None, 'Microsoft.Compute/virtualMachines')
validator(cmd, ns)
self.assertEqual(ns.name_or_id, id)
# allow Provider and Type separate
ns = self._build_namespace('vm1', 'my-rg', 'Microsoft.Compute', None, 'virtualMachines')
validator(cmd, ns)
self.assertEqual(ns.name_or_id, id)
# verify works with parent
id = '/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-rg/providers/Microsoft.Compute/' \
'fakeType/type1/anotherFakeType/type2/virtualMachines/vm1'
ns = self._build_namespace('vm1', 'my-rg', 'Microsoft.Compute', 'fakeType/type1/anotherFakeType/type2',
'virtualMachines')
validator(cmd, ns)
self.assertEqual(ns.name_or_id, id)
# verify extra parameters are removed
self.assertFalse(hasattr(ns, 'resource_name'))
self.assertFalse(hasattr(ns, 'namespace'))
self.assertFalse(hasattr(ns, 'parent'))
self.assertFalse(hasattr(ns, 'resource_type'))
def test_parser_failure_recovery_recommendations(self):
cli = DummyCli()
main_loader = MainCommandsLoader(cli)
cli.loader = main_loader
cli.loader.load_command_table(None)
parser = cli.parser_cls(cli)
parser.load_command_table(cli.loader)
recommendation_provider_parameters = []
version = cli.get_cli_version()
expected_recommendation_provider_parameters = [
# version, command, parameters, extension
ExpectedParameters(version, 'test module1', ['--opt'], False),
ExpectedParameters(version, 'test extension1', ['--opt'], False),
ExpectedParameters(version, 'foo_bar', ['--opt'], False),
ExpectedParameters(version, 'test module', ['--opt'], False),
ExpectedParameters(version, 'test extension', ['--opt'], True)
]
def mock_recommendation_provider(*args):
recommendation_provider_parameters.append(tuple(args))
return []
AzCliCommandParser.recommendation_provider = mock_recommendation_provider
faulty_cmd_args = [
'test module1 --opt enum_1', 'test extension1 --opt enum_1',
'test foo_bar --opt enum_3', 'test module --opt enum_3',
'test extension --opt enum_3'
]
for text in faulty_cmd_args:
with self.assertRaises(SystemExit):
parser.parse_args(text.split())
for i, parameters in enumerate(recommendation_provider_parameters):
version, command, parameters, extension = parameters
expected = expected_recommendation_provider_parameters[i]
self.assertEqual(expected.version, version)
self.assertIn(expected.command, command)
self.assertEqual(expected.parameters, parameters)
if expected.has_extension:
self.assertIsNotNone(extension)
else:
self.assertIsNone(extension)
def test_helm_show(self, mock_requests_get, mock_get_access_credentials):
cmd = mock.MagicMock()
cmd.cli_ctx = DummyCli()
encoded_charts = json.dumps({
'mychart1': [{
'name': 'mychart1',
'version': '0.2.1'
}, {
'name': 'mychart1',
'version': '0.1.2'
}]
}).encode()
response = mock.MagicMock()
response.headers = {}
response.status_code = 200
response.content = encoded_charts
mock_requests_get.return_value = response
mock_get_access_credentials.return_value = 'testregistry.azurecr.io', EMPTY_GUID, 'password'
# Show all versions of a chart
acr_helm_show(cmd,
'testregistry',
'mychart1',
repository='testrepository')
mock_requests_get.assert_called_with(
method='get',
url=
'https://testregistry.azurecr.io/helm/v1/testrepository/_charts/mychart1',
headers=get_authorization_header(EMPTY_GUID, 'password'),
params=None,
json=None,
verify=mock.ANY)
# Show one version of a chart
acr_helm_show(cmd,
'testregistry',
'mychart1',
version='0.2.1',
repository='testrepository')
mock_requests_get.assert_called_with(
method='get',
url=
'https://testregistry.azurecr.io/helm/v1/testrepository/_charts/mychart1/0.2.1',
headers=get_authorization_header(EMPTY_GUID, 'password'),
params=None,
json=None,
verify=mock.ANY)
def test_help_loads(self):
from azure.cli.core.commands.arm import add_id_parameters
import knack.events as events
cli = DummyCli()
parser_dict = {}
cli = DummyCli()
help_ctx = cli.help_cls(cli)
try:
cli.invoke(['-h'])
except SystemExit:
pass
cmd_tbl = cli.invocation.commands_loader.command_table
cli.invocation.parser.load_command_table(
cli.invocation.commands_loader)
for cmd in cmd_tbl:
try:
cmd_tbl[cmd].loader.command_name = cmd
cmd_tbl[cmd].loader.load_arguments(cmd)
except KeyError:
pass
cli.register_event(events.EVENT_INVOKER_POST_CMD_TBL_CREATE,
add_id_parameters)
cli.raise_event(events.EVENT_INVOKER_CMD_TBL_LOADED,
command_table=cmd_tbl)
cli.invocation.parser.load_command_table(
cli.invocation.commands_loader)
_store_parsers(cli.invocation.parser, parser_dict)
for name, parser in parser_dict.items():
try:
help_file = GroupHelpFile(help_ctx, name, parser) if _is_group(parser) \
else CliCommandHelpFile(help_ctx, name, parser)
help_file.load(parser)
except Exception as ex:
raise HelpAuthoringException('{}, {}'.format(name, ex))
def __init__(self,
name_prefix='clitest-item',
parameter_name='policy_name',
vault_parameter_name='vault_name',
resource_group_parameter_name='resource_group',
dev_setting_name='AZURE_CLI_TEST_DEV_BACKUP_POLICY_NAME'):
super(PolicyPreparer, self).__init__(name_prefix, 24)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.parameter_name = parameter_name
self.resource_group = None
self.resource_group_parameter_name = resource_group_parameter_name
self.vault = None
self.vault_parameter_name = vault_parameter_name
self.dev_setting_value = os.environ.get(dev_setting_name, None)
def test_list_only_enabled_one(self, logger_mock, load_subscription_mock):
cmd = mock.MagicMock()
cmd.cli_ctx = DummyCli()
sub1 = {'state': 'Enabled'}
sub2 = {'state': 'Overdued'}
load_subscription_mock.return_value = [sub1, sub2]
# list all
self.assertEqual(2, len(list_subscriptions(cmd, all=True)))
self.assertTrue(not logger_mock.warning.called)
# list only enabled one
result = list_subscriptions(cmd)
self.assertEqual(1, len(result))
self.assertEqual('Enabled', result[0]['state'])
logger_mock.warning.assert_called_once_with(mock.ANY)
def mock_echo_args(command_name, parameters):
from azure.cli.core.mock import DummyCli
try:
# TODO: continue work on this...
argv = ' '.join((command_name, parameters)).split()
cli = DummyCli()
cli.invoke(argv)
command_table = cli.invocation.commands_loader.command_table
prefunc = command_table[command_name].handler
command_table[command_name].handler = lambda args: args
cli.invoke(argv)
parsed_namespace = None # continue this too...
return parsed_namespace
finally:
command_table[command_name].handler = prefunc
def __init__(self,
name_prefix='clitest-item',
parameter_name='policy_name',
vault_parameter_name='vault_name',
resource_group_parameter_name='resource_group',
instant_rp_days=None):
super(AFSPolicyPreparer, self).__init__(name_prefix, 24)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.parameter_name = parameter_name
self.resource_group = None
self.resource_group_parameter_name = resource_group_parameter_name
self.vault = None
self.vault_parameter_name = vault_parameter_name
self.instant_rp_days = instant_rp_days
def test_repository_list(self, mock_requests_get,
mock_get_access_credentials,
mock_get_registry_by_name):
cmd = mock.MagicMock()
cmd.cli_ctx = DummyCli()
encoded_repositories = json.dumps({
'repositories': ['testrepo1', 'testrepo2']
}).encode()
response = mock.MagicMock()
response.headers = {}
response.status_code = 200
response.content = encoded_repositories
mock_requests_get.return_value = response
# List repositories using Basic auth on a classic registry
mock_get_registry_by_name.return_value = Registry(
location='westus', sku=Sku(name='Classic')), 'testrg'
mock_get_access_credentials.return_value = 'testregistry.azurecr.io', 'username', 'password'
acr_repository_list(cmd, 'testregistry')
mock_requests_get.assert_called_with(
method='get',
url='https://testregistry.azurecr.io/v2/_catalog',
headers=get_authorization_header('username', 'password'),
params={
'n': 100,
'orderby': None
},
json=None,
data=None,
verify=mock.ANY)
# List repositories using Bearer auth on a managed registry
mock_get_registry_by_name.return_value = Registry(
location='westus', sku=Sku(name='Standard')), 'testrg'
mock_get_access_credentials.return_value = 'testregistry.azurecr.io', EMPTY_GUID, 'password'
acr_repository_list(cmd, 'testregistry', top=10)
mock_requests_get.assert_called_with(
method='get',
url='https://testregistry.azurecr.io/acr/v1/_catalog',
headers=get_authorization_header(EMPTY_GUID, 'password'),
params={
'n': 10,
'orderby': None
},
json=None,
data=None,
verify=mock.ANY)
def __init__(
self,
name_prefix='clitest-vm',
parameter_name='vm_name',
resource_group_location_parameter_name='resource_group_location',
resource_group_parameter_name='resource_group',
dev_setting_name='AZURE_CLI_TEST_DEV_BACKUP_VM_NAME'):
super(VMPreparer, self).__init__(name_prefix, 15)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.parameter_name = parameter_name
self.resource_group = None
self.resource_group_parameter_name = resource_group_parameter_name
self.location = None
self.resource_group_location_parameter_name = resource_group_location_parameter_name
self.dev_setting_value = os.environ.get(dev_setting_name, None)
def __init__(self,
name_prefix='clitest-item',
storage_account_parameter_name='storage_account',
resource_group_parameter_name='resource_group',
vault_parameter_name='vault_name',
parameter_name='rp_name',
afs_parameter_name='afs_name'):
super(AFSRPPreparer, self).__init__(name_prefix, 24)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.parameter_name = parameter_name
self.resource_group = None
self.resource_group_parameter_name = resource_group_parameter_name
self.storage_account_parameter_name = storage_account_parameter_name
self.vault_parameter_name = vault_parameter_name
self.afs_parameter_name = afs_parameter_name
def __init__(self,
name_prefix='clitest-item',
storage_account_parameter_name='storage_account',
resource_group_parameter_name='resource_group',
file_parameter_name=None,
parameter_name='afs_name',
file_upload=False):
super(FileSharePreparer, self).__init__(name_prefix, 24)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.parameter_name = parameter_name
self.resource_group = None
self.resource_group_parameter_name = resource_group_parameter_name
self.storage_account_parameter_name = storage_account_parameter_name
self.file_parameter_name = file_parameter_name
self.file_upload = file_upload
def test_get_clouds_concurrent(self):
with mock.patch('azure.cli.core.cloud.CLOUD_CONFIG_FILE', tempfile.mkstemp()[1]) as config_file:
# Max pool_size is 61, otherwise exception will be thrown on Python 3.8 Windows:
# File "...Python38\lib\multiprocessing\connection.py", line 810, in _exhaustive_wait
# res = _winapi.WaitForMultipleObjects(L, False, timeout)
# ValueError: need at most 63 handles, got a sequence of length 102
pool_size = 20
p = multiprocessing.Pool(pool_size)
p.map(_helper_get_clouds, range(pool_size))
p.close()
p.join()
# Check we can read the file with no exceptions
cli = DummyCli()
configparser.ConfigParser().read(config_file)
for kc in KNOWN_CLOUDS:
get_cloud(cli, kc.name)
def test_source_storage_account_err_case(self):
np = mock.MagicMock()
cmd = mock.MagicMock()
cmd.cli_ctx = DummyCli()
np._cmd = cmd
np.source_storage_account_id = '/subscriptions/123/resourceGroups/ygsrc/providers/Microsoft.Storage/storageAccounts/s123'
np.source = '/subscriptions/123/resourceGroups/yugangw/providers/Microsoft.Compute/disks/d2'
# action (should throw)
kwargs = {'namespace': np}
with self.assertRaises(CLIError):
process_disk_or_snapshot_create_namespace(cmd, **kwargs)
# with blob uri, should be fine
np.source = 'https://s1.blob.core.windows.net/vhds/s1.vhd'
process_disk_or_snapshot_create_namespace(cmd, **kwargs)
def test_register_command_from_extension(self):
from azure.cli.core.commands import _load_command_loader
cli = DummyCli()
main_loader = MainCommandsLoader(cli)
cli.loader = main_loader
cmd_tbl = cli.loader.load_command_table(None)
ext1 = cmd_tbl['hello noodle']
ext2 = cmd_tbl['hello world']
self.assertTrue(isinstance(ext1.command_source, ExtensionCommandSource))
self.assertFalse(ext1.command_source.overrides_command)
self.assertTrue(isinstance(ext2.command_source, ExtensionCommandSource))
self.assertTrue(ext2.command_source.overrides_command)
def test_local_context(self, get_username):
get_username.return_value = 'core_test_user'
local_context = AzCLILocalContext(DummyCli())
self.assertFalse(local_context.is_on)
local_context.turn_on()
self.assertTrue(local_context.is_on)
local_context.set(['all'], 'resource_group_name', 'test_rg')
self.assertEqual('test_rg', local_context.get('all', 'resource_group_name'))
self.assertEqual('test_rg', local_context.get_value(['resource_group_name'])['all']['resource_group_name'])
local_context.delete(['resource_group_name'])
local_context.initialize() # reload local context file
self.assertNotEqual('test_rg', local_context.get('all', 'resource_group_name'))
local_context.clear()
local_context.delete_file()
local_context.turn_off()
self.assertFalse(local_context.is_on)
def __init__(self,
engine_type,
location,
engine_parameter_name='database_engine',
name_prefix=SERVER_NAME_PREFIX,
parameter_name='server',
resource_group_parameter_name='resource_group'):
super(ServerPreparer, self).__init__(name_prefix,
SERVER_NAME_MAX_LENGTH)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.engine_type = engine_type
self.engine_parameter_name = engine_parameter_name
self.location = location
self.parameter_name = parameter_name
self.resource_group_parameter_name = resource_group_parameter_name
def __init__(self,
name_prefix='clibatch',
parameter_name='batch_account_name',
location='westus',
resource_group_parameter_name='resource_group',
skip_delete=True,
dev_setting_name='AZURE_CLI_TEST_DEV_BATCH_ACCT_NAME'):
super(BatchAccountPreparer, self).__init__(name_prefix, 24)
from azure.cli.core.mock import DummyCli
self.cli_ctx = DummyCli()
self.parameter_name = parameter_name
self.resource_group = None
self.resource_group_parameter_name = resource_group_parameter_name
self.skip_delete = skip_delete
self.location = location
self.dev_setting_value = os.environ.get(dev_setting_name, None)
