def load_config(self):
self.config = Config(self.global_args['--account'],
self.global_args['--region'],
self.global_args['--storage-account'],
self.global_args['--storage-container'],
self.global_args['--config'])
self.config_file = self.config.config_file
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 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 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 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 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):
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 __check_account_existing_in_default_config(self):
default_config = None
try:
default_config = Config()
except Exception:
# ignore exception thrown if no config file exists
pass
if default_config:
account_section_name = 'account:' + self.command_args['--name']
if default_config.config.has_section(account_section_name):
raise AzureAccountConfigurationError(
'Account %s already configured in file %s' % (
self.command_args['--name'],
Config.get_config_file()
)
)
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 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 test_parse_error(self):
Config(filename='../data/config_parse_error')
def test_account_not_present(self):
Config(filename='../data/config.no_account')
def setup(self):
self.config = Config(region_name='East US 2',
filename='../data/config')
def test_get_region_name_with_region_arg_but_no_config(self):
expected = 'Foo Test Region'
result = Config(region_name=expected,
filename='../data/config.no_region').get_region_name()
assert result == expected
def test_config_must_have_management_url_or_publishsettings(self):
account = AzureAccount(
Config(filename='../data/config.publishsettings_undefined'))
account.get_management_url()
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)
def test_default_config_file_not_found(self, mock_isfile):
mock_isfile.return_value = False
Config()
def test_get_publishsettings_file_name_missing(self):
config = Config(region_name='East US 2',
filename='../data/config.missing_region_data')
config.get_storage_account_name()
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_account_name_not_found(self, mock_isfile):
mock_isfile.return_value = False
Config(account_name='account-name')
def test_account_section_not_found(self):
Config(filename='../data/config.invalid_account')
def test_config_file_not_found(self, mock_isfile):
mock_isfile.return_value = False
Config(filename="does-not-exist")
def test_region_section_not_found(self):
Config(filename='../data/config.invalid_region'
).get_storage_account_name()
def test_no_default_section_in_config(self):
Config(region_name='East US 2', filename='../data/config.no_default')
def test_region_not_present(self):
Config(filename='../data/config.no_region').get_storage_account_name()
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_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()
