def test_case_insensitive_enum_choices(self):
from enum import Enum
class TestEnum(Enum): # pylint: disable=too-few-public-methods
opt1 = "ALL_CAPS"
opt2 = "camelCase"
opt3 = "snake_case"
def test_handler():
pass
cli = TestCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'test command', test_handler)
command.add_argument('opt', '--opt', required=True, **enum_choice_list(TestEnum))
cmd_table = {'test command': command}
cli.commands_loader.command_table = cmd_table
parser = AzCliCommandParser(cli)
parser.load_command_table(cli.commands_loader)
args = parser.parse_args('test command --opt alL_cAps'.split())
self.assertEqual(args.opt, 'ALL_CAPS')
args = parser.parse_args('test command --opt CAMELCASE'.split())
self.assertEqual(args.opt, 'camelCase')
args = parser.parse_args('test command --opt sNake_CASE'.split())
self.assertEqual(args.opt, 'snake_case')
def test_register_simple_commands(self):
def test_handler1():
pass
def test_handler2():
pass
cli = DummyCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'command the-name', test_handler1)
command2 = AzCliCommand(cli.loader, 'sub-command the-second-name',
test_handler2)
cmd_table = {
'command the-name': command,
'sub-command the-second-name': command2
}
cli.commands_loader.command_table = cmd_table
parser = AzCliCommandParser(cli)
parser.load_command_table(cli.commands_loader)
args = parser.parse_args('command the-name'.split())
self.assertIs(args.func, command)
args = parser.parse_args('sub-command the-second-name'.split())
self.assertIs(args.func, command2)
AzCliCommandParser.error = VerifyError(self, )
parser.parse_args('sub-command'.split())
self.assertTrue(AzCliCommandParser.error.called)
def _get_test_cmd():
cli_ctx = DummyCli()
loader = AzCommandsLoader(cli_ctx, resource_type=ResourceType.MGMT_COMPUTE)
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {'resource_type': ResourceType.MGMT_COMPUTE, 'operation_group': 'virtual_machines'}
cmd.cli_ctx = cli_ctx
return cmd
def test_case_insensitive_enum_choices(self):
from enum import Enum
class TestEnum(Enum): # pylint: disable=too-few-public-methods
opt1 = "ALL_CAPS"
opt2 = "camelCase"
opt3 = "snake_case"
def test_handler():
pass
cli = DummyCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'test command', test_handler)
command.add_argument('opt',
'--opt',
required=True,
**enum_choice_list(TestEnum))
cmd_table = {'test command': command}
cli.commands_loader.command_table = cmd_table
parser = AzCliCommandParser(cli)
parser.load_command_table(cli.commands_loader)
args = parser.parse_args('test command --opt alL_cAps'.split())
self.assertEqual(args.opt, 'ALL_CAPS')
args = parser.parse_args('test command --opt CAMELCASE'.split())
self.assertEqual(args.opt, 'camelCase')
args = parser.parse_args('test command --opt sNake_CASE'.split())
self.assertEqual(args.opt, 'snake_case')
def _get_test_cmd():
cli_ctx = DummyCli()
cli_ctx.data['subscription_id'] = '00000000-0000-0000-0000-000000000000'
loader = AzCommandsLoader(cli_ctx, resource_type='Microsoft.AppPlatform')
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {'resource_type': 'Microsoft.AppPlatform'}
cmd.cli_ctx = cli_ctx
return cmd
def load_command_table(self, args):
super(ExtCommandsLoader, self).load_command_table(args)
command = AzCliCommand(loader, 'test extension', test_handler)
command.add_argument('opt',
'--opt',
required=True,
**enum_choice_list(TestEnum))
self.command_table['test extension'] = command
return self.command_table
def _get_test_cmd():
from azure.cli.testsdk import TestCli
from azure.cli.core import AzCommandsLoader
from azure.cli.core.commands import AzCliCommand
cli_ctx = TestCli()
loader = AzCommandsLoader(cli_ctx, resource_type=ResourceType.MGMT_COMPUTE)
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {'resource_type': ResourceType.MGMT_COMPUTE}
cmd.cli_ctx = cli_ctx
return cmd
def _get_test_cmd():
from azure.cli.core.mock import DummyCli
from azure.cli.core import AzCommandsLoader
from azure.cli.core.commands import AzCliCommand
cli_ctx = DummyCli()
loader = AzCommandsLoader(cli_ctx, resource_type=ResourceType.MGMT_APPSERVICE)
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {'resource_type': ResourceType.MGMT_APPSERVICE}
cmd.cli_ctx = cli_ctx
return cmd
def _get_test_cmd():
from azure.cli.testsdk import TestCli
from azure.cli.core import AzCommandsLoader
from azure.cli.core.commands import AzCliCommand
cli_ctx = TestCli()
loader = AzCommandsLoader(cli_ctx, resource_type=ResourceType.MGMT_COMPUTE)
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {'resource_type': ResourceType.MGMT_COMPUTE}
cmd.cli_ctx = cli_ctx
return cmd
def _get_test_cmd():
from azure.cli.core.mock import DummyCli
from azure.cli.core import AzCommandsLoader
from azure.cli.core.commands import AzCliCommand
from azure.cli.core.profiles import ResourceType
cli_ctx = DummyCli()
loader = AzCommandsLoader(cli_ctx, resource_type=ResourceType.MGMT_COMPUTE)
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {'resource_type': ResourceType.MGMT_COMPUTE}
cmd.cli_ctx = cli_ctx
return cmd
def fixture_cmd(mocker):
cli = DummyCli()
cli.loader = mocker.MagicMock()
cli.loader.cli_ctx = cli
def test_handler1():
pass
return AzCliCommand(cli.loader, "iot-extension command", test_handler1)
def test_nargs_parameter(self):
def test_handler():
pass
cli = TestCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'test command', test_handler)
command.add_argument('req', '--req', required=True, nargs=2)
cmd_table = {'test command': command}
parser = AzCliCommandParser(cli)
parser.load_command_table(cmd_table)
args = parser.parse_args('test command --req yep nope'.split())
self.assertIs(args.func, command)
AzCliCommandParser.error = VerifyError(self)
parser.parse_args('test command -req yep'.split())
self.assertTrue(AzCliCommandParser.error.called)
def test_required_parameter(self):
def test_handler(args): # pylint: disable=unused-argument
pass
cli = DummyCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'test command', test_handler)
command.add_argument('req', '--req', required=True)
cmd_table = {'test command': command}
cli.commands_loader.command_table = cmd_table
parser = AzCliCommandParser(cli)
parser.load_command_table(cli.commands_loader)
args = parser.parse_args('test command --req yep'.split())
self.assertIs(args.func, command)
AzCliCommandParser.error = VerifyError(self)
parser.parse_args('test command'.split())
self.assertTrue(AzCliCommandParser.error.called)
def test_required_parameter(self):
def test_handler(args): # pylint: disable=unused-argument
pass
cli = DummyCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'test command', test_handler)
command.add_argument('req', '--req', required=True)
cmd_table = {'test command': command}
cli.commands_loader.command_table = cmd_table
parser = AzCliCommandParser(cli)
parser.load_command_table(cli.commands_loader)
args = parser.parse_args('test command --req yep'.split())
self.assertIs(args.func, command)
AzCliCommandParser.error = VerifyError(self)
parser.parse_args('test command'.split())
self.assertTrue(AzCliCommandParser.error.called)
def test_nargs_parameter(self):
def test_handler():
pass
cli = TestCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'test command', test_handler)
command.add_argument('req', '--req', required=True, nargs=2)
cmd_table = {'test command': command}
cli.commands_loader.command_table = cmd_table
parser = AzCliCommandParser(cli)
parser.load_command_table(cli.commands_loader)
args = parser.parse_args('test command --req yep nope'.split())
self.assertIs(args.func, command)
AzCliCommandParser.error = VerifyError(self)
parser.parse_args('test command -req yep'.split())
self.assertTrue(AzCliCommandParser.error.called)
def test_nargs_parameter(self):
def test_handler():
pass
cli = DummyCli()
cli.loader = mock.MagicMock()
cli.loader.cli_ctx = cli
command = AzCliCommand(cli.loader, 'test command', test_handler)
command.add_argument('req', '--req', required=True, nargs=2)
cmd_table = {'test command': command}
cli.commands_loader.command_table = cmd_table
parser = AzCliCommandParser(cli)
parser.load_command_table(cli.commands_loader)
args = parser.parse_args('test command --req yep nope'.split())
self.assertIs(args.func, command)
with mock.patch('azure.cli.core.parser.AzCliCommandParser.error', new=VerifyError(self)):
parser.parse_args('test command -req yep'.split())
self.assertTrue(AzCliCommandParser.error.called)
class MockCmd:
def __init__(self, cli_ctx):
self.cli_ctx = cli_ctx
self.cmd = AzCliCommand(AzCommandsLoader(cli_ctx), "mock-cmd", None)
def supported_api_version(
self,
resource_type=None,
min_api=None,
max_api=None,
operation_group=None,
parameter_name=None,
):
return self.cmd.supported_api_version(
resource_type=resource_type,
min_api=min_api,
max_api=max_api,
operation_group=operation_group,
parameter_name=parameter_name,
)
def get_models(self, *attr_args, **kwargs):
return self.cmd.get_models(*attr_args, **kwargs)
def test_what_if_exclude_change_types(self, long_running_operation_stub):
# Arrange.
from azure.cli.core.mock import DummyCli
from azure.cli.core import AzCommandsLoader
from azure.cli.core.commands import AzCliCommand
from azure.cli.core.profiles._shared import ResourceType
cli_ctx = DummyCli()
loader = AzCommandsLoader(
cli_ctx, resource_type=ResourceType.MGMT_RESOURCE_RESOURCES)
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {
'resource_type': ResourceType.MGMT_RESOURCE_RESOURCES
}
cmd.cli_ctx = cli_ctx
WhatIfOperationResult, WhatIfChange, ChangeType = cmd.get_models(
'WhatIfOperationResult', 'WhatIfChange', 'ChangeType')
long_running_operation_stub.return_value = WhatIfOperationResult(
changes=[
WhatIfChange(resource_id='resource0',
change_type=ChangeType.create),
WhatIfChange(resource_id='resource1',
change_type=ChangeType.modify),
WhatIfChange(resource_id='resource2',
change_type=ChangeType.ignore),
])
# Act.
result = _what_if_deploy_arm_template_core(cmd.cli_ctx,
mock.MagicMock(), True,
["create", "igNoRE"])
# Assert.
self.assertEqual(1, len(result.changes))
self.assertEqual(ChangeType.modify, result.changes[0].change_type)
def create_invoker_and_load_cmds_and_args(cli):
cli.invocation = mock.MagicMock()
cli.invocation.commands_loader = mock.MagicMock()
cli.invocation.commands_loader.command_table = self.cmd_table = {}
for cmd in [
'foo command_1', 'foo command_2', 'bar command_1',
'bar command_2', 'foobar'
]:
self.cmd_table[cmd] = AzCliCommand(
cli.invocation.commands_loader, cmd, lambda: None)
for cmd in ['bar command_1', 'bar command_2']:
self.cmd_table[cmd].command_source = ExtensionCommandSource(
extension_name='bar')
self.cmd_table[cmd].command_source.extension_name = 'bar'
for cmd in ['foo command_1', 'foo command_2']:
self.cmd_table[cmd].command_source = mock.MagicMock()
self.cmd_table[cmd].command_source = 'foo'
def load_command_table(self, args):
super(TestCommandsLoader, self).load_command_table(args)
self.command_table = {'test': AzCliCommand(self, 'test', _handler)}
return self.command_table
# --------------------------------------------------------------------------------------------
import unittest
from azure.cli.core.profiles import ResourceType
from azure.cli.core.mock import DummyCli
from azure.cli.core import AzCommandsLoader
from azure.cli.core.commands import AzCliCommand
from azure.cli.command_modules.resource._color import Color, ColoredStringBuilder
from azure.cli.command_modules.resource._formatters import format_json, format_what_if_operation_result
cli_ctx = DummyCli()
loader = AzCommandsLoader(cli_ctx, resource_type=ResourceType.MGMT_RESOURCE_RESOURCES)
cmd = AzCliCommand(loader, "test", None, resource_type=ResourceType.MGMT_RESOURCE_RESOURCES)
WhatIfOperationResult, WhatIfChange, WhatIfPropertyChange, ChangeType, PropertyChangeType = cmd.get_models(
"WhatIfOperationResult", "WhatIfChange", "WhatIfPropertyChange", "ChangeType", "PropertyChangeType",
)
class TestFormatJson(unittest.TestCase):
_colon = ColoredStringBuilder().append(":", Color.RESET).build()
_left_square_bracket = ColoredStringBuilder().append("[", Color.RESET).build()
_right_square_bracket = ColoredStringBuilder().append("]", Color.RESET).build()
def test_leaf(self):
test_data = (
("null", None),
("true", True),
_what_if_deploy_arm_template_core,
deploy_arm_template_at_resource_group,
deploy_arm_template_at_subscription_scope,
deploy_arm_template_at_management_group,
deploy_arm_template_at_tenant_scope,
)
from azure.cli.core.mock import DummyCli
from azure.cli.core import AzCommandsLoader
from azure.cli.core.commands import AzCliCommand
from azure.cli.core.profiles._shared import ResourceType
cli_ctx = DummyCli()
loader = AzCommandsLoader(cli_ctx,
resource_type=ResourceType.MGMT_RESOURCE_RESOURCES)
cmd = AzCliCommand(loader, 'test', None)
cmd.command_kwargs = {'resource_type': ResourceType.MGMT_RESOURCE_RESOURCES}
cmd.cli_ctx = cli_ctx
WhatIfOperationResult, WhatIfChange, ChangeType = cmd.get_models(
'WhatIfOperationResult', 'WhatIfChange', 'ChangeType')
def _simulate_no_tty():
from knack.prompting import NoTTYException
raise NoTTYException
@mock.patch('knack.prompting.verify_is_a_tty', _simulate_no_tty)
class TestCustom(unittest.TestCase):
def test_file_string_or_uri(self):
def load_command_table(self, args):
super(ExtCommandsLoader, self).load_command_table(args)
command = AzCliCommand(loader, 'test extension', test_handler)
command.add_argument('opt', '--opt', required=True, **enum_choice_list(TestEnum))
self.command_table['test extension'] = command
return self.command_table
def __init__(self, cli_ctx):
self.cli_ctx = cli_ctx
self.cmd = AzCliCommand(AzCommandsLoader(cli_ctx), "mock-cmd", None)
