class TestConfigurationDomainGraphics(CloubedTestCase):
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_parse_graphics_ok(self):
"""
ConfigurationDomain.__parse_graphics() should properly set graphics
attribute
"""
conf = { 'graphics': 'vnc' }
self.domain_conf._ConfigurationDomain__parse_graphics(conf)
self.assertEqual(self.domain_conf.graphics, 'vnc')
conf = { } # default is spice if controller supports else it is vnc
self.domain_conf._ConfigurationDomain__parse_graphics(conf)
if VirtController.supports_spice():
self.assertEqual(self.domain_conf.graphics, 'spice')
else:
self.assertEqual(self.domain_conf.graphics, 'vnc')
def test_parse_graphics_invalid_format(self):
"""
ConfigurationDomain.__parse_graphics() should raise
CloubedConfigurationException when invalid graphics format is given
in parameter
"""
invalid_graphics = [ { 'graphics': 4 },
{ 'graphics': {} },
{ 'graphics': [] },
{ 'graphics': None } ]
for graphics in invalid_graphics:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of graphics parameter of domain test_name is not " \
"valid",
self.domain_conf._ConfigurationDomain__parse_graphics,
graphics)
def test_parse_graphics_invalid_value(self):
"""
ConfigurationDomain.__parse_graphics() should raise
CloubedConfigurationException when invalid graphics choice is given
in parameter
"""
invalid_graphics = { 'graphics': 'nonexisting_graphics' }
self.assertRaisesRegexp(
CloubedConfigurationException,
"value nonexisting_graphics of graphics parameter of domain " \
"test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_graphics,
invalid_graphics)
class TestConfigurationDomainCdrom(CloubedTestCase):
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_parse_cdrom_ok(self):
"""
ConfigurationDomain.__parse_cdrom() should properly set cdrom
attribute
"""
conf = { 'cdrom': '/file.iso' } # absolute path
self.domain_conf._ConfigurationDomain__parse_cdrom(conf)
self.assertEqual(self.domain_conf.cdrom, '/file.iso')
conf = { 'cdrom': 'file.iso' } # relative path
self.domain_conf._ConfigurationDomain__parse_cdrom(conf)
self.assertEqual(self.domain_conf.cdrom,
os.path.join(os.getcwd(), 'file.iso') )
conf = { } # default is None
self.domain_conf._ConfigurationDomain__parse_cdrom(conf)
self.assertEqual(self.domain_conf.cdrom, None)
def test_parse_cdrom_invalid_format(self):
"""
ConfigurationDomain.__parse_cdrom() should raise
CloubedConfigurationException when invalid cdrom format is given
in parameter
"""
invalid_cdroms = [ { 'cdrom': 4 },
{ 'cdrom': {} },
{ 'cdrom': [] },
{ 'cdrom': None } ]
for cdrom in invalid_cdroms:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of cdrom parameter of domain test_name is not " \
"valid",
self.domain_conf._ConfigurationDomain__parse_cdrom,
cdrom)
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
class TestConfigurationDomainCpu(CloubedTestCase):
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_parse_cpu_topology(self):
"""
ConfigurationDomain.__parse_cpu() should properly parse topology
"""
config = { 'cpu': '2x3x4' }
self.domain_conf._ConfigurationDomain__parse_cpu(config)
self.assertEquals(self.domain_conf.sockets, 2)
self.assertEquals(self.domain_conf.cores, 3)
self.assertEquals(self.domain_conf.threads, 4)
def test_parse_cpu_missing(self):
"""
ConfigurationDomain.__parse_cpu() should raise
CloubedConfigurationException when the cpu parameter is missing
"""
invalid_config = { }
self.assertRaisesRegexp(
CloubedConfigurationException,
"cpu parameter of domain test_name is missing",
self.domain_conf._ConfigurationDomain__parse_cpu,
invalid_config)
def test_parse_cpu_invalid(self):
"""
ConfigurationDomain.__parse_cpu() should raise
CloubedConfigurationException when invalid cpu if given in
parameter
"""
invalid_configs = [ { 'cpu': [] },
{ 'cpu': {} },
{ 'cpu': None } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of cpu parameter of domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_cpu,
invalid_config)
def test_parse_cpu_invalid_topology(self):
"""
ConfigurationDomain.__parse_cpu() should raise
CloubedConfigurationException when invalid cpu topology
is given
"""
invalid_configs = [ { 'cpu': 'fail' },
{ 'cpu': '2x3' },
{ 'cpu': '1xfailx3' },
{ 'cpu': '2x5x3x4' } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of cpu topology of domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_cpu,
invalid_config)
class TestConfigurationDomainTemplates(CloubedTestCase):
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_parse_templates_ok(self):
"""
ConfigurationDomain.__parse_templates() should parse valid values
without errors and set appropriate instance attributes
"""
conf = { 'templates':
{ 'files': [ { 'name': 'test_template_file_name',
'input': 'test_template_file_input',
'output': 'test_template_file_output' } ],
'vars': { 'var_name': 'var_value' } } }
self.domain_conf._ConfigurationDomain__parse_templates(conf)
self.assertEquals(len(self.domain_conf.template_files), 1)
self.assertDictContainsSubset(
{'domain.test_name.name': 'test_name'},
self.domain_conf.get_absolute_templates_dict())
self.assertDictContainsSubset(
{'self.name': 'test_name'},
self.domain_conf.get_contextual_templates_dict())
conf = { 'templates': {} }
self.domain_conf._ConfigurationDomain__parse_templates(conf)
self.assertEqual(self.domain_conf.template_files, [])
self.assertEqual(self.domain_conf._template_vars, {})
def test_parse_templates_invalid_files_format(self):
"""
ConfigurationDomain.__parse_templates() should raise
CloubedConfigurationException if the format of the files section is
not valid
"""
invalid_conf = { 'templates': { 'files': 42 } }
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of the files sub-section in the templates section " \
"of domain test_name templates is not valid",
self.domain_conf._ConfigurationDomain__parse_templates,
invalid_conf)
def test_parse_templates_files_missing_attribute(self):
"""
ConfigurationDomain.__parse_templates() should raise
CloubedConfigurationException if one required attribute of a
template file is missing
"""
invalid_conf = { 'templates':
{ 'files': [ { 'name': 'test_template_file_name',
'output': 'test_template_file_output' } ] } }
self.assertRaisesRegexp(
CloubedConfigurationException,
"input parameter of a template file of domain test_name " \
"is missing",
self.domain_conf._ConfigurationDomain__parse_templates,
invalid_conf)
def test_parse_templates_files_attribute_invalid_format(self):
"""
ConfigurationDomain.__parse_templates() should raise
CloubedConfigurationException if the format of one attribute of a
template file is invalid
"""
invalid_conf = { 'templates':
{ 'files': [ { 'name': 'test_template_file_name',
'input': 42,
'output': 'test_template_file_output' } ] } }
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of input parameter of a template file of domain " \
"test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_templates,
invalid_conf)
def test_parse_templates_invalid_vars_format(self):
"""
ConfigurationDomain.__parse_templates() should raise
CloubedConfigurationException if the format of the vars section is
not valid
"""
invalid_conf = { 'templates':
{ 'vars': 42 } }
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of the vars sub-section in the templates section of " \
"domain test_name templates is not valid",
self.domain_conf._ConfigurationDomain__parse_templates,
invalid_conf)
def test_parse_templates_vars_attribute_invalid_format(self):
"""
ConfigurationDomain.__parse_templates() should raise
CloubedConfigurationException if the format of one attribute of a
template file is invalid
"""
invalid_conf = { 'templates':
{ 'vars': { 'test_var_name': [] } } }
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of the value of test_var_name template variable of " \
"domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_templates,
invalid_conf)
class TestConfigurationDomainVirtfs(CloubedTestCase):
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_parse_virtfs_missing(self):
"""
ConfigurationDomain.__parse_virtfs() should properly set virtfs
attribute
"""
conf = { 'virtfs': [ { 'source': '/test_source', 'target': 'test_target' } ] }
self.domain_conf._ConfigurationDomain__parse_virtfs(conf)
self.assertEqual(self.domain_conf.virtfs[0]['source'], '/test_source')
self.assertEqual(self.domain_conf.virtfs[0]['target'], 'test_target')
# source is a relative path
conf = { 'virtfs': [ { 'source': 'test_source2', 'target': 'test_target2' } ] }
self.domain_conf._ConfigurationDomain__parse_virtfs(conf)
self.assertEqual(self.domain_conf.virtfs[0]['source'],
os.path.join(os.getcwd(), 'test_source2'))
self.assertEqual(self.domain_conf.virtfs[0]['target'], 'test_target2')
conf = { 'virtfs': [ { 'source': '/test_source3' } ] }
self.domain_conf._ConfigurationDomain__parse_virtfs(conf)
self.assertEqual(self.domain_conf.virtfs[0]['source'], '/test_source3')
self.assertEqual(self.domain_conf.virtfs[0]['target'], '/test_source3')
conf = { }
self.domain_conf._ConfigurationDomain__parse_virtfs(conf)
self.assertEqual(self.domain_conf.virtfs, [])
def test_parse_virtfs_invalid_format(self):
"""
ConfigurationDomain.__parse_virtfs() should raise
CloubedConfigurationException when invalid virtfs format is given
in parameter
"""
invalid_configs = [ { 'virtfs': 'invalid_virtfs' },
{ 'virtfs': {} },
{ 'virtfs': 42 },
{ 'virtfs': None } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of virtfs section of domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_virtfs,
invalid_config)
def test_parse_virtfs_invalid_format_2(self):
"""
ConfigurationDomain.__parse_virtfs() should raise
CloubedConfigurationException when invalid virtfs format is given
in parameter
"""
invalid_configs = [ { 'virtfs': [ 'invalid_virtfs' ] },
{ 'virtfs': [ None ] },
{ 'virtfs': [ 0, 42 ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of virtfs 0 of domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_virtfs,
invalid_config)
def test_parse_virtfs_missing_source(self):
"""
ConfigurationDomain.__parse_virtfs() should raise
CloubedConfigurationException when virtfs in parameter does not have
any source
"""
invalid_configs = [ { 'virtfs': [ { } ] },
{ 'virtfs': [ { 'no' : 'source' } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"source of virtfs 0 of domain test_name is missing",
self.domain_conf._ConfigurationDomain__parse_virtfs,
invalid_config)
def test_parse_virtfs_invalid_source(self):
"""
ConfigurationDomain.__parse_virtfs() should raise
CloubedConfigurationException when virtfs in parameter has an
invalid source
"""
invalid_configs = [ { 'virtfs': [ { 'source': None } ] },
{ 'virtfs': [ { 'source': 42 } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of source of virtfs 0 of domain test_name is " \
"not valid",
self.domain_conf._ConfigurationDomain__parse_virtfs,
invalid_config)
def test_parse_disks_invalid_target(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when disks in parameter have invalid
storage volume
"""
invalid_configs = [ { 'virtfs': [ { 'source': 'test_source',
'target': None } ] },
{ 'virtfs': [ { 'source': 'test_source',
'target': 42 } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of target of virtfs 0 of domain test_name is " \
"not valid",
self.domain_conf._ConfigurationDomain__parse_virtfs,
invalid_config)
class TestConfigurationDomainDisks(CloubedTestCase):
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_parse_disks_ok(self):
"""
ConfigurationDomain.__parse_disks() should properly parse disks
when the disks section is OK
"""
config = { 'disks': [ { 'device': 'test_device',
'storage_volume': 'test_storage_volume' },
{ 'device': 'test_device',
'name': 'test_name1',
'size': 30 },
{ 'device': 'test_device',
'name': 'test_name2',
'storagepool': 'test_storage_pool',
'size': 30 },
{ 'device': 'test_device',
'name': 'test_name3',
'size': 30,
'storagepool': 'test_storage_pool',
'type': 'qcow2' },
{ 'device': 'test_device',
'name': 'test_name4',
'size': 30,
'storagepool': 'test_storage_pool',
'type': 'qcow2',
'backing': 'test_backing' } ] }
self.domain_conf._ConfigurationDomain__parse_disks(config)
self.assertEqual(self.domain_conf.disks[0]['device'], 'test_device')
self.assertEqual(self.domain_conf.disks[0]['storage_volume'], 'test_storage_volume')
self.assertEqual(self.domain_conf.disks[1]['storage_volume'], 'test_name1')
self.assertEqual(self.domain_conf.disks[2]['storage_volume'], 'test_name2')
self.assertEqual(self.domain_conf.disks[3]['storage_volume'], 'test_name3')
self.assertEqual(self.domain_conf.disks[4]['storage_volume'], 'test_name4')
def test_parse_disks_missing(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when the disks section is missing
"""
invalid_config = { }
self.assertRaisesRegexp(
CloubedConfigurationException,
"disks section of domain test_name is missing",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_invalid_format(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when invalid disks format is given
in parameter
"""
invalid_configs = [ { 'disks': 'invalid_disk' },
{ 'disks': {} },
{ 'disks': 42 },
{ 'disks': None } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of disks section of domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_invalid_format_2(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when invalid disks format is given
in parameter
"""
invalid_configs = [ { 'disks': [ 'invalid_disk' ] },
{ 'disks': [ None ] },
{ 'disks': [ 0, 42 ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of disk 0 of domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_missing_device(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when disks in parameter have not any
device
"""
invalid_configs = [ { 'disks': [ { } ] },
{ 'disks': [ { 'epic' : 'fail' } ] },
{ 'disks': [ { 'storage_volume' : 'test_storage_volume' } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"device of disk 0 of domain test_name is missing",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_invalid_device(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when disks in parameter have invalid
device
"""
invalid_configs = [ { 'disks': [ { 'device': None } ] },
{ 'disks': [ { 'device': 42 } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of device of disk 0 of domain test_name is not " \
"valid",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_bus_ok(self):
"""
ConfigurationDomain.__parse_disks() should properly set disk bus
attribute
"""
conf = { 'disks': [ { 'device': 'test_device',
'bus': 'scsi',
'storage_volume': 'test_storage_volume' } ] }
self.domain_conf._ConfigurationDomain__parse_disks(conf)
self.assertEqual(self.domain_conf.disks,
conf['disks'])
# test default bus is virtio
conf['disks'][0].pop('bus', None)
self.domain_conf._ConfigurationDomain__parse_disks(conf)
conf['disks'][0]['bus'] = 'virtio'
self.assertEqual(self.domain_conf.disks,
conf['disks'])
def test_parse_disks_bus_invalid_format(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException if the format of bus parameter of one
disk is not valid
"""
invalid_configs = [ { 'disks': [ { 'device': 'test_device',
'bus': 42 } ] },
{ 'disks': [ { 'device': 'test_device',
'bus': None } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of bus of disk 0 of domain test_name " \
"is not valid",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_bus_invalid_value(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException if the value of bus parameter of one
disk is not valid
"""
invalid_config = { 'disks': [ { 'device': 'test_device',
'bus': 'fail' } ] }
self.assertRaisesRegexp(
CloubedConfigurationException,
"value fail of bus of disk 0 of domain test_name " \
"is not valid",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_missing_storage_volume_name(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when disks in parameter have not any
storage volume or name
"""
invalid_configs = [ { 'disks': [ { 'device': 'test_device' } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"storage_volume or name parameters of disk 0 of domain " \
"test_name are missing",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_conflict_storage_volume_name(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when disks in parameter have
conflicting storage volume and name
"""
invalid_configs = [ { 'disks': [ { 'device': 'test_device',
'storage_volume': 'test_storage_volume',
'name': 'test_name' } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"storage_volume and name parameters of disk 0 of domain "\
"test_name are conflicting",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_invalid_storage_volume_name(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when disks in parameter have invalid
storage volume name
"""
invalid_configs = [ { 'disks': [ { 'device': 'test_device',
'storage_volume': None } ] },
{ 'disks': [ { 'device': 'test_device',
'storage_volume': 42 } ] } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of storage_volume parameter of disk 0 of domain " \
"test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
def test_parse_disks_invalid_storage_volume_item(self):
"""
ConfigurationDomain.__parse_disks() should raise
CloubedConfigurationException when disks in parameter have invalid
storage volume item
"""
invalid_configs = [ { 'disks': [ { 'device': 'test_device',
'name': 'test_name' } ] },
{ 'disks': [ { 'device': 'test_device',
'name': None,
'size': 42 } ] },
{ 'disks': [ { 'device': 'test_device',
'name': 'test_name',
'size': 'fail' } ] } ]
for invalid_config in invalid_configs:
self.assertRaises(
CloubedConfigurationException,
self.domain_conf._ConfigurationDomain__parse_disks,
invalid_config)
class TestConfigurationDomain(CloubedTestCase):
""" Test all accessors against valid and basic domain dict """
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_get_type(self):
"""
ConfigurationDomain._get_type() should return domain
"""
self.assertEqual(self.domain_conf._get_type(), 'domain')
def test_attr_cpu(self):
"""
ConfigurationDomain.cores should be the cpu of the domain
"""
self.assertEqual(self.domain_conf.sockets, 1)
self.assertEqual(self.domain_conf.cores, 2)
self.assertEqual(self.domain_conf.threads, 1)
def test_attr_memory(self):
"""
ConfigurationDomain.memory should be the memory size of the domain
(in MB)
"""
self.assertEqual(self.domain_conf.memory,
1024)
def test_attr_template_files(self):
"""
ConfigurationDomain.template_files should be the list of templates
of the domain
"""
self.assertEqual(self.domain_conf.template_files,
[])
def test_attr_netifs(self):
"""
ConfigurationDomain.netifs should be the list of netifs of the
domain
"""
self.assertEqual(self.domain_conf.netifs,
[{ 'network': 'test_netif', 'ip': '10.0.0.1' }])
def test_attr_disks(self):
"""
ConfigurationDomain.disks should be a list with all disks of
the domain
"""
self.assertEqual(self.domain_conf.disks,
[{ 'device': 'test_device',
'storage_volume': 'test_storage_volume',
'bus': 'virtio' }])
def test_attr_virtfs(self):
"""
ConfigurationDomain.virtf should be a list with all virtfs of the
domain
"""
self.assertEqual(self.domain_conf.virtfs,
[{ 'source': '/test_source', 'target': 'test_target' }])
class TestConfigurationDomainMemory(CloubedTestCase):
def setUp(self):
self._domain_item = valid_domain_item
self._loader = MockConfigurationLoader(conf_minimal)
self.conf = Configuration(self._loader)
self.domain_conf = ConfigurationDomain(self.conf, self._domain_item)
def test_parse_memory_ok(self):
"""
ConfigurationDomain.__parse_memory() should convert valid memory in
parameter into an integer representing the number of MB
"""
valid_memories = { '1GB' : 1024,
2 : 2048,
'512M' : 512,
'512MB' : 512,
'512MiB': 512,
'512 M' : 512 }
for memory, expected_value in valid_memories.iteritems():
config = { 'memory': memory }
self.domain_conf._ConfigurationDomain__parse_memory(config)
self.assertEqual(self.domain_conf.memory,
expected_value)
def test_parse_memory_missing(self):
"""
ConfigurationDomain.__parse_memory() should raise
CloubedConfigurationException when the memory parameter is missing
"""
invalid_config = { }
self.assertRaisesRegexp(
CloubedConfigurationException,
"memory parameter of domain test_name is missing",
self.domain_conf._ConfigurationDomain__parse_memory,
invalid_config)
def test_parse_memory_invalid_format(self):
"""
ConfigurationDomain.__parse_memory() should raise
CloubedConfigurationException when the format of the memory given
in parameter is not valid
"""
invalid_configs = [ { 'memory': {} },
{ 'memory': None } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"format of memory parameter of domain test_name is not " \
"valid",
self.domain_conf._ConfigurationDomain__parse_memory,
invalid_config)
def test_parse_memory_invalid_str(self):
"""
ConfigurationDomain.__parse_memory() should raise
CloubedConfigurationException when the format of the memory string
given in parameter is not valid
"""
invalid_configs = [ { 'memory': 'b32' },
{ 'memory': 'x' } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"memory size '.*' of domain test_name is not valid",
self.domain_conf._ConfigurationDomain__parse_memory,
invalid_config)
def test_parse_memory_invalid_unit(self):
"""
ConfigurationDomain.__parse_memory() should raise
CloubedConfigurationException when the unit in the memory string
given in parameter is not valid
"""
invalid_configs = [ { 'memory': '1TB' },
{ 'memory': '1K' },
{ 'memory': '1m' },
{ 'memory': '1Mo' } ]
for invalid_config in invalid_configs:
self.assertRaisesRegexp(
CloubedConfigurationException,
"unknown unit for memory '.*' of domain test_name",
self.domain_conf._ConfigurationDomain__parse_memory,
invalid_config)
