def test_config_without_publishsettings(self):
account = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.no_publishsettings'))
assert account.get_management_url() == 'test.url'
assert account.certificate_filename() == '../data/pemfile'
assert account.subscription_id() == 'id1234'
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(
self.result,
self.global_args['--output-format'],
self.global_args['--output-style']
)
self.load_config()
self.account = AzureAccount(self.config)
self.image = Image(self.account)
if self.command_args['list']:
self.__list()
if self.command_args['show']:
self.__show()
elif self.command_args['create']:
self.__create()
elif self.command_args['delete']:
self.__delete()
elif self.command_args['replicate']:
self.__replicate()
elif self.command_args['replication-status']:
self.__replication_status(self.command_args['--name'])
elif self.command_args['unreplicate']:
self.__unreplicate()
elif self.command_args['publish']:
self.__publish()
elif self.command_args['update']:
self.__update()
def test_subscription_id_missing(self, base64_decode,
mock_dump_certificate, mock_dump_pkey,
mock_pkcs12):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_publishsettings_id'))
account_invalid.get_management_service()
def process(self):
self.manual = Help()
if self.__help():
return
self.load_config()
self.account = AzureAccount(self.config)
container_name = self.account.storage_container()
self.storage = Storage(self.account, container_name)
# default to 1 minute ago (skew around 'now')
if self.command_args['--start-datetime'] == 'now':
start = datetime.datetime.utcnow() - datetime.timedelta(minutes=1)
else:
start = self.validate_date('--start-datetime')
# default to 30 days from now
if self.command_args['--expiry-datetime'] == '30 days from start':
expiry = start + datetime.timedelta(days=30)
else:
expiry = self.validate_date('--expiry-datetime')
self.validate_sas_permissions('--permissions')
if self.command_args['upload']:
self.__upload()
elif self.command_args['delete']:
self.__delete()
elif self.command_args['sas']:
self.__sas(container_name, start, expiry,
self.command_args['--permissions'])
def setup(self):
# construct an account
account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
self.service = mock.Mock()
account.get_management_service = mock.Mock(return_value=self.service)
account.get_blob_service_host_base = mock.Mock(return_value='test.url')
account.storage_key = mock.Mock()
# now that that's done, instantiate an Endpoint with the account
self.endpoint = Endpoint(account)
# asynchronous API operations return a request object
self.my_request = mock.Mock(request_id=Defaults.unify_id(42))
# variables used in multiple tests
self.cloud_service_name = 'mockcloudservice'
self.instance_name = 'mockcloudserviceinstance1'
self.endpoint_name = 'HTTPS'
self.port = '443'
self.idle_timeout = 10
self.protocol = 'tcp'
self.udp_endpoint_name = 'SNMP'
self.udp_port = '131'
self.instance_port = '10000'
self.udp_protocol = 'udp'
# identify the instance for the Endpoint to work on
self.endpoint.set_instance(self.cloud_service_name, self.instance_name)
# mock out the get_role function of service
self.service.get_role = mock.Mock(return_value=self.mock_role())
def setup(self, mock_temp):
tempfile = mock.Mock()
tempfile.name = 'tempfile'
mock_temp.return_value = tempfile
self.account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
azurectl.account.service.load_pkcs12 = mock.Mock()
def setup(self):
account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
self.service = mock.Mock()
account.get_management_service = mock.Mock(return_value=self.service)
account.get_blob_service_host_base = mock.Mock(return_value='test.url')
account.storage_key = mock.Mock()
# now that that's done, instantiate a DataDisk with the account
self.data_disk = DataDisk(account)
# asynchronous API operations return a request object
self.my_request = mock.Mock(request_id=Defaults.unify_id(42))
# variables used in multiple tests
self.cloud_service_name = 'mockcloudservice'
self.instance_name = 'mockcloudserviceinstance1'
self.lun = 0
self.host_caching = 'ReadWrite'
self.disk_filename = 'mockcloudserviceinstance1-data-disk-0.vhd'
self.disk_name = 'mockcloudserviceinstance1-data-disk-0'
self.disk_url = ('https://' + account.storage_name() + '.blob.' +
account.get_blob_service_host_base() + '/' +
account.storage_container() + '/' +
self.disk_filename)
self.disk_label = 'Mock data disk'
self.disk_size = 42
self.timestamp = datetime.utcnow()
self.time_string = datetime.isoformat(self.timestamp).replace(':', '_')
self.account = account
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(self.result, self.global_args['--output-format'],
self.global_args['--output-style'])
self.load_config()
self.account = AzureAccount(self.config)
self.reserved_ip = ReservedIp(self.account)
if self.command_args['list']:
self.__list()
if self.command_args['show']:
self.__show()
if self.command_args['create']:
self.__create()
if self.command_args['delete']:
self.__delete()
if self.command_args['associate']:
self.__associate()
if self.command_args['disassociate']:
self.__disassociate()
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(self.result, self.global_args['--output-format'],
self.global_args['--output-style'])
self.load_config()
self.account = AzureAccount(self.config)
self.endpoint = Endpoint(self.account)
self.endpoint.set_instance(
self.command_args['--cloud-service-name'],
(self.command_args['--instance-name']
or self.command_args['--cloud-service-name']))
if self.command_args['list']:
self.__list()
if self.command_args['show']:
self.__show()
if self.command_args['create']:
self.__create()
if self.command_args['update']:
self.__update()
if self.command_args['delete']:
self.__delete()
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(self.result, self.global_args['--output-format'],
self.global_args['--output-style'])
self.load_config()
self.account = AzureAccount(self.config)
self.data_disk = DataDisk(self.account)
if self.command_args['create']:
self.__create()
if self.command_args['delete']:
self.__delete()
if self.command_args['attach']:
self.__attach()
if self.command_args['detach']:
self.__detach()
if self.command_args['attached']:
if self.command_args['show']:
self.__show_attached()
else:
if self.command_args['list']:
self.__list()
if self.command_args['show']:
self.__show()
def setup(self):
sys.argv = [
sys.argv[0], '--config', '../data/config', 'compute', 'shell'
]
account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
account.get_management_service = mock.Mock()
account.get_blob_service_host_base = mock.Mock(
return_value='.blob.test.url')
account.storage_key = mock.Mock()
azurectl.commands.compute_shell.AzureAccount = mock.Mock(
return_value=account)
self.task = ComputeShellTask()
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(
self.result,
self.global_args['--output-format'],
self.global_args['--output-style']
)
self.load_config()
self.account = AzureAccount(self.config)
# default to 1 minute ago (skew around 'now')
if self.command_args['--start-datetime'] == 'now':
start = datetime.datetime.utcnow() - datetime.timedelta(minutes=1)
else:
start = self.validate_date('--start-datetime')
# default to 30 days from now
if self.command_args['--expiry-datetime'] == '30 days from start':
expiry = start + datetime.timedelta(days=30)
else:
expiry = self.validate_date('--expiry-datetime')
self.validate_sas_permissions('--permissions')
self.container = Container(self.account)
if self.command_args['list']:
self.__container_list()
elif self.command_args['show']:
self.__container_content()
elif self.command_args['create']:
self.__container_create()
elif self.command_args['delete']:
self.__container_delete()
elif self.command_args['sas']:
self.__container_sas(
start, expiry, self.command_args['--permissions']
)
def process(self):
self.load_config()
account = AzureAccount(self.config)
service = account.get_management_service()
print(
dedent("""
An instance of azure.servicemanagement.ServiceManagementService has
been instantiated using the supplied credentials, as `service`.
azurectl convenience models can be instantiated using the same
credentials; e.g. `VirtualMachine(account)`. For convenience, use
the `pprint()` function to pretty-print results.
When you're finished, exit with `exit()`
"""))
code.interact(local={
'account': account,
'pprint': pprint,
'service': service
})
def setup(self):
account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
self.service = mock.Mock()
account.get_management_service = mock.Mock(return_value=self.service)
account.get_blob_service_host_base = mock.Mock(
return_value='.blob.test.url')
account.storage_key = mock.Mock()
MyStruct = namedtuple(
'MyStruct',
'name address label state in_use service_name deployment_name \
location')
self.list_ips = [
MyStruct(name='some-name',
address='1.2.3.4',
label='',
state='Created',
in_use=True,
service_name='foo',
deployment_name='bar',
location='Region')
]
self.result_list = [{
'name': 'some-name',
'address': '1.2.3.4',
'state': 'Created',
'in_use': True,
'cloud_service_name': 'foo',
'instance_name': 'bar',
'region': 'Region'
}]
MyResult = namedtuple('MyResult', 'request_id')
self.myrequest = MyResult(request_id=42)
self.reserved_ip = ReservedIp(account)
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(self.result, self.global_args['--output-format'],
self.global_args['--output-style'])
self.load_config()
self.account = AzureAccount(self.config)
if self.command_args['types']:
self.__list_instance_types()
elif self.command_args['regions']:
self.__list_locations()
elif self.command_args['show']:
self.cloud_service = CloudService(self.account)
self.__show_cloud_service_properties()
else:
self.vm = VirtualMachine(self.account)
self.cloud_service = CloudService(self.account)
if self.command_args['create']:
self.__create_cloud_service()
self.__create_instance()
elif self.command_args['delete']:
if self.command_args['--instance-name']:
self.__delete_instance()
else:
self.__delete_cloud_service()
elif self.command_args['reboot']:
self.__reboot_instance()
elif self.command_args['shutdown']:
self.__shutdown_instance()
elif self.command_args['start']:
self.__start_instance()
elif self.command_args['status']:
self.__operate_on_instance_state()
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(
self.result,
self.global_args['--output-format'],
self.global_args['--output-style']
)
self.load_config()
self.account = AzureAccount(self.config)
self.storage_account = StorageAccount(self.account)
if self.command_args['--name']:
self.validate_account_name()
if self.command_args['--description']:
self.validate_description()
if self.command_args['--label']:
self.validate_label()
if self.command_args['create']:
self.__create()
elif self.command_args['update']:
self.__update()
elif self.command_args['show']:
self.__show()
elif self.command_args['list']:
self.__list()
elif self.command_args['delete']:
self.__delete()
elif self.command_args['regions']:
self.__list_locations()
self.out.display()
def setup(self):
MyStruct = namedtuple(
'MyStruct', 'name label os category description location \
affinity_group media_link')
self.list_os_images = [
MyStruct(name='some-name',
label='bob',
os='linux',
category='cloud',
description='nice',
location='here',
affinity_group='ok',
media_link='url')
]
account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
self.service = mock.Mock()
account.get_management_service = mock.Mock(return_value=self.service)
account.get_blob_service_host_base = mock.Mock(return_value='test.url')
account.storage_key = mock.Mock()
self.account = account
self.vm = VirtualMachine(account)
self.system_config = self.vm.create_linux_configuration(
'some-user', 'some-host')
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(self.result, self.global_args['--output-format'],
self.global_args['--output-style'])
self.load_config()
self.account = AzureAccount(self.config)
request_id = format(self.command_args['--id'])
if self.command_args['status']:
self.result.add('request:' + request_id,
self.request_status(request_id))
self.out.display()
elif self.command_args['wait']:
self.request_wait(request_id)
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(
self.result,
self.global_args['--output-format'],
self.global_args['--output-style']
)
self.load_config()
self.account = AzureAccount(self.config)
self.fileshare = FileShare(self.account)
if self.command_args['list']:
self.__share_list()
elif self.command_args['create']:
self.__share_create()
elif self.command_args['delete']:
self.__share_delete()
def test_config_must_have_management_url_or_publishsettings(self):
account = AzureAccount(
Config(filename='../data/config.publishsettings_undefined'))
account.get_management_url()
class ComputeImageTask(CliTask):
"""
Process image commands
"""
def process(self):
self.manual = Help()
if self.__help():
return
self.result = DataCollector()
self.out = DataOutput(
self.result,
self.global_args['--output-format'],
self.global_args['--output-style']
)
self.load_config()
self.account = AzureAccount(self.config)
self.image = Image(self.account)
if self.command_args['list']:
self.__list()
if self.command_args['show']:
self.__show()
elif self.command_args['create']:
self.__create()
elif self.command_args['delete']:
self.__delete()
elif self.command_args['replicate']:
self.__replicate()
elif self.command_args['replication-status']:
self.__replication_status(self.command_args['--name'])
elif self.command_args['unreplicate']:
self.__unreplicate()
elif self.command_args['publish']:
self.__publish()
elif self.command_args['update']:
self.__update()
def __help(self):
if self.command_args['help']:
self.manual.show('azurectl::compute::image')
else:
return False
return self.manual
def __create(self):
request_id = self.image.create(
self.command_args['--name'],
self.command_args['--blob-name'],
self.command_args['--label'],
self.account.storage_container()
)
if self.command_args['--wait']:
self.request_wait(request_id)
self.result.add(
'image:' + self.command_args['--name'],
request_id
)
self.out.display()
def __delete(self):
request_id = self.image.delete(
self.command_args['--name'],
self.command_args['--delete-disk'],
)
if self.command_args['--wait']:
self.request_wait(request_id)
self.result.add(
'image:' + self.command_args['--name'],
request_id
)
self.out.display()
def __list(self):
self.result.add('images', self.image.list())
self.out.display()
def __show(self):
self.result.add('image', self.image.show(self.command_args['--name']))
self.out.display()
def __replicate(self):
image_name = self.command_args['--name']
request_id = self.image.replicate(
image_name,
self.command_args['--regions'].split(','),
self.command_args['--offer'],
self.command_args['--sku'],
self.command_args['--image-version']
)
self.result.add(
'replicate:' +
self.command_args['--name'] + ':' + self.command_args['--regions'],
request_id
)
if not self.command_args['--quiet']:
self.out.display()
if self.command_args['--wait']:
if not self.command_args['--quiet']:
progress = BackgroundScheduler(timezone=utc)
progress.add_job(
lambda: self.image.print_replication_status(image_name),
'interval',
minutes=5
)
progress.start()
try:
self.image.wait_for_replication_completion(image_name)
self.image.print_replication_status(image_name)
except KeyboardInterrupt:
raise SystemExit('azurectl aborted by keyboard interrupt')
finally:
progress.shutdown()
if not self.command_args['--quiet']:
print()
log.info('Replicated %s', image_name)
def __replication_status(self, image_name):
self.result.add(
'replication-status:' + image_name,
self.image.replication_status(image_name)
)
self.out.display()
def __unreplicate(self):
self.result.add(
'unreplicate:' + self.command_args['--name'],
self.image.unreplicate(
self.command_args['--name']
)
)
self.out.display()
def __publish(self):
scope = 'public'
if self.command_args['--private']:
scope = 'private'
elif self.command_args['--msdn']:
scope = 'msdn'
request_id = self.image.publish(
self.command_args['--name'], scope
)
if self.command_args['--wait']:
self.request_wait(request_id)
self.result.add(
'publish:' + self.command_args['--name'],
request_id
)
self.out.display()
def __update(self):
log.info(
'Updating image metadata for: %s', self.command_args['--name']
)
update_elements = {
'description':
self.command_args['--description'],
'eula':
self.command_args['--eula'],
'image_family':
self.command_args['--image-family'],
'icon_uri':
self.command_args['--icon-uri'],
'label':
self.command_args['--label'],
'language':
self.command_args['--language'],
'privacy_uri':
self.command_args['--privacy-uri'],
'published_date':
self.command_args['--published-date'],
'small_icon_uri':
self.command_args['--small-icon-uri'],
'recommended_vm_size':
self.command_args['--recommended-vm-size'],
'show_in_gui':
self.command_args['--show-in-gui'],
}
for name, value in update_elements.items():
if value is not None:
log.info('--> %s = %s', name, value)
self.image.update(
self.command_args['--name'], update_elements
)
def setup(self):
MyResult = namedtuple(
'MyResult',
'request_id'
)
self.myrequest = MyResult(request_id=42)
self.fake_image_name = 'some-name'
MyStruct = namedtuple(
'MyStruct',
'affinity_group category description eula icon_uri image_family \
is_premium label language location logical_size_in_gb media_link \
name os os_state pricing_detail_link privacy_uri \
published_date publisher_name recommended_vm_size show_in_gui \
small_icon_uri'
)
self.list_os_images = [MyStruct(
affinity_group='group',
category='cloud',
description='nice',
eula='eula',
icon_uri='url',
image_family='disks',
is_premium=False,
label='bob',
language='English',
location='West US',
logical_size_in_gb=30,
media_link='url',
name=self.fake_image_name,
os='linux',
os_state='brilliant',
pricing_detail_link='url',
privacy_uri='url',
published_date='date',
publisher_name='suse',
recommended_vm_size=10,
show_in_gui=True,
small_icon_uri='url'
)]
self.os_image = mock.Mock()
self.os_image.eula = 'eula'
self.os_image.description = 'description'
self.os_image.language = 'en_US'
self.os_image.image_family = 'family'
self.os_image.icon_uri = 'OpenSuse12_100.png'
self.os_image.label = 'label'
self.os_image.small_icon_uri = 'OpenSuse12_45.png'
self.os_image.published_date = '2016-01-20'
self.os_image.privacy_uri = 'http://privacy.uri'
self.os_image_updated = mock.Mock()
self.os_image_updated.eula = 'eula'
self.os_image_updated.description = 'description'
self.os_image_updated.language = 'en_US'
self.os_image_updated.image_family = 'family'
self.os_image_updated.icon_uri = 'OpenSuse12_100.png'
self.os_image_updated.label = 'label'
self.os_image_updated.small_icon_uri = 'OpenSuse12_45.png'
self.os_image_updated.published_date = '2016-01-20T00:00:00Z'
self.os_image_updated.privacy_uri = 'http://privacy.uri/'
account = AzureAccount(
Config(
region_name='East US 2', filename='../data/config'
)
)
self.service = mock.Mock()
account.get_management_service = mock.Mock(return_value=self.service)
account.get_blob_service_host_base = mock.Mock(
return_value='test.url'
)
account.storage_key = mock.Mock()
self.image = Image(account)
class TestAzureAccount:
def setup(self):
self.account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
azurectl.account.service.load_pkcs12 = mock.Mock()
def __mock_management_service(self,
endpoint,
service_response=None,
side_effect=None):
mock_service_function = mock.Mock()
if side_effect:
mock_service_function.side_effect = side_effect
else:
mock_service_function.return_value = service_response
mock_service = mock.Mock(**{endpoint: mock_service_function})
self.account.get_management_service = mock.Mock(
return_value=mock_service)
@raises(AzureServiceManagementError)
@patch('azurectl.account.service.ServiceManagementService')
@patch('azurectl.account.service.dump_privatekey')
@patch('azurectl.account.service.dump_certificate')
@patch('azurectl.account.service.AzureAccount.get_management_url')
def test_service_error(self, mock_mgmt_url, mock_dump_certificate,
mock_dump_pkey, mock_service):
mock_mgmt_url.return_value = 'test.url'
mock_dump_certificate.return_value = 'abc'
mock_dump_pkey.return_value = 'abc'
mock_service.side_effect = AzureServiceManagementError
self.account.storage_names()
def test_storage_name(self):
assert self.account.storage_name() == 'bob'
def test_storage_container(self):
assert self.account.storage_container() == 'foo'
@raises(AzureSubscriptionCertificateDecodeError)
@patch('azurectl.account.service.dump_privatekey')
@patch('azurectl.account.service.dump_certificate')
def test_subscription_cert_decode_error(self, mock_dump_certificate,
mock_dump_pkey):
mock_dump_pkey.return_value = 'abc'
mock_dump_certificate.side_effect = \
AzureSubscriptionCertificateDecodeError
self.account.get_management_service()
@raises(AzureManagementCertificateNotFound)
def test_subscription_management_cert_not_found(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_publishsettings_cert'))
account_invalid.get_management_service()
@raises(AzureSubscriptionIdNotFound)
@patch('azurectl.account.service.load_pkcs12')
@patch('azurectl.account.service.dump_privatekey')
@patch('azurectl.account.service.dump_certificate')
@patch('base64.b64decode')
def test_subscription_id_missing(self, base64_decode,
mock_dump_certificate, mock_dump_pkey,
mock_pkcs12):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_publishsettings_id'))
account_invalid.get_management_service()
def test_get_management_url(self):
mgmt_url = self.account.get_management_url()
assert mgmt_url == 'test.url'
@raises(AzureServiceManagementUrlNotFound)
def test_get_management_url_missing(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_mgmt_url'))
account_invalid.get_management_url()
@patch('azurectl.account.service.AzureAccount.get_management_url')
def test_get_blob_service_host_base(self, mock_mgmt_url):
mock_mgmt_url.return_value = 'management.test.url'
host_base = self.account.get_blob_service_host_base()
assert host_base == 'test.url'
@raises(AzureUnrecognizedManagementUrl)
@patch('azurectl.account.service.AzureAccount.get_management_url')
def test_get_blob_service_host_base_with_bad_url(self, mock_mgmt_url):
mock_mgmt_url.return_value = 'invalid.test.url'
host_base = self.account.get_blob_service_host_base()
@raises(AzureSubscriptionPKCS12DecodeError)
def test_subscription_pkcs12_error(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.corrupted_p12_cert'))
account_invalid.get_management_service()
@raises(AzureSubscriptionParseError)
def test_empty_publishsettings(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.empty_publishsettings'))
account_invalid.get_management_url()
@raises(AzureSubscriptionParseError)
def test_missing_publishsettings(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_publishsettings'))
account_invalid.get_management_url()
@patch('azurectl.account.service.dump_privatekey')
@patch('azurectl.account.service.dump_certificate')
@patch('azurectl.account.service.AzureAccount.get_management_url')
def test_publishsettings_with_multiple_subscriptions_defaults_to_first(
self, mock_mgmt_url, mock_dump_certificate, mock_dump_pkey):
account = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.multiple_subscriptions_no_id'))
assert account.subscription_id() == 'first'
@patch('azurectl.account.service.dump_privatekey')
@patch('azurectl.account.service.dump_certificate')
@patch('azurectl.account.service.AzureAccount.get_management_url')
def test_config_specifies_subscription_in_publishsettings(
self, mock_mgmt_url, mock_dump_certificate, mock_dump_pkey):
account = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.multiple_subscriptions_set_id'))
assert account.subscription_id() == 'second'
@raises(AzureSubscriptionPrivateKeyDecodeError)
def test_publishsettings_invalid_cert(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.invalid_publishsettings_cert'))
account_invalid.certificate_filename()
@raises(AzureSubscriptionIdNotFound)
def test_config_subscription_id_not_found_in_publishsettings(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_set_subscription_id'))
account_invalid.get_management_url()
@raises(AzureSubscriptionIdNotFound)
def test_config_subscription_id_missing(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.set_subscription_id_missing_id'))
account_invalid.get_management_url()
def test_config_without_publishsettings(self):
account = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.no_publishsettings'))
assert account.get_management_url() == 'test.url'
assert account.certificate_filename() == '../data/pemfile'
assert account.subscription_id() == 'id1234'
@raises(AzureConfigVariableNotFound)
def test_config_must_have_management_url_or_publishsettings(self):
account = AzureAccount(
Config(filename='../data/config.publishsettings_undefined'))
account.get_management_url()
@raises(AzureConfigVariableNotFound)
def test_config_must_have_management_pem_file_or_publishsettings(self):
account = AzureAccount(
Config(filename='../data/config.publishsettings_undefined'))
account.certificate_filename()
def test_storage_key(self):
primary = namedtuple('primary', 'primary')
keys = namedtuple('storage_service_keys', 'storage_service_keys')
self.__mock_management_service(
'get_storage_account_keys',
keys(storage_service_keys=primary(primary='foo')))
assert self.account.storage_key() == 'foo'
@raises(AzureServiceManagementError)
def test_storage_key_error(self):
self.__mock_management_service('get_storage_account_keys',
None,
side_effect=Exception)
self.account.storage_key()
@patch('azurectl.account.service.ServiceManagementService')
def test_get_management_service(self, mock_service):
self.account.subscription_id = mock.Mock()
self.account.certificate_filename = mock.Mock()
self.account.get_management_url = mock.Mock()
service = self.account.get_management_service()
assert self.account._AzureAccount__service == service
assert self.account.subscription_id.called
assert self.account.certificate_filename.called
assert self.account.get_management_url.called
@patch(
'azurectl.account.service.ServiceManagementService.list_storage_accounts'
)
def test_storage_names(self, mock_service):
names = namedtuple('service_name', 'service_name')
service_result = [names(service_name='foo')]
self.__mock_management_service('list_storage_accounts', service_result)
assert self.account.storage_names() == ['foo']
def test_instance_types(self):
# given
names = namedtuple(
'names', 'name memory_in_mb cores max_data_disk_count \
virtual_machine_resource_disk_size_in_mb')
service_result = [
names(name='foo',
memory_in_mb=1,
cores=2,
max_data_disk_count=3,
virtual_machine_resource_disk_size_in_mb=4)
]
self.__mock_management_service('list_role_sizes', service_result)
# when
x = self.account.instance_types()
# then
assert self.account.instance_types() == [{
'foo': {
'cores': 2,
'max_disk_count': 3,
'disk_size': '4MB',
'memory': '1MB'
}
}]
def test_locations(self):
# given
mock_location = mock.Mock(compute_capabilities={
'virtual_machines_role_sizes': [],
'web_worker_role_sizes': []
},
display_name=u'Mock Region',
available_services=[
u'Compute', u'Storage',
u'PersistentVMRole', u'HighMemory'
])
mock_location.configure_mock(name=u'Mock Region')
self.__mock_management_service('list_locations', [mock_location])
# when
result = self.account.locations()
# then
assert result == [u'Mock Region']
def test_filtered_locations(self):
# given
mock_location = mock.Mock(compute_capabilities={
'virtual_machines_role_sizes': [],
'web_worker_role_sizes': []
},
display_name=u'Mock Region',
available_services=[
u'Compute', u'Storage',
u'PersistentVMRole', u'HighMemory'
])
mock_location.configure_mock(name=u'Mock Region')
self.__mock_management_service('list_locations', [mock_location])
self.account.certificate_filename = mock.Mock()
# when
result = self.account.locations('Compute')
# then
assert result == [u'Mock Region']
# when
result = self.account.locations('foo')
# then
assert result == []
def test_config_subscription_id_not_found_in_publishsettings(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_set_subscription_id'))
account_invalid.get_management_url()
def setup(self):
account = AzureAccount(
Config(
region_name='East US 2', filename='../data/config'
)
)
self.service = mock.Mock()
account.get_management_service = mock.Mock(return_value=self.service)
account.get_blob_service_host_base = mock.Mock(
return_value='.blob.test.url'
)
account.storage_key = mock.Mock()
self.containers_list = ['container_a', 'container_b']
self.mock_storage_service = mock.Mock(
storage_service_keys=None,
storage_service_properties=mock.Mock(
status='Created',
account_type='Standard_GRS',
description='mock storage service',
geo_secondary_region='West US',
creation_time='2015-12-09T07:53:54Z',
geo_primary_region='East US 2',
label='mockstorageservice',
status_of_primary='Available',
location='East US 2',
affinity_group='',
last_geo_failover_time='',
status_of_secondary='Available',
endpoints=[
'https://mockstorageservice.blob.core.windows.net/',
'https://mockstorageservice.queue.core.windows.net/',
'https://mockstorageservice.table.core.windows.net/',
'https://mockstorageservice.file.core.windows.net/'
],
geo_replication_enabled='True'
),
url=(
'https://management.core.windows.net/' +
'00000000-0000-0000-0000-000000000000/services/' +
'storageservices/mockstorageservice'
),
service_name='mockstorageservice',
capabilities='None',
extended_properties={
'ResourceGroup': 'Default-Storage-EastUS2',
'ResourceLocation': 'East US 2'
},
containers=None
)
self.keyed_service = mock.Mock(
storage_service_keys=mock.Mock(
primary='1234567890abcdef==',
secondary='fedcba0987654321=='
)
)
self.expected_list_result = [{
"backup": {
"backup-region": "West US",
"backup-region-status": "Available",
"last-failover": "",
"status": "Available"
},
"backup-strategy": "--geo-redundant",
"description": "mock storage service",
"endpoints": [
"https://mockstorageservice.blob.core.windows.net/",
"https://mockstorageservice.queue.core.windows.net/",
"https://mockstorageservice.table.core.windows.net/",
"https://mockstorageservice.file.core.windows.net/"
],
"label": "mockstorageservice",
"name": "mockstorageservice",
"region": "East US 2",
"status": "Created"
}]
self.expected_show_result = {
"backup": {
"backup-region": "West US",
"backup-region-status": "Available",
"last-failover": "",
"status": "Available"
},
"backup-strategy": "--geo-redundant",
"containers": self.containers_list,
"description": "mock storage service",
"endpoints": [
"https://mockstorageservice.blob.core.windows.net/",
"https://mockstorageservice.queue.core.windows.net/",
"https://mockstorageservice.table.core.windows.net/",
"https://mockstorageservice.file.core.windows.net/"
],
"keys": {
"primary": self.keyed_service.storage_service_keys.primary,
"secondary": self.keyed_service.storage_service_keys.secondary
},
"label": "mockstorageservice",
"name": "mockstorageservice",
"region": "East US 2",
"status": "Created"
}
self.my_request = mock.Mock(request_id=Defaults.unify_id(42))
self.storage_account = StorageAccount(account)
def test_get_management_url_missing(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_mgmt_url'))
account_invalid.get_management_url()
def setup(self):
self.account = AzureAccount(
Config(region_name='East US 2', filename='../data/config'))
azurectl.account.service.load_pkcs12 = mock.Mock()
def test_subscription_management_cert_not_found(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.missing_publishsettings_cert'))
account_invalid.get_management_service()
def test_config_must_have_management_pem_file_or_publishsettings(self):
account = AzureAccount(
Config(filename='../data/config.publishsettings_undefined'))
account.certificate_filename()
def test_config_subscription_id_missing(self):
account_invalid = AzureAccount(
Config(region_name='East US 2',
filename='../data/config.set_subscription_id_missing_id'))
account_invalid.get_management_url()
