class TestLan(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, self.datacenter, 'create_datacenter')
# Create test LAN.
self.lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
wait_for_completion(self.client, self.lan, 'create_lan')
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
wait_for_completion(self.client, self.server, 'create_server')
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
wait_for_completion(self.client, self.nic1, 'create_nic1')
# Create test NIC2.
nic2 = NIC(**self.resource['nic'])
nic2.lan = self.lan['id']
self.nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic2)
wait_for_completion(self.client, self.nic2, 'create_nic2')
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
class TestLan(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test LAN.
self.lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
self.client.wait_for_completion(self.lan)
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(self.server)
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
self.client.wait_for_completion(self.nic1)
# Create test NIC2.
nic2 = NIC(**self.resource['nic'])
nic2.lan = self.lan['id']
self.nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic2)
self.client.wait_for_completion(self.nic2)
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_lans(self):
lans = self.client.list_lans(datacenter_id=self.datacenter['id'])
self.assertGreater(len(lans), 0)
self.assertEqual(lans['items'][0]['type'], 'lan')
self.assertIn(lans['items'][0]['id'], ('1', '2', '3'))
self.assertEqual(lans['items'][0]['properties']['name'], self.resource['lan']['name'])
self.assertTrue(lans['items'][0]['properties']['public'], self.resource['lan']['public'])
def test_get_lan(self):
lan = self.client.get_lan(datacenter_id=self.datacenter['id'], lan_id=self.lan['id'])
self.assertEqual(lan['type'], 'lan')
self.assertEqual(lan['id'], self.lan['id'])
self.assertEqual(lan['properties']['name'], self.resource['lan']['name'])
self.assertTrue(lan['properties']['public'], self.resource['lan']['public'])
def test_remove_lan(self):
lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
self.client.wait_for_completion(lan)
lan = self.client.delete_lan(datacenter_id=self.datacenter['id'], lan_id=lan['id'])
self.assertTrue(lan)
def test_update_lan(self):
lan = self.client.update_lan(
datacenter_id=self.datacenter['id'],
lan_id=self.lan['id'],
name=self.resource['lan']['name'] + ' - RENAME',
public=False)
self.assertEqual(lan['type'], 'lan')
self.assertEqual(lan['properties']['name'], self.resource['lan']['name'] + ' - RENAME')
self.assertFalse(lan['properties']['public'])
def test_create_lan(self):
self.assertEqual(self.lan['id'], '1')
self.assertEqual(self.lan['type'], 'lan')
self.assertEqual(self.lan['properties']['name'], self.resource['lan']['name'])
self.assertEqual(self.lan['properties']['public'], self.resource['lan']['public'])
def test_create_complex_lan(self):
resource = NIC(**self.resource['nic'])
nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=resource)
self.client.wait_for_completion(nic1)
self.assertFalse(nic1['properties']['nat'])
self.assertEqual(nic1['properties']['name'], 'Python SDK Test')
self.assertTrue(nic1['properties']['dhcp'])
self.assertEqual(nic1['properties']['lan'], 1)
self.assertTrue(nic1['properties']['firewallActive'])
nics = [nic1['id']]
lan = LAN(nics=nics, **self.resource['lan'])
response = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=lan)
self.client.wait_for_completion(response)
self.assertEqual(response['type'], 'lan')
self.assertEqual(response['properties']['name'], self.resource['lan']['name'])
self.assertTrue(response['properties']['public'])
def test_get_lan_members(self):
members = self.client.get_lan_members(
datacenter_id=self.datacenter['id'],
lan_id=self.lan['id'])
self.assertGreater(len(members), 0)
self.assertEqual(members['items'][0]['type'], 'nic')
self.assertEqual(members['items'][0]['properties']['name'], self.resource['nic']['name'])
assertRegex(self, members['items'][0]['properties']['mac'], self.resource['mac_match'])
def test_get_failure(self):
try:
self.client.get_lan(datacenter_id=self.datacenter['id'], lan_id=0)
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
def test_create_failure(self):
try:
self.client.create_lan(
datacenter_id='00000000-0000-0000-0000-000000000000', lan=LAN())
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
class TestDatacenter(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list(self):
datacenters = self.client.list_datacenters()
self.assertGreater(len(datacenters), 0)
self.assertEqual(datacenters['items'][0]['type'], 'datacenter')
def test_get(self):
datacenter = self.client.get_datacenter(
datacenter_id=self.datacenter['id'])
assertRegex(self, datacenter['id'], self.resource['uuid_match'])
self.assertEqual(datacenter['type'], 'datacenter')
self.assertEqual(datacenter['id'], self.datacenter['id'])
self.assertEqual(datacenter['properties']['name'], self.resource['datacenter']['name'])
self.assertEqual(datacenter['properties']['description'], self.resource['datacenter']['description'])
self.assertEqual(datacenter['properties']['location'], self.resource['datacenter']['location'])
def test_delete(self):
datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, datacenter, 'create_datacenter')
response = self.client.delete_datacenter(
datacenter_id=datacenter['id'])
self.assertTrue(response)
def test_update(self):
datacenter = self.client.update_datacenter(
datacenter_id=self.datacenter['id'],
description=self.resource['datacenter']['name']+' - RENAME')
wait_for_completion(self.client, datacenter, 'update_datacenter')
datacenter = self.client.get_datacenter(datacenter_id=self.datacenter['id'])
assertRegex(self, datacenter['id'], self.resource['uuid_match'])
self.assertEqual(datacenter['id'], self.datacenter['id'])
self.assertEqual(datacenter['properties']['name'], self.resource['datacenter']['name'])
self.assertEqual(datacenter['properties']['description'], self.resource['datacenter']['name']+' - RENAME')
self.assertEqual(datacenter['properties']['location'], self.resource['datacenter']['location'])
self.assertGreater(datacenter['properties']['version'], 1)
def test_create_simple(self):
datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, datacenter, 'create_datacenter')
assertRegex(self, datacenter['id'], self.resource['uuid_match'])
self.assertEqual(datacenter['properties']['name'], self.resource['datacenter']['name'])
self.assertEqual(datacenter['properties']['description'], self.resource['datacenter']['description'])
self.assertEqual(datacenter['properties']['location'], self.resource['datacenter']['location'])
response = self.client.delete_datacenter(
datacenter_id=datacenter['id'])
self.assertTrue(response)
class TestVolume(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, self.datacenter, 'create_datacenter')
# Create test volume
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
wait_for_completion(self.client, self.volume, 'create_volume')
# Create snapshot1
self.snapshot1 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'],
description=self.resource['snapshot']['description'])
wait_for_completion(self.client, self.snapshot1, 'create_snapshot1',
wait_timeout=600)
# Create snapshot2 (used in delete test)
self.snapshot2 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'],
description=self.resource['snapshot']['description'])
wait_for_completion(self.client, self.snapshot2, 'create_snapshop2',
wait_timeout=600)
self.image = find_image(self.client, configuration.IMAGE_NAME)
@classmethod
def tearDownClass(self):
self.client.remove_snapshot(snapshot_id=self.snapshot1['id'])
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_volumes(self):
volumes = self.client.list_volumes(
datacenter_id=self.datacenter['id'])
self.assertGreater(len(volumes), 0)
assertRegex(self, volumes['items'][0]['id'], self.resource['uuid_match'])
self.assertEqual(volumes['items'][0]['type'], 'volume')
self.assertEqual(volumes['items'][0]['properties']['name'], self.resource['volume']['name'])
self.assertEqual(volumes['items'][0]['properties']['size'], self.resource['volume']['size'])
self.assertEqual(volumes['items'][0]['properties']['licenceType'], self.resource['volume']['licence_type'])
self.assertEqual(volumes['items'][0]['properties']['type'], self.resource['volume']['type'])
self.assertFalse(volumes['items'][0]['properties']['cpuHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['cpuHotUnplug'])
self.assertFalse(volumes['items'][0]['properties']['ramHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['ramHotUnplug'])
self.assertFalse(volumes['items'][0]['properties']['nicHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['nicHotUnplug'])
self.assertFalse(volumes['items'][0]['properties']['discVirtioHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['discVirtioHotUnplug'])
self.assertFalse(volumes['items'][0]['properties']['discScsiHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['discScsiHotUnplug'])
self.assertIsNone(volumes['items'][0]['properties']['bus'])
def test_get_volume(self):
volume = self.client.get_volume(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'])
self.assertEqual(volume['id'], self.volume['id'])
self.assertEqual(volume['type'], 'volume')
self.assertEqual(volume['properties']['name'], self.resource['volume']['name'])
self.assertEqual(volume['properties']['size'], self.resource['volume']['size'])
self.assertEqual(volume['properties']['licenceType'], self.resource['volume']['licence_type'])
self.assertEqual(volume['properties']['type'], self.resource['volume']['type'])
self.assertFalse(volume['properties']['cpuHotPlug'])
self.assertFalse(volume['properties']['cpuHotUnplug'])
self.assertFalse(volume['properties']['ramHotPlug'])
self.assertFalse(volume['properties']['ramHotUnplug'])
self.assertFalse(volume['properties']['nicHotPlug'])
self.assertFalse(volume['properties']['nicHotUnplug'])
self.assertFalse(volume['properties']['discVirtioHotPlug'])
self.assertFalse(volume['properties']['discVirtioHotUnplug'])
self.assertFalse(volume['properties']['discScsiHotPlug'])
self.assertFalse(volume['properties']['discScsiHotUnplug'])
self.assertIsNone(volume['properties']['bus'])
def test_delete_volume(self):
volume = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
wait_for_completion(self.client, volume, 'create_volume')
volume = self.client.delete_volume(
datacenter_id=self.datacenter['id'],
volume_id=volume['id'])
self.assertTrue(volume)
def test_update_volume(self):
volume = self.client.update_volume(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
size=6,
name=self.resource['volume']['name'] + ' RENAME')
wait_for_completion(self.client, volume, 'update_volume')
volume = self.client.get_volume(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'])
self.assertEqual(volume['id'], self.volume['id'])
self.assertEqual(volume['properties']['name'], self.resource['volume']['name'] + ' RENAME')
self.assertEqual(volume['properties']['size'], 6)
def test_create_volume(self):
# Use volume created during volume test setup.
self.assertEqual(self.volume['properties']['name'], self.resource['volume']['name'])
self.assertEqual(self.volume['properties']['bus'], self.resource['volume']['bus'])
self.assertEqual(self.volume['properties']['type'], self.resource['volume']['type'])
self.assertEqual(self.volume['properties']['size'], self.resource['volume']['size'])
self.assertEqual(self.volume['properties']['licenceType'], self.resource['volume']['licence_type'])
self.assertFalse(self.volume['properties']['cpuHotPlug'])
self.assertFalse(self.volume['properties']['cpuHotUnplug'])
self.assertFalse(self.volume['properties']['ramHotPlug'])
self.assertFalse(self.volume['properties']['ramHotUnplug'])
self.assertFalse(self.volume['properties']['nicHotPlug'])
self.assertFalse(self.volume['properties']['nicHotUnplug'])
self.assertFalse(self.volume['properties']['discVirtioHotPlug'])
self.assertFalse(self.volume['properties']['discVirtioHotUnplug'])
self.assertFalse(self.volume['properties']['discScsiHotPlug'])
self.assertFalse(self.volume['properties']['discScsiHotUnplug'])
def test_create_snapshot(self):
# Use snapshot created during volume test setup.
assertRegex(self, self.snapshot1['id'], self.resource['uuid_match'])
self.assertEqual(self.snapshot1['type'], 'snapshot')
self.assertEqual(self.snapshot1['properties']['name'], self.resource['snapshot']['name'])
self.assertEqual(self.snapshot1['properties']['description'], self.resource['snapshot']['description'])
self.assertEqual(self.snapshot1['properties']['location'], configuration.LOCATION)
self.assertFalse(self.snapshot1['properties']['cpuHotPlug'])
self.assertFalse(self.snapshot1['properties']['cpuHotUnplug'])
self.assertFalse(self.snapshot1['properties']['ramHotPlug'])
self.assertFalse(self.snapshot1['properties']['ramHotUnplug'])
self.assertFalse(self.snapshot1['properties']['nicHotPlug'])
self.assertFalse(self.snapshot1['properties']['nicHotUnplug'])
self.assertFalse(self.snapshot1['properties']['discVirtioHotPlug'])
self.assertFalse(self.snapshot1['properties']['discVirtioHotUnplug'])
self.assertFalse(self.snapshot1['properties']['discScsiHotPlug'])
self.assertFalse(self.snapshot1['properties']['discScsiHotUnplug'])
self.assertIsNone(self.snapshot1['properties']['size'])
self.assertIsNone(self.snapshot1['properties']['licenceType'])
def test_restore_snapshot(self):
response = self.client.restore_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
snapshot_id=self.snapshot1['id'])
self.assertTrue(response)
def test_remove_snapshot(self):
volume = self.client.remove_snapshot(snapshot_id=self.snapshot2['id'])
self.assertTrue(volume)
def test_create_volume_failure(self):
with self.assertRaises(Exception) as context:
self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(image=self.image['id'],
**self.resource['volume_failure']))
exception = ('(422, u\'[(root).properties.image] Passwords/SSH Keys '
'are mandatory for public ProfitBricks Images.\')')
self.assertIn(exception, str(context.exception))
server1 = Server(name='My New Server1',
ram=4096,
cores=4,
nics=nics,
create_volumes=[volume1])
servers = [server1]
lan1 = LAN(name='public Lan 4', public=True)
lan2 = LAN(name='public Lan 5', public=True)
lans = [lan1, lan2]
loadbalancer1 = LoadBalancer(name='LB01', ip='10.2.2.5', dhcp=False)
loadbalancers = [loadbalancer1]
d = Datacenter(name='My New Datacenter',
description='Production environment',
location='de/fkb',
servers=servers,
volumes=volumes,
lans=lans,
loadbalancers=loadbalancers)
response = client.create_datacenter(datacenter=d)
del_response = client.delete_datacenter(response['id'])
class TestUserManagement(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create datacenter resource
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create volume resource
volume = Volume(**self.resource['volume'])
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'], volume=volume)
self.client.wait_for_completion(self.volume)
self.image = find_image(self.client, configuration.IMAGE_NAME)
# Create snapshot resource
self.snapshot = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'])
self.client.wait_for_completion(self.snapshot)
# Reserve IP block resource
self.ipblock = self.client.reserve_ipblock(
IPBlock(**self.resource['ipblock']))
# Create User 1
self.user_dict1 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999),
administrator=True,
force_sec_auth=False)
self.user1 = self.client.create_user(user=self.user_dict1)
# Create User 2
self.user_dict2 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999))
self.user2 = self.client.create_user(user=self.user_dict2)
# Create User 3
self.user_dict3 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999))
self.user3 = self.client.create_user(user=self.user_dict3)
# Create Group 1
group = Group(**self.resource['group'])
self.group1 = self.client.create_group(group)
# Create Group 2
group.name = self.resource['group']['name'] + ' 2'
self.group2 = self.client.create_group(group)
# Create Group 3
group.name = self.resource['group']['name'] + ' 3'
self.group3 = self.client.create_group(group)
# Create Share 1
self.share1 = self.client.add_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'],
edit_privilege=True,
share_privilege=True)
@classmethod
def tearDownClass(self):
self.client.delete_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'])
self.client.delete_snapshot(snapshot_id=self.snapshot['id'])
self.client.delete_user(user_id=self.user1['id'])
self.client.delete_user(user_id=self.user3['id'])
self.client.delete_group(group_id=self.group1['id'])
self.client.delete_group(group_id=self.group3['id'])
self.client.delete_ipblock(ipblock_id=self.ipblock['id'])
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_create_user(self):
self.assertEqual(self.user1['type'], 'user')
self.assertEqual(self.user1['properties']['firstname'],
self.user_dict1.firstname)
self.assertEqual(self.user1['properties']['lastname'],
self.user_dict1.lastname)
self.assertEqual(self.user1['properties']['email'],
self.user_dict1.email)
self.assertEqual(self.user1['properties']['administrator'],
self.user_dict1.administrator)
self.assertEqual(self.user1['properties']['forceSecAuth'],
self.user_dict1.force_sec_auth)
def test_list_users(self):
users = self.client.list_users()
self.assertGreater(len(users['items']), 0)
self.assertEqual(users['items'][0]['type'], 'user')
def test_get_user(self):
user = self.client.get_user(user_id=self.user1['id'])
self.assertEqual(user['type'], 'user')
self.assertEqual(user['id'], self.user1['id'])
self.assertEqual(user['properties']['firstname'],
self.user1['properties']['firstname'])
self.assertEqual(user['properties']['lastname'],
self.user1['properties']['lastname'])
self.assertEqual(user['properties']['email'],
self.user1['properties']['email'])
self.assertEqual(user['properties']['administrator'],
self.user1['properties']['administrator'])
self.assertEqual(user['properties']['forceSecAuth'],
self.user1['properties']['forceSecAuth'])
self.assertFalse(user['properties']['secAuthActive'])
def test_delete_user(self):
user = self.client.delete_user(user_id=self.user2['id'])
self.assertTrue(user)
def test_update_user(self):
user = self.client.update_user(
user_id=self.user1['id'],
firstname=self.user1['properties']['firstname'],
lastname=self.user1['properties']['lastname'],
email=self.user1['properties']['email'],
administrator=False,
force_sec_auth=self.user1['properties']['forceSecAuth'])
self.assertEqual(user['type'], 'user')
self.assertEqual(user['id'], self.user1['id'])
self.assertEqual(user['properties']['firstname'],
self.user1['properties']['firstname'])
self.assertEqual(user['properties']['lastname'],
self.user1['properties']['lastname'])
self.assertEqual(user['properties']['email'],
self.user1['properties']['email'])
self.assertFalse(user['properties']['administrator'])
self.assertEqual(user['properties']['forceSecAuth'],
self.user1['properties']['forceSecAuth'])
def test_create_user_failure(self):
try:
user = User(firstname='John',
lastname='Doe',
password='******')
self.client.create_user(user)
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'email',
e.content[0]['message'])
def test_get_user_failure(self):
try:
self.client.get_user('00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_group(self):
self.assertEqual(self.group1['type'], 'group')
self.assertEqual(self.group1['properties']['name'],
self.resource['group']['name'])
self.assertEqual(self.group1['properties']['createDataCenter'],
self.resource['group']['create_datacenter'])
self.assertEqual(self.group1['properties']['createSnapshot'],
self.resource['group']['create_snapshot'])
self.assertEqual(self.group1['properties']['reserveIp'],
self.resource['group']['reserve_ip'])
self.assertEqual(self.group1['properties']['accessActivityLog'],
self.resource['group']['access_activity_log'])
def test_list_groups(self):
groups = self.client.list_groups()
self.assertGreater(len(groups['items']), 0)
self.assertEqual(groups['items'][0]['type'], 'group')
def test_get_group(self):
group = self.client.get_group(group_id=self.group1['id'])
self.assertEqual(group['type'], 'group')
self.assertEqual(group['id'], self.group1['id'])
self.assertEqual(group['properties']['name'],
self.group1['properties']['name'])
self.assertEqual(group['properties']['createDataCenter'],
self.group1['properties']['createDataCenter'])
self.assertEqual(group['properties']['createSnapshot'],
self.group1['properties']['createSnapshot'])
self.assertEqual(group['properties']['reserveIp'],
self.group1['properties']['reserveIp'])
self.assertEqual(group['properties']['accessActivityLog'],
self.group1['properties']['accessActivityLog'])
def test_update_group(self):
group = self.client.update_group(group_id=self.group1['id'],
name=self.resource['group']['name'] +
' - RENAME',
create_datacenter=False)
self.assertEqual(group['type'], 'group')
self.assertEqual(group['id'], self.group1['id'])
self.assertEqual(group['properties']['name'],
self.resource['group']['name'] + ' - RENAME')
self.assertFalse(group['properties']['createDataCenter'])
def test_delete_group(self):
group = self.client.delete_group(group_id=self.group2['id'])
self.assertTrue(group)
def test_create_group_failure(self):
try:
self.client.create_group(Group(create_datacenter=True))
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'name',
e.content[0]['message'])
def test_get_group_failure(self):
try:
self.client.get_group('00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_add_share(self):
self.assertEqual(self.share1['type'], 'resource')
self.assertTrue(self.share1['properties']['editPrivilege'])
self.assertTrue(self.share1['properties']['sharePrivilege'])
def test_list_shares(self):
shares = self.client.list_shares(group_id=self.group3['id'])
self.assertGreater(len(shares['items']), 0)
self.assertEqual(shares['items'][0]['type'], 'resource')
def test_get_share(self):
share = self.client.get_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'])
self.assertEqual(share['id'], self.datacenter['id'])
self.assertEqual(share['type'], 'resource')
self.assertTrue(share['properties']['editPrivilege'])
self.assertTrue(share['properties']['sharePrivilege'])
def test_update_share(self):
share = self.client.update_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'],
share_privilege=False)
self.assertEqual(share['id'], self.datacenter['id'])
self.assertEqual(share['type'], 'resource')
self.assertFalse(share['properties']['sharePrivilege'])
def test_get_share_failure(self):
try:
self.client.get_share(
group_id=self.group3['id'],
resource_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_share_failure(self):
try:
self.client.add_share(
group_id=self.group3['id'],
resource_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_list_group_users(self):
users = self.client.list_group_users(group_id=self.group3['id'])
self.assertGreater(len(users['items']), 0)
self.assertEqual(users['items'][0]['type'], 'user')
def test_add_group_user(self):
user = self.client.add_group_user(group_id=self.group3['id'],
user_id=self.user3['id'])
self.assertEqual(user['id'], self.user3['id'])
self.assertEqual(user['type'], 'user')
def test_remove_group_user(self):
user = self.client.remove_group_user(group_id=self.group3['id'],
user_id=self.user3['id'])
self.assertTrue(user)
def test_list_resources(self):
resources = self.client.list_resources()
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['type'], 'collection')
def test_list_datacenter_resources(self):
resources = self.client.list_resources(resource_type='datacenter')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'datacenter')
def test_list_image_resources(self):
resources = self.client.list_resources(resource_type='image')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'image')
def test_list_snapshot_resources(self):
resources = self.client.list_resources(resource_type='snapshot')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'snapshot')
def test_list_ipblock_resources(self):
resources = self.client.list_resources(resource_type='ipblock')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'ipblock')
def test_list_resources_failure(self):
try:
self.client.list_resources(resource_type='unknown')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_get_datacenter_resource(self):
resource = self.client.get_resource(resource_type='datacenter',
resource_id=self.datacenter['id'])
self.assertEqual(resource['id'], self.datacenter['id'])
self.assertEqual(resource['type'], 'datacenter')
def test_get_image_resource(self):
resource = self.client.get_resource(resource_type='image',
resource_id=self.image['id'])
self.assertEqual(resource['id'], self.image['id'])
self.assertEqual(resource['type'], 'image')
def test_get_snapshot_resource(self):
resource = self.client.get_resource(resource_type='snapshot',
resource_id=self.snapshot['id'])
self.assertEqual(resource['id'], self.snapshot['id'])
self.assertEqual(resource['type'], 'snapshot')
def test_list_ipblock_resources2(self):
resource = self.client.get_resource(resource_type='ipblock',
resource_id=self.ipblock['id'])
self.assertEqual(resource['id'], self.ipblock['id'])
self.assertEqual(resource['type'], 'ipblock')
def test_get_resource_failure(self):
try:
self.client.get_resource(
resource_type='datacenter',
resource_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
class TestDatacenter(unittest.TestCase):
def setUp(self):
self.datacenter = ProfitBricksService(username="******", password="******")
def test_get_all(self):
datacenters = self.datacenter.list_datacenters()
self.assertEqual(len(datacenters), 4)
self.assertEqual(datacenters["items"][0]["id"], datacenter_id)
# self.assertEqual(
# datacenters['items'][0]['properties']['name'], 'datacenter1')
# self.assertEqual(
# datacenters['items'][0]['properties']['description'], 'Description of my DC')
# self.assertEqual(
# datacenters['items'][0]['properties']['location'], 'de/fkb')
# self.assertEqual(
# datacenters['items'][0]['properties']['version'], 4)
def test_get(self):
datacenter = self.datacenter.get_datacenter(datacenter_id=datacenter_id)
self.assertEqual(datacenter["id"], datacenter_id)
self.assertEqual(datacenter["properties"]["name"], "datacenter1")
self.assertEqual(datacenter["properties"]["description"], "Description of my DC")
self.assertEqual(datacenter["properties"]["version"], 4)
self.assertEqual(datacenter["properties"]["location"], "de/fkb")
def test_delete(self):
datacenter = self.datacenter.delete_datacenter(datacenter_id=datacenter_id)
self.assertTrue(datacenter)
def test_update(self):
datacenter = self.datacenter.update_datacenter(
datacenter_id=datacenter_id, name="Partially updated datacenter name"
)
self.assertEqual(datacenter["id"], datacenter_id)
self.assertEqual(datacenter["properties"]["name"], "datacenter1")
self.assertEqual(datacenter["properties"]["description"], "Description of my DC")
self.assertEqual(datacenter["properties"]["version"], 4)
self.assertEqual(datacenter["properties"]["location"], "de/fkb")
def test_create_simple(self):
i = Datacenter(name="datacenter1", description="My New Datacenter", location="de/fkb")
response = self.datacenter.create_datacenter(datacenter=i)
self.assertEqual(response["id"], datacenter_id)
self.assertEqual(response["properties"]["name"], "datacenter1")
self.assertEqual(response["properties"]["description"], "My New Datacenter")
self.assertEqual(response["properties"]["version"], 4)
self.assertEqual(response["properties"]["location"], "de/fkb")
def test_create_complex(self):
"""
Creates a complex Datacenter in a single request.
"""
fwrule1 = FirewallRule(
name="Open SSH port", protocol="TCP", source_mac="01:23:45:67:89:00", port_range_start=22
)
fwrule2 = FirewallRule(name="Allow PING", protocol="ICMP", icmp_type=8, icmp_code=0)
fw_rules = [fwrule1, fwrule2]
nic1 = NIC(name="nic1", ips=["10.2.2.3"], dhcp="true", lan=1, firewall_active=True, firewall_rules=fw_rules)
nic2 = NIC(name="nic2", ips=["10.2.3.4"], dhcp="true", lan=1, firewall_active=True, firewall_rules=fw_rules)
nics = [nic1, nic2]
volume1 = Volume(name="volume1", size=56, image="<IMAGE/SNAPSHOT-ID>", bus="VIRTIO")
volume2 = Volume(name="volume2", size=56, image="<IMAGE/SNAPSHOT-ID>", bus="VIRTIO")
volumes = [volume2]
server1 = Server(name="server1", ram=4096, cores=4, nics=nics, create_volumes=[volume1])
servers = [server1]
balancednics = ["<NIC-ID-1>", "<NIC-ID-2>"]
loadbalancer1 = LoadBalancer(name="My LB", balancednics=balancednics)
loadbalancers = [loadbalancer1]
lan1 = LAN(name="public Lan 4", public=True)
lan2 = LAN(name="public Lan 4", public=True)
lans = [lan1, lan2]
d = Datacenter(
name="datacenter1",
description="my DC",
location="de/fkb",
servers=servers,
volumes=volumes,
loadbalancers=loadbalancers,
lans=lans,
)
response = self.datacenter.create_datacenter(datacenter=d)
print(response)
self.assertEqual(response["id"], datacenter_id)
self.assertEqual(response["properties"]["name"], "My New Datacenter")
self.assertEqual(response["properties"]["description"], "Production environment")
self.assertEqual(response["properties"]["version"], 4)
self.assertEqual(response["properties"]["location"], "de/fkb")
class TestDatacenter(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_datacenters(self):
datacenters = self.client.list_datacenters()
self.assertGreater(len(datacenters), 0)
self.assertEqual(datacenters['items'][0]['type'], 'datacenter')
def test_get_datacenter(self):
datacenter = self.client.get_datacenter(
datacenter_id=self.datacenter['id'])
assertRegex(self, datacenter['id'], self.resource['uuid_match'])
self.assertEqual(datacenter['type'], 'datacenter')
self.assertEqual(datacenter['id'], self.datacenter['id'])
self.assertEqual(datacenter['properties']['name'],
self.resource['datacenter']['name'])
self.assertEqual(datacenter['properties']['description'],
self.resource['datacenter']['description'])
self.assertEqual(datacenter['properties']['location'],
self.resource['datacenter']['location'])
def test_get_failure(self):
try:
self.client.get_datacenter(
datacenter_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_failure(self):
try:
datacenter = Datacenter(name=self.resource['datacenter']['name'])
self.client.create_datacenter(datacenter)
except PBError as e:
self.assertIn(
self.resource['missing_attribute_error'] % 'location',
e.content[0]['message'])
def test_remove_datacenter(self):
datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(datacenter)
response = self.client.delete_datacenter(
datacenter_id=datacenter['id'])
self.assertTrue(response)
def test_update_datacenter(self):
datacenter = self.client.update_datacenter(
datacenter_id=self.datacenter['id'],
description=self.resource['datacenter']['name'] + ' - RENAME')
self.client.wait_for_completion(datacenter)
time.sleep(10)
datacenter = self.client.get_datacenter(
datacenter_id=self.datacenter['id'])
assertRegex(self, datacenter['id'], self.resource['uuid_match'])
self.assertEqual(datacenter['id'], self.datacenter['id'])
self.assertEqual(datacenter['properties']['name'],
self.resource['datacenter']['name'])
self.assertEqual(datacenter['properties']['description'],
self.resource['datacenter']['name'] + ' - RENAME')
self.assertEqual(datacenter['properties']['location'],
self.resource['datacenter']['location'])
self.assertGreater(datacenter['properties']['version'], 1)
def test_create_simple(self):
datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(datacenter)
self.assertEqual(datacenter['type'], 'datacenter')
self.assertEqual(datacenter['properties']['name'],
self.resource['datacenter']['name'])
self.assertEqual(datacenter['properties']['description'],
self.resource['datacenter']['description'])
self.assertEqual(datacenter['properties']['location'],
self.resource['datacenter']['location'])
response = self.client.delete_datacenter(
datacenter_id=datacenter['id'])
self.assertTrue(response)
def test_create_composite(self):
datacenter_resource = Datacenter(
**self.resource['datacenter_composite'])
datacenter_resource.servers = [Server(**self.resource['server'])]
datacenter_resource.volumes = [Volume(**self.resource['volume'])]
datacenter = self.client.create_datacenter(
datacenter=datacenter_resource)
self.client.wait_for_completion(datacenter)
self.assertEqual(datacenter['type'], 'datacenter')
self.assertEqual(datacenter['properties']['name'],
self.resource['datacenter_composite']['name'])
self.assertEqual(datacenter['properties']['description'],
self.resource['datacenter_composite']['description'])
self.assertEqual(datacenter['properties']['location'],
self.resource['datacenter_composite']['location'])
self.assertGreater(len(datacenter['entities']['servers']), 0)
self.assertGreater(len(datacenter['entities']['volumes']), 0)
response = self.client.delete_datacenter(
datacenter_id=datacenter['id'])
self.assertTrue(response)
class TestFirewall(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test LAN.
self.lan = self.client.create_lan(datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
self.client.wait_for_completion(self.lan)
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(self.server)
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
self.client.wait_for_completion(self.nic1)
# Create test Firewall Rule
fwrule = FirewallRule(**self.resource['fwrule'])
self.fwrule = self.client.create_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule=fwrule)
self.client.wait_for_completion(self.fwrule)
# Create test Firewall Rule 2
fwrule2 = FirewallRule(**self.resource['fwrule'])
fwrule2.port_range_start = 8080
fwrule2.port_range_end = 8080
fwrule2.name = "8080"
self.fwrule2 = self.client.create_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule=fwrule2)
self.client.wait_for_completion(self.fwrule2)
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_fwrules(self):
fwrules = self.client.get_firewall_rules(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'])
self.assertGreater(len(fwrules), 0)
self.assertIn(fwrules['items'][0]['id'],
(self.fwrule['id'], self.fwrule2['id']))
self.assertEqual(fwrules['items'][0]['type'], 'firewall-rule')
def test_get_fwrule(self):
fwrule = self.client.get_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule_id=self.fwrule['id'])
self.assertEqual(fwrule['type'], 'firewall-rule')
self.assertEqual(fwrule['id'], self.fwrule['id'])
assertRegex(self, fwrule['id'], self.resource['uuid_match'])
self.assertEqual(fwrule['properties']['name'],
self.fwrule['properties']['name'])
self.assertEqual(fwrule['properties']['protocol'],
self.fwrule['properties']['protocol'])
self.assertEqual(fwrule['properties']['sourceMac'],
self.fwrule['properties']['sourceMac'])
self.assertIsNone(fwrule['properties']['sourceIp'])
self.assertIsNone(fwrule['properties']['targetIp'])
self.assertIsNone(fwrule['properties']['icmpCode'])
self.assertIsNone(fwrule['properties']['icmpType'])
self.assertEqual(fwrule['properties']['portRangeStart'],
self.fwrule['properties']['portRangeStart'])
self.assertEqual(fwrule['properties']['portRangeEnd'],
self.fwrule['properties']['portRangeEnd'])
def test_delete_fwrule(self):
fwrule = self.client.delete_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule_id=self.fwrule2['id'])
self.assertTrue(fwrule)
def test_update_fwrule(self):
fwrule = self.client.update_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule_id=self.fwrule['id'],
name=self.resource['fwrule']['name'] + ' - RENAME')
self.assertEqual(fwrule['type'], 'firewall-rule')
self.assertEqual(fwrule['properties']['name'],
self.resource['fwrule']['name'] + ' - RENAME')
def test_create_fwrule(self):
self.assertEqual(self.fwrule['type'], 'firewall-rule')
self.assertEqual(self.fwrule['properties']['name'],
self.resource['fwrule']['name'])
self.assertEqual(self.fwrule['properties']['protocol'],
self.resource['fwrule']['protocol'])
self.assertEqual(self.fwrule['properties']['sourceMac'],
self.resource['fwrule']['source_mac'])
self.assertIsNone(self.fwrule['properties']['sourceIp'])
self.assertIsNone(self.fwrule['properties']['targetIp'])
self.assertIsNone(self.fwrule['properties']['icmpCode'])
self.assertIsNone(self.fwrule['properties']['icmpType'])
self.assertEqual(self.fwrule['properties']['portRangeStart'],
self.resource['fwrule']['port_range_start'])
self.assertEqual(self.fwrule['properties']['portRangeEnd'],
self.resource['fwrule']['port_range_end'])
def test_get_failure(self):
try:
self.client.get_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_failure(self):
try:
fwrule = FirewallRule(name=self.resource['fwrule']['name'])
self.client.create_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule=fwrule)
except PBError as e:
self.assertIn(
self.resource['missing_attribute_error'] % 'protocol',
e.content[0]['message'])
class TestServer(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test volume1.
self.volume1 = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
self.client.wait_for_completion(self.volume1)
# Create test volume2 (attach volume test).
self.volume2 = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
self.client.wait_for_completion(self.volume2)
# Create test server.
server = Server(**self.resource['server'])
server.attach_volumes = [self.volume1['id']]
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'], server=server)
self.client.wait_for_completion(self.server)
# Create test NIC.
self.nic = self.client.create_nic(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=NIC(**self.resource['nic']))
self.client.wait_for_completion(self.nic)
# Find an Ubuntu image for testing.
for item in self.client.list_images()['items']:
if (configuration.IMAGE_NAME in item['properties']['name'] and
item['properties']['location'] == configuration.LOCATION):
self.image = item
# Find a cdrom image
images = self.client.list_images(depth=5)
usedIndex = 0
for index, image in enumerate(images['items']):
if (image['metadata']['state'] == "AVAILABLE"
and image['properties']['public'] is True
and image['properties']['imageType'] == "CDROM" and
image['properties']['location'] == configuration.LOCATION
and image['properties']['licenceType'] == "LINUX"):
if (usedIndex == 0):
self.test_image1 = image
usedIndex = index
else:
self.test_image2 = image
break
# Create test cdrom
self.cdrom = self.client.attach_cdrom(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
cdrom_id=self.test_image1['id'])
self.client.wait_for_completion(self.cdrom)
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_servers(self):
servers = self.client.list_servers(datacenter_id=self.datacenter['id'])
self.assertGreater(len(servers), 0)
self.assertEqual(servers['items'][0]['type'], 'server')
self.assertTrue(self, len(servers['items']) > 0)
assertRegex(self, servers['items'][0]['id'],
self.resource['uuid_match'])
def test_get_server(self):
server = self.client.get_server(datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertEqual(server['type'], 'server')
self.assertEqual(server['id'], self.server['id'])
self.assertEqual(server['properties']['name'],
self.resource['server']['name'])
self.assertEqual(server['properties']['cores'],
self.resource['server']['cores'])
self.assertEqual(server['properties']['ram'],
self.resource['server']['ram'])
self.assertEqual(server['properties']['availabilityZone'],
self.resource['server']['availability_zone'])
self.assertEqual(server['properties']['cpuFamily'],
self.resource['server']['cpu_family'])
# assertRegex(self, server['properties']['bootVolume']['id'], self.resource['uuid_match'])
def test_get_failure(self):
try:
self.client.get_server(
datacenter_id=self.datacenter['id'],
server_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_delete_server(self):
server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(server)
response = self.client.delete_server(
datacenter_id=self.datacenter['id'], server_id=server['id'])
self.assertTrue(response)
def test_update_server(self):
server = self.client.update_server(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
name=self.resource['server']['name'] + ' RENAME')
self.client.wait_for_completion(server)
server = self.client.get_server(datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertEqual(server['id'], self.server['id'])
self.assertEqual(server['properties']['name'],
self.resource['server']['name'] + ' RENAME')
self.assertEqual(server['properties']['cores'],
self.resource['server']['cores'])
self.assertEqual(server['properties']['ram'],
self.resource['server']['ram'])
def test_create_server(self):
# Use server created during server test setup
assertRegex(self, self.server['id'], self.resource['uuid_match'])
self.assertEqual(self.server['type'], 'server')
self.assertEqual(self.server['properties']['name'],
self.resource['server']['name'])
self.assertEqual(self.server['properties']['cores'],
self.resource['server']['cores'])
self.assertEqual(self.server['properties']['ram'],
self.resource['server']['ram'])
self.assertEqual(self.server['properties']['availabilityZone'],
self.resource['server']['availability_zone'])
self.assertEqual(self.server['properties']['cpuFamily'],
self.resource['server']['cpu_family'])
# assertRegex(self, server['properties']['bootVolume']['id'], self.resource['uuid_match'])
# self.assertIsNone(self.server['properties']['availabilityZone'])
self.assertIsNone(self.server['properties']['vmState'])
def test_create_failure(self):
try:
server = Server(name=self.resource['server']['name'],
ram=self.resource['server']['ram'])
self.client.create_server(datacenter_id=self.datacenter['id'],
server=server)
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'cores',
e.content[0]['message'])
def test_create_composite(self):
fwrule = FirewallRule(**self.resource['fwrule'])
nic = NIC(firewall_rules=[fwrule], **self.resource['nic'])
volume = Volume(image=self.image['id'],
image_password='******',
ssh_keys=['ssh-rsa AAAAB3NzaC1'],
**self.resource['volume'])
volume.availability_zone = 'ZONE_3'
server = Server(nics=[nic],
create_volumes=[volume],
**self.resource['server'])
composite_server = self.client.create_server(
datacenter_id=self.datacenter['id'], server=server)
self.client.wait_for_completion(composite_server, timeout=600)
composite_server = self.client.get_server(
datacenter_id=self.datacenter['id'],
server_id=composite_server['id'])
assertRegex(self, composite_server['id'], self.resource['uuid_match'])
self.assertEqual(composite_server['properties']['name'],
self.resource['server']['name'])
self.assertEqual(composite_server['properties']['cores'],
self.resource['server']['cores'])
self.assertEqual(composite_server['properties']['ram'],
self.resource['server']['ram'])
self.assertEqual(composite_server['properties']['availabilityZone'],
'ZONE_1')
self.assertIn(composite_server['properties']['vmState'],
self.resource['vm_states'])
self.assertGreater(
len(composite_server['entities']['volumes']['items']), 0)
self.assertGreater(len(composite_server['entities']['nics']['items']),
0)
def test_start_server(self):
server = self.client.start_server(datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertTrue(server)
def test_stop_server(self):
server = self.client.stop_server(datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertTrue(server)
def test_reboot_server(self):
server = self.client.reboot_server(datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertTrue(server)
def test_get_attached_volumes(self):
volumes = self.client.get_attached_volumes(
datacenter_id=self.datacenter['id'], server_id=self.server['id'])
self.assertGreater(len(volumes['items']), 0)
self.assertEqual(volumes['items'][0]['type'], 'volume')
self.assertEqual(volumes['items'][0]['id'], self.volume1['id'])
self.assertEqual(volumes['items'][0]['properties']['name'],
self.resource['volume']['name'])
self.assertEqual(volumes['items'][0]['properties']['size'],
self.resource['volume']['size'])
self.assertEqual(volumes['items'][0]['properties']['bus'],
self.resource['volume']['bus'])
self.assertEqual(volumes['items'][0]['properties']['type'],
self.resource['volume']['disk_type'])
self.assertEqual(volumes['items'][0]['properties']['licenceType'],
'UNKNOWN')
self.assertIsNone(volumes['items'][0]['properties']['image'])
self.assertIsNone(volumes['items'][0]['properties']['imagePassword'])
self.assertFalse(volumes['items'][0]['properties']['cpuHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['cpuHotUnplug'])
self.assertFalse(volumes['items'][0]['properties']['ramHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['ramHotUnplug'])
self.assertFalse(volumes['items'][0]['properties']['nicHotPlug'])
self.assertFalse(volumes['items'][0]['properties']['nicHotUnplug'])
self.assertFalse(
volumes['items'][0]['properties']['discVirtioHotPlug'])
self.assertFalse(
volumes['items'][0]['properties']['discVirtioHotUnplug'])
self.assertFalse(volumes['items'][0]['properties']['discScsiHotPlug'])
self.assertFalse(
volumes['items'][0]['properties']['discScsiHotUnplug'])
def test_get_attached_volume(self):
volume = self.client.get_attached_volume(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume1['id'])
self.assertEqual(volume['id'], self.volume1['id'])
self.assertEqual(volume['properties']['name'],
self.resource['volume']['name'])
self.assertEqual(volume['properties']['size'],
self.resource['volume']['size'])
self.assertEqual(volume['properties']['bus'],
self.resource['volume']['bus'])
self.assertEqual(volume['properties']['type'],
self.resource['volume']['disk_type'])
self.assertEqual(volume['properties']['licenceType'],
self.resource['volume']['licence_type'])
self.assertIsNone(volume['properties']['image'])
self.assertIsNone(volume['properties']['imagePassword'])
self.assertFalse(volume['properties']['cpuHotPlug'])
self.assertFalse(volume['properties']['cpuHotUnplug'])
self.assertFalse(volume['properties']['ramHotPlug'])
self.assertFalse(volume['properties']['ramHotUnplug'])
self.assertFalse(volume['properties']['nicHotPlug'])
self.assertFalse(volume['properties']['nicHotUnplug'])
self.assertFalse(volume['properties']['discVirtioHotPlug'])
self.assertFalse(volume['properties']['discVirtioHotUnplug'])
self.assertFalse(volume['properties']['discScsiHotPlug'])
self.assertFalse(volume['properties']['discScsiHotUnplug'])
def test_attach_volume(self):
volume = self.client.attach_volume(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume2['id'])
self.client.wait_for_completion(volume)
self.assertEqual(volume['id'], self.volume2['id'])
self.assertEqual(volume['properties']['name'],
self.resource['volume']['name'])
self.assertEqual(volume['properties']['size'],
self.resource['volume']['size'])
self.assertEqual(volume['properties']['type'],
self.resource['volume']['disk_type'])
self.assertEqual(volume['properties']['licenceType'],
self.resource['volume']['licence_type'])
self.assertIsNone(volume['properties']['bus'])
self.assertIsNone(volume['properties']['image'])
self.assertIsNone(volume['properties']['imagePassword'])
self.assertFalse(volume['properties']['cpuHotPlug'])
self.assertFalse(volume['properties']['cpuHotUnplug'])
self.assertFalse(volume['properties']['ramHotPlug'])
self.assertFalse(volume['properties']['ramHotUnplug'])
self.assertFalse(volume['properties']['nicHotPlug'])
self.assertFalse(volume['properties']['nicHotUnplug'])
self.assertFalse(volume['properties']['discVirtioHotPlug'])
self.assertFalse(volume['properties']['discVirtioHotUnplug'])
self.assertFalse(volume['properties']['discScsiHotPlug'])
self.assertFalse(volume['properties']['discScsiHotUnplug'])
self.client.detach_volume(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume2['id'])
def test_detach_volume(self):
volume = self.client.detach_volume(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume1['id'])
self.assertTrue(volume)
def test_list_cdroms(self):
cdroms = self.client.get_attached_cdroms(
datacenter_id=self.datacenter['id'], server_id=self.server['id'])
self.assertGreater(len(cdroms['items']), 0)
def test_attach_cdrom(self):
attached_cdrom = self.client.attach_cdrom(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
cdrom_id=self.test_image2['id'])
self.client.wait_for_completion(attached_cdrom, timeout=600)
self.assertEqual(attached_cdrom['id'], self.test_image2['id'])
self.assertEqual(attached_cdrom['properties']['name'],
self.test_image2['properties']['name'])
def test_get_cdrom(self):
attached_cdrom = self.client.attach_cdrom(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
cdrom_id=self.test_image1['id'])
self.client.wait_for_completion(attached_cdrom, timeout=600)
cdrom = self.client.get_attached_cdrom(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
cdrom_id=attached_cdrom['id'])
self.assertEqual(cdrom['id'], attached_cdrom['id'])
self.assertEqual(cdrom['properties']['name'],
attached_cdrom['properties']['name'])
def test_detach_cdrom(self):
detached_cd = self.client.detach_cdrom(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
cdrom_id=self.cdrom['id'])
time.sleep(15)
self.assertTrue(detached_cd)
try:
check_detached_cdrom_gone(self)
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
class TestLan(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, self.datacenter, 'create_datacenter')
# Create test LAN.
self.lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
wait_for_completion(self.client, self.lan, 'create_lan')
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
wait_for_completion(self.client, self.server, 'create_server')
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
wait_for_completion(self.client, self.nic1, 'create_nic1')
# Create test NIC2.
nic2 = NIC(**self.resource['nic'])
nic2.lan = self.lan['id']
self.nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic2)
wait_for_completion(self.client, self.nic2, 'create_nic2')
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_lans(self):
lans = self.client.list_lans(datacenter_id=self.datacenter['id'])
self.assertGreater(len(lans), 0)
self.assertEqual(lans['items'][0]['type'], 'lan')
self.assertIn(lans['items'][0]['id'], ('1', '2', '3'))
self.assertEqual(lans['items'][0]['properties']['name'], self.resource['lan']['name'])
self.assertTrue(lans['items'][0]['properties']['public'], self.resource['lan']['public'])
def test_get_lan(self):
lan = self.client.get_lan(datacenter_id=self.datacenter['id'], lan_id=self.lan['id'])
self.assertEqual(lan['type'], 'lan')
self.assertEqual(lan['id'], self.lan['id'])
self.assertEqual(lan['properties']['name'], self.resource['lan']['name'])
self.assertTrue(lan['properties']['public'], self.resource['lan']['public'])
def test_delete_lan(self):
lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
wait_for_completion(self.client, self.lan, 'create_lan')
lan = self.client.delete_lan(datacenter_id=self.datacenter['id'], lan_id=lan['id'])
self.assertTrue(lan)
def test_update_lan(self):
lan = self.client.update_lan(
datacenter_id=self.datacenter['id'],
lan_id=self.lan['id'],
name=self.resource['lan']['name'] + ' RENAME',
public=False)
self.assertEqual(lan['type'], 'lan')
self.assertEqual(lan['properties']['name'], self.resource['lan']['name'] + ' RENAME')
self.assertFalse(lan['properties']['public'])
def test_create_lan(self):
self.assertEqual(self.lan['id'], '1')
self.assertEqual(self.lan['type'], 'lan')
self.assertEqual(self.lan['properties']['name'], self.resource['lan']['name'])
self.assertEqual(self.lan['properties']['public'], self.resource['lan']['public'])
def test_create_complex_lan(self):
resource = NIC(**self.resource['nic'])
nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=resource)
wait_for_completion(self.client, nic1, 'create_nic1')
nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=resource)
wait_for_completion(self.client, nic2, 'create_nic2')
nics = [nic1['id'], nic2['id']]
lan = LAN(nics=nics, **self.resource['lan'])
response = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=lan)
wait_for_completion(self.client, response, 'create_lan')
self.assertEqual(response['type'], 'lan')
self.assertEqual(response['properties']['name'], self.resource['lan']['name'])
self.assertTrue(response['properties']['public'])
def test_get_lan_members(self):
members = self.client.get_lan_members(
datacenter_id=self.datacenter['id'],
lan_id=self.lan['id'])
self.assertGreater(len(members), 0)
assertRegex(self, members['items'][0]['id'], self.resource['uuid_match'])
self.assertEqual(members['items'][0]['type'], 'nic')
self.assertEqual(members['items'][0]['properties']['name'], self.resource['nic']['name'])
assertRegex(self, members['items'][0]['properties']['mac'], self.resource['mac_match'])
class TestVolume(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
self.image = find_image(self.client, configuration.IMAGE_NAME)
# Create test volume
vol = Volume(**self.resource['volume2'])
vol.image = self.image['id']
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=vol)
self.client.wait_for_completion(self.volume)
# Create snapshot1
self.snapshot1 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'],
description=self.resource['snapshot']['description'])
self.client.wait_for_completion(self.snapshot1, timeout=600)
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_volumes(self):
volumes = self.client.list_volumes(
datacenter_id=self.datacenter['id'])
self.assertGreater(len(volumes), 0)
assertRegex(self, volumes['items'][0]['id'], self.resource['uuid_match'])
self.assertEqual(volumes['items'][0]['type'], 'volume')
self.assertEqual(volumes['items'][0]['properties']['name'],
self.resource['volume2']['name'])
self.assertEqual(volumes['items'][0]['properties']['size'],
self.resource['volume2']['size'])
self.assertEqual(volumes['items'][0]['properties']['type'],
self.resource['volume2']['disk_type'])
self.assertIsNone(volumes['items'][0]['properties']['bus'])
def test_get_volume(self):
volume = self.client.get_volume(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'])
self.assertEqual(volume['id'], self.volume['id'])
self.assertEqual(volume['type'], 'volume')
self.assertEqual(volume['properties']['name'], self.resource['volume2']['name'])
self.assertEqual(volume['properties']['size'], self.resource['volume2']['size'])
self.assertEqual(volume['properties']['licenceType'],
self.image['properties']['licenceType'])
self.assertEqual(volume['properties']['type'], self.resource['volume2']['disk_type'])
self.assertIsNone(volume['properties']['bus'])
self.assertEqual(volume['properties']['availabilityZone'],
self.resource['volume2']['availability_zone'])
def test_delete_volume(self):
volume = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
self.client.wait_for_completion(volume)
volume = self.client.delete_volume(
datacenter_id=self.datacenter['id'],
volume_id=volume['id'])
self.assertTrue(volume)
def test_update_volume(self):
volume = self.client.update_volume(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
size=6,
name=self.resource['volume2']['name'] + ' - RENAME')
self.client.wait_for_completion(volume)
volume = self.client.get_volume(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'])
self.assertEqual(volume['id'], self.volume['id'])
self.assertEqual(volume['properties']['name'],
self.resource['volume2']['name'] + ' - RENAME')
self.assertEqual(volume['properties']['size'], 6)
def test_create_volume(self):
# Use volume created during volume test setup.
assertRegex(self, self.volume['id'], self.resource['uuid_match'])
self.assertEqual(self.volume['properties']['name'], self.resource['volume2']['name'])
self.assertEqual(self.volume['properties']['bus'], self.resource['volume2']['bus'])
self.assertEqual(self.volume['properties']['type'], self.resource['volume2']['disk_type'])
self.assertEqual(self.volume['properties']['size'], self.resource['volume2']['size'])
self.assertEqual(self.volume['properties']['sshKeys'],
self.resource['volume2']['ssh_keys'])
self.assertEqual(self.volume['properties']['availabilityZone'],
self.resource['volume2']['availability_zone'])
def test_create_snapshot(self):
# Use snapshot created during volume test setup.
self.assertEqual(self.snapshot1['type'], 'snapshot')
self.assertEqual(self.snapshot1['properties']['name'], self.resource['snapshot']['name'])
self.assertEqual(self.snapshot1['properties']['description'],
self.resource['snapshot']['description'])
self.assertEqual(self.snapshot1['properties']['location'], configuration.LOCATION)
self.assertIsNone(self.snapshot1['properties']['size'])
self.assertIsNone(self.snapshot1['properties']['licenceType'])
def test_restore_snapshot(self):
response = self.client.restore_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
snapshot_id=self.snapshot1['id'])
self.assertTrue(response)
def test_remove_snapshot(self):
volume = self.client.remove_snapshot(snapshot_id=self.snapshot1['id'])
self.assertTrue(volume)
def test_get_failure(self):
try:
self.client.get_volume(
datacenter_id=self.datacenter['id'],
volume_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
def test_create_failure(self):
try:
volume = Volume(name=self.resource['volume2']['name'])
self.client.create_volume(datacenter_id=self.datacenter['id'], volume=volume)
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'size',
e.content[0]['message'])
class TestLoadBalancer(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test LAN.
self.lan = self.client.create_lan(datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
self.client.wait_for_completion(self.lan)
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(self.server)
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
self.client.wait_for_completion(self.nic1)
# Create test NIC2.
# nic2 = NIC(**self.resource['nic'])
# nic2.lan = self.lan['id']
# self.nic2 = self.client.create_nic(
# datacenter_id=self.datacenter['id'],
# server_id=self.server['id'],
# nic=nic2)
# self.client.wait_for_completion(self.nic2)
# Create test LoadBalancer
loadbalancer = LoadBalancer(**self.resource['loadbalancer'])
loadbalancer.balancednics = [self.nic1['id']]
self.loadbalancer = self.client.create_loadbalancer(
datacenter_id=self.datacenter['id'], loadbalancer=loadbalancer)
self.client.wait_for_completion(self.loadbalancer)
# Create test LoadBalancer2
loadbalancer2 = LoadBalancer(**self.resource['loadbalancer'])
loadbalancer2.name = "Python SDK Test 2"
self.loadbalancer2 = self.client.create_loadbalancer(
datacenter_id=self.datacenter['id'], loadbalancer=loadbalancer2)
self.client.wait_for_completion(self.loadbalancer2)
# Create test LoadBalancer3
loadbalancer3 = LoadBalancer(**self.resource['loadbalancer'])
loadbalancer3.balancednics = [self.nic1['id']]
loadbalancer3.name = "Python SDK Test 3"
self.loadbalancer3 = self.client.create_loadbalancer(
datacenter_id=self.datacenter['id'], loadbalancer=loadbalancer3)
self.client.wait_for_completion(self.loadbalancer3)
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_loadbalancers(self):
loadbalancers = self.client.list_loadbalancers(
datacenter_id=self.datacenter['id'])
self.assertGreater(len(loadbalancers), 0)
self.assertIn(loadbalancers['items'][0]['id'],
(self.loadbalancer['id'], self.loadbalancer2['id'],
self.loadbalancer3['id']))
self.assertEqual(loadbalancers['items'][0]['type'], 'loadbalancer')
def test_get_loadbalancer(self):
loadbalancer = self.client.get_loadbalancer(
datacenter_id=self.datacenter['id'],
loadbalancer_id=self.loadbalancer['id'])
self.assertEqual(loadbalancer['type'], 'loadbalancer')
self.assertEqual(loadbalancer['id'], self.loadbalancer['id'])
assertRegex(self, loadbalancer['id'], self.resource['uuid_match'])
self.assertEqual(loadbalancer['properties']['name'],
self.loadbalancer['properties']['name'])
self.assertEqual(loadbalancer['properties']['dhcp'],
self.loadbalancer['properties']['dhcp'])
self.assertIsNotNone(loadbalancer['properties']['ip'])
def test_delete_loadbalancer(self):
loadbalancer = self.client.delete_loadbalancer(
datacenter_id=self.datacenter['id'],
loadbalancer_id=self.loadbalancer2['id'])
self.assertTrue(loadbalancer)
def test_update_loadbalancer(self):
loadbalancer = self.client.update_loadbalancer(
datacenter_id=self.datacenter['id'],
loadbalancer_id=self.loadbalancer['id'],
name=self.resource['loadbalancer']['name'] + ' - RENAME')
self.assertEqual(loadbalancer['type'], 'loadbalancer')
self.assertEqual(loadbalancer['properties']['name'],
self.resource['loadbalancer']['name'] + ' - RENAME')
def test_create_loadbalancer(self):
self.assertEqual(self.loadbalancer['type'], 'loadbalancer')
self.assertIsNotNone(self.loadbalancer['entities']['balancednics'])
self.assertEqual(self.loadbalancer['properties']['name'],
self.resource['loadbalancer']['name'])
self.assertEqual(self.loadbalancer['properties']['dhcp'],
self.resource['loadbalancer']['dhcp'])
def test_associate_nic(self):
associated_nic = self.client.add_loadbalanced_nics(
datacenter_id=self.datacenter['id'],
loadbalancer_id=self.loadbalancer2['id'],
nic_id=self.nic1['id'])
self.client.wait_for_completion(associated_nic)
self.assertEqual(associated_nic['id'], self.nic1['id'])
self.assertEqual(associated_nic['properties']['name'],
self.nic1['properties']['name'])
def test_remove_nic(self):
remove_nic = self.client.remove_loadbalanced_nic(
datacenter_id=self.datacenter['id'],
loadbalancer_id=self.loadbalancer3['id'],
nic_id=self.nic1['id'])
self.assertTrue(remove_nic)
sleep(30)
def test_list_balanced_nics(self):
balanced_nics = self.client.get_loadbalancer_members(
datacenter_id=self.datacenter['id'],
loadbalancer_id=self.loadbalancer['id'])
self.assertGreater(len(balanced_nics['items']), 0)
self.assertEqual(balanced_nics['items'][0]['id'], self.nic1['id'])
self.assertEqual(balanced_nics['items'][0]['type'], 'nic')
def test_get_balanced_nic(self):
balanced_nic = self.client.get_loadbalanced_nic(
datacenter_id=self.datacenter['id'],
loadbalancer_id=self.loadbalancer['id'],
nic_id=self.nic1['id'])
self.assertEqual(balanced_nic['id'], self.nic1['id'])
self.assertEqual(balanced_nic['type'], 'nic')
self.assertEqual(balanced_nic['properties']['name'],
self.nic1['properties']['name'])
self.assertEqual(balanced_nic['properties']['dhcp'],
self.nic1['properties']['dhcp'])
self.assertIsInstance(balanced_nic['properties']['nat'], bool)
self.assertIsInstance(balanced_nic['properties']['firewallActive'],
bool)
self.assertGreater(len(balanced_nic['properties']['ips']), 0)
self.assertIsInstance(balanced_nic['properties']['lan'], int)
assertRegex(self, balanced_nic['properties']['mac'],
self.resource['mac_match'])
def test_get_failure(self):
try:
self.client.get_loadbalancer(
datacenter_id=self.datacenter['id'],
loadbalancer_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_failure(self):
try:
self.client.create_loadbalancer(
datacenter_id=self.datacenter['id'],
loadbalancer=LoadBalancer())
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'lan',
e.content[0]['message'])
class TestServer(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, self.datacenter, 'create_datacenter')
# Create test volume1.
self.volume1 = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
wait_for_completion(self.client, self.volume1, 'create_volume')
# Create test volume2 (attach volume test).
self.volume2 = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
wait_for_completion(self.client, self.volume2, 'create_volume')
# Create test server.
server = Server(**self.resource['server'])
server.attach_volumes = [self.volume1['id']]
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=server)
wait_for_completion(self.client, self.server, 'create_server')
# Create test NIC.
self.nic = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=NIC(**self.resource['nic']))
wait_for_completion(self.client, self.nic, 'create_nic')
# Find an Ubuntu image for testing.
for item in self.client.list_images()['items']:
if 'Ubuntu-15' in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION:
self.image = item
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list(self):
servers = self.client.list_servers(datacenter_id=self.datacenter['id'])
self.assertGreater(len(servers), 0)
self.assertEqual(servers['items'][0]['type'], 'server')
assertRegex(self, servers['items'][0]['id'], self.resource['uuid_match'])
def test_get(self):
server = self.client.get_server(
datacenter_id=self.datacenter['id'],
server_id=self.server['id']
)
self.assertEqual(server['type'], 'server')
self.assertEqual(server['id'], self.server['id'])
self.assertEqual(server['properties']['name'], self.resource['server']['name'])
self.assertEqual(server['properties']['cores'], self.resource['server']['cores'])
self.assertEqual(server['properties']['ram'], self.resource['server']['ram'])
def test_delete(self):
server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server'])
)
wait_for_completion(self.client, server, 'create_server')
response = self.client.delete_server(
datacenter_id=self.datacenter['id'],
server_id=server['id']
)
self.assertTrue(response)
def test_update(self):
server = self.client.update_server(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
name=self.resource['server']['name'] + ' RENAME')
wait_for_completion(self.client, server, 'update_server')
server = self.client.get_server(
datacenter_id=self.datacenter['id'],
server_id=self.server['id']
)
self.assertEqual(server['id'], self.server['id'])
self.assertEqual(server['properties']['name'], self.resource['server']['name'] + ' RENAME')
self.assertEqual(server['properties']['cores'], self.resource['server']['cores'])
self.assertEqual(server['properties']['ram'], self.resource['server']['ram'])
def test_create_simple(self):
# Use server created dring server test setup
assertRegex(self, self.server['id'], self.resource['uuid_match'])
self.assertEqual(self.server['type'], 'server')
self.assertEqual(self.server['properties']['name'], self.resource['server']['name'])
self.assertEqual(self.server['properties']['cores'], self.resource['server']['cores'])
self.assertEqual(self.server['properties']['ram'], self.resource['server']['ram'])
self.assertIsNone(self.server['properties']['availabilityZone'])
self.assertIsNone(self.server['properties']['vmState'])
def test_create_complex(self):
fwrule = FirewallRule(**self.resource['fwrule'])
nic = NIC(firewall_rules=[fwrule], **self.resource['nic'])
volume = Volume(image=self.image['id'],
image_password='******',
ssh_keys=['ssh-rsa AAAAB3NzaC1'],
**self.resource['volume'])
server = Server(
nics=[nic],
create_volumes=[volume],
**self.resource['server'])
composite_server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=server)
wait_for_completion(self.client, composite_server, 'create_server', wait_timeout=600)
composite_server = self.client.get_server(
datacenter_id=self.datacenter['id'],
server_id=composite_server['id'])
assertRegex(self, composite_server['id'], self.resource['uuid_match'])
self.assertEqual(composite_server['properties']['name'], self.resource['server']['name'])
self.assertEqual(composite_server['properties']['cores'], self.resource['server']['cores'])
self.assertEqual(composite_server['properties']['ram'], self.resource['server']['ram'])
self.assertEqual(composite_server['properties']['availabilityZone'], 'AUTO')
self.assertIn(composite_server['properties']['vmState'], self.resource['vm_states'])
def test_start_server(self):
server = self.client.start_server(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertTrue(server)
def test_stop_server(self):
server = self.client.stop_server(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertTrue(server)
def test_reboot_server(self):
server = self.client.reboot_server(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertTrue(server)
def test_get_attached_volumes(self):
servers = self.client.get_attached_volumes(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertGreater(len(servers), 0)
self.assertEqual(servers['items'][0]['id'], self.volume1['id'])
self.assertEqual(servers['items'][0]['properties']['name'], self.resource['volume']['name'])
self.assertEqual(servers['items'][0]['properties']['size'], self.resource['volume']['size'])
self.assertEqual(servers['items'][0]['properties']['bus'], self.resource['volume']['bus'])
self.assertEqual(servers['items'][0]['properties']['type'], self.resource['volume']['type'])
self.assertEqual(servers['items'][0]['properties']['licenceType'], 'UNKNOWN')
self.assertIsNone(servers['items'][0]['properties']['image'])
self.assertIsNone(servers['items'][0]['properties']['imagePassword'])
self.assertFalse(servers['items'][0]['properties']['cpuHotPlug'])
self.assertFalse(servers['items'][0]['properties']['cpuHotUnplug'])
self.assertFalse(servers['items'][0]['properties']['ramHotPlug'])
self.assertFalse(servers['items'][0]['properties']['ramHotUnplug'])
self.assertFalse(servers['items'][0]['properties']['nicHotPlug'])
self.assertFalse(servers['items'][0]['properties']['nicHotUnplug'])
self.assertFalse(servers['items'][0]['properties']['discVirtioHotPlug'])
self.assertFalse(servers['items'][0]['properties']['discVirtioHotUnplug'])
self.assertFalse(servers['items'][0]['properties']['discScsiHotPlug'])
self.assertFalse(servers['items'][0]['properties']['discScsiHotUnplug'])
def test_get_attached_volume(self):
server = self.client.get_attached_volume(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume1['id'])
self.assertEqual(server['id'], self.volume1['id'])
self.assertEqual(server['properties']['name'], self.resource['volume']['name'])
self.assertEqual(server['properties']['size'], self.resource['volume']['size'])
self.assertEqual(server['properties']['bus'], self.resource['volume']['bus'])
self.assertEqual(server['properties']['type'], self.resource['volume']['type'])
self.assertEqual(server['properties']['licenceType'], self.resource['volume']['licence_type'])
self.assertIsNone(server['properties']['image'])
self.assertIsNone(server['properties']['imagePassword'])
self.assertFalse(server['properties']['cpuHotPlug'])
self.assertFalse(server['properties']['cpuHotUnplug'])
self.assertFalse(server['properties']['ramHotPlug'])
self.assertFalse(server['properties']['ramHotUnplug'])
self.assertFalse(server['properties']['nicHotPlug'])
self.assertFalse(server['properties']['nicHotUnplug'])
self.assertFalse(server['properties']['discVirtioHotPlug'])
self.assertFalse(server['properties']['discVirtioHotUnplug'])
self.assertFalse(server['properties']['discScsiHotPlug'])
self.assertFalse(server['properties']['discScsiHotUnplug'])
def test_attach_volume(self):
volume = self.client.attach_volume(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume2['id'])
wait_for_completion(self.client, volume, 'attach_volume')
self.assertEqual(volume['id'], self.volume2['id'])
self.assertEqual(volume['properties']['name'], self.resource['volume']['name'])
self.assertEqual(volume['properties']['size'], self.resource['volume']['size'])
self.assertEqual(volume['properties']['type'], self.resource['volume']['type'])
self.assertEqual(volume['properties']['licenceType'], self.resource['volume']['licence_type'])
self.assertIsNone(volume['properties']['bus'])
self.assertIsNone(volume['properties']['image'])
self.assertIsNone(volume['properties']['imagePassword'])
self.assertFalse(volume['properties']['cpuHotPlug'])
self.assertFalse(volume['properties']['cpuHotUnplug'])
self.assertFalse(volume['properties']['ramHotPlug'])
self.assertFalse(volume['properties']['ramHotUnplug'])
self.assertFalse(volume['properties']['nicHotPlug'])
self.assertFalse(volume['properties']['nicHotUnplug'])
self.assertFalse(volume['properties']['discVirtioHotPlug'])
self.assertFalse(volume['properties']['discVirtioHotUnplug'])
self.assertFalse(volume['properties']['discScsiHotPlug'])
self.assertFalse(volume['properties']['discScsiHotUnplug'])
response = self.client.detach_volume(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume2['id'])
def test_detach_volume(self):
volume = self.client.detach_volume(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
volume_id=self.volume1['id'])
self.assertTrue(volume)
class TestNic(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test LAN.
self.lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(name=self.resource['lan']['name'], public=False))
self.client.wait_for_completion(self.lan)
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(self.server)
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.ips = ['10.0.0.1']
nic1.ips = self.ips
self.nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
self.client.wait_for_completion(self.nic1)
# Create test NIC2.
nic2 = NIC(**self.resource['nic'])
nic2.lan = self.lan['id']
self.nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic2)
self.client.wait_for_completion(self.nic2)
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_nics(self):
nics = self.client.list_nics(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'])
self.assertGreater(len(nics), 0)
self.assertIn(nics['items'][0]['id'], (self.nic1['id'], self.nic2['id']))
self.assertEqual(nics['items'][0]['type'], 'nic')
def test_get_nic(self):
nic = self.client.get_nic(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'])
self.assertEqual(nic['type'], 'nic')
self.assertEqual(nic['id'], self.nic1['id'])
assertRegex(self, nic['id'], self.resource['uuid_match'])
self.assertEqual(nic['properties']['name'], self.resource['nic']['name'])
self.assertEqual(nic['properties']['firewallActive'],
self.resource['nic']['firewall_active'])
self.assertIsInstance(nic['properties']['ips'], list)
self.assertEqual(nic['properties']['dhcp'], self.resource['nic']['dhcp'])
self.assertEqual(nic['properties']['nat'], self.resource['nic']['nat'])
self.assertEqual(nic['properties']['lan'], self.resource['nic']['lan'])
def test_delete_nic(self):
nic2 = self.client.delete_nic(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic2['id'])
self.assertTrue(nic2)
def test_update_nic(self):
nic = self.client.update_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
name=self.resource['nic']['name'] + ' - RENAME')
self.assertEqual(nic['id'], self.nic1['id'])
self.assertEqual(nic['type'], 'nic')
self.assertEqual(nic['properties']['name'], self.resource['nic']['name'] + ' - RENAME')
def test_create_nic(self):
self.assertEqual(self.nic1['type'], 'nic')
self.assertEqual(self.nic1['properties']['name'], self.resource['nic']['name'])
self.assertEqual(self.nic1['properties']['firewallActive'],
self.resource['nic']['firewall_active'])
self.assertIsInstance(self.nic1['properties']['ips'], list)
self.assertEqual(self.nic1['properties']['dhcp'], self.resource['nic']['dhcp'])
self.assertIsNone(self.nic1['properties']['nat'])
self.assertEqual(str(self.nic1['properties']['lan']), self.lan['id'])
def test_get_failure(self):
try:
self.client.get_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
def test_create_failure(self):
try:
nic = NIC(name=self.resource['nic']['name'])
self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic)
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'lan',
e.content[0]['message'])
class TestSnapshot(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test volume
volume = Volume(**self.resource['volume'])
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'], volume=volume)
self.client.wait_for_completion(self.volume)
# Create test volume1
volume1 = Volume(**self.resource['volume'])
self.volume1 = self.client.create_volume(
datacenter_id=self.datacenter['id'], volume=volume1)
self.client.wait_for_completion(self.volume1)
# Create test snapshot
snapshot = Snapshot(**self.resource['snapshot'])
self.snapshot1 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=snapshot.name,
description=snapshot.description)
self.client.wait_for_completion(self.snapshot1)
# Create test snapshot2
self.snapshot2 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name="python sdk test snapshot",
description="snapshot test description")
self.client.wait_for_completion(self.snapshot2)
@classmethod
def tearDownClass(self):
self.client.delete_snapshot(snapshot_id=self.snapshot1['id'])
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_snapshots(self):
snapshots = self.client.list_snapshots()
self.assertGreater(len(snapshots['items']), 0)
self.assertEqual(snapshots['items'][0]['type'], 'snapshot')
def test_get_snapshot(self):
snapshot = self.client.get_snapshot(snapshot_id=self.snapshot1['id'])
self.assertEqual(snapshot['type'], 'snapshot')
self.assertEqual(snapshot['id'], self.snapshot1['id'])
self.assertEqual(snapshot['properties']['name'],
self.resource['snapshot']['name'])
self.assertTrue(snapshot['properties']['description'],
self.resource['snapshot']['description'])
self.assertEqual(snapshot['properties']['location'],
configuration.LOCATION)
self.assertEqual(snapshot['properties']['size'],
self.volume['properties']['size'])
self.assertEqual(snapshot['properties']['cpuHotPlug'],
self.volume['properties']['cpuHotPlug'])
self.assertEqual(snapshot['properties']['cpuHotUnplug'],
self.volume['properties']['cpuHotUnplug'])
self.assertEqual(snapshot['properties']['ramHotPlug'],
self.volume['properties']['ramHotPlug'])
self.assertEqual(snapshot['properties']['ramHotUnplug'],
self.volume['properties']['ramHotUnplug'])
self.assertEqual(snapshot['properties']['nicHotPlug'],
self.volume['properties']['nicHotPlug'])
self.assertEqual(snapshot['properties']['nicHotUnplug'],
self.volume['properties']['nicHotUnplug'])
self.assertEqual(snapshot['properties']['discVirtioHotPlug'],
self.volume['properties']['discVirtioHotPlug'])
self.assertEqual(snapshot['properties']['discVirtioHotUnplug'],
self.volume['properties']['discVirtioHotUnplug'])
self.assertEqual(snapshot['properties']['discScsiHotPlug'],
self.volume['properties']['discScsiHotPlug'])
self.assertEqual(snapshot['properties']['discScsiHotUnplug'],
self.volume['properties']['discScsiHotUnplug'])
self.assertEqual(snapshot['properties']['licenceType'],
self.volume['properties']['licenceType'])
def test_delete_snapshot(self):
snapshot = self.client.delete_snapshot(
snapshot_id=self.snapshot2['id'])
self.assertTrue(snapshot)
def test_update_snapshot(self):
snapshot = self.client.update_snapshot(
snapshot_id=self.snapshot1['id'],
name=self.resource['snapshot']['name'] + ' - RENAME',
description=self.resource['snapshot']['description'] + ' - RENAME')
self.client.wait_for_completion(snapshot)
self.assertEqual(snapshot['type'], 'snapshot')
self.assertEqual(snapshot['properties']['name'],
self.resource['snapshot']['name'] + ' - RENAME')
self.assertEqual(
snapshot['properties']['description'],
self.resource['snapshot']['description'] + ' - RENAME')
def test_create_snapshot(self):
self.assertEqual(self.snapshot1['type'], 'snapshot')
self.assertEqual(self.snapshot1['properties']['name'],
self.resource['snapshot']['name'])
self.assertEqual(self.snapshot1['properties']['description'],
self.resource['snapshot']['description'])
def test_get_failure(self):
try:
self.client.get_snapshot('00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_failure(self):
try:
self.client.create_snapshot(
datacenter_id='00000000-0000-0000-0000-000000000000',
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'])
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
class TestDatacenter(unittest.TestCase):
def setUp(self):
self.datacenter = ProfitBricksService(
username='******', password='******')
def test_get_all(self):
datacenters = self.datacenter.list_datacenters()
self.assertEqual(len(datacenters), 4)
self.assertEqual(datacenters['items'][0]['id'], datacenter_id)
# self.assertEqual(
# datacenters['items'][0]['properties']['name'], 'datacenter1')
# self.assertEqual(
# datacenters['items'][0]['properties']['description'], 'Description of my DC')
# self.assertEqual(
# datacenters['items'][0]['properties']['location'], 'de/fkb')
# self.assertEqual(
# datacenters['items'][0]['properties']['version'], 4)
def test_get(self):
datacenter = self.datacenter.get_datacenter(
datacenter_id=datacenter_id)
self.assertEqual(datacenter['id'], datacenter_id)
self.assertEqual(datacenter['properties']['name'], 'datacenter1')
self.assertEqual(datacenter['properties']['description'], 'Description of my DC')
self.assertEqual(datacenter['properties']['version'], 4)
self.assertEqual(datacenter['properties']['location'], 'de/fkb')
def test_delete(self):
datacenter = self.datacenter.delete_datacenter(
datacenter_id=datacenter_id)
self.assertTrue(datacenter)
def test_update(self):
datacenter = self.datacenter.update_datacenter(
datacenter_id=datacenter_id,
name='Partially updated datacenter name')
self.assertEqual(datacenter['id'], datacenter_id)
self.assertEqual(datacenter['properties']['name'], 'datacenter1')
self.assertEqual(datacenter['properties']['description'], 'Description of my DC')
self.assertEqual(datacenter['properties']['version'], 4)
self.assertEqual(datacenter['properties']['location'], 'de/fkb')
def test_create_simple(self):
i = Datacenter(
name='datacenter1',
description='My New Datacenter',
location='de/fkb'
)
response = self.datacenter.create_datacenter(datacenter=i)
self.assertEqual(response['id'], datacenter_id)
self.assertEqual(response['properties']['name'], 'My New Datacenter')
self.assertEqual(response['properties']['description'], 'Production environment')
self.assertEqual(response['properties']['version'], 4)
self.assertEqual(response['properties']['location'], 'de/fkb')
def test_create_complex(self):
"""
Creates a complex Datacenter in a single request.
"""
fwrule1 = FirewallRule(
name='Open SSH port',
protocol='TCP',
source_mac='01:23:45:67:89:00',
port_range_start=22
)
fwrule2 = FirewallRule(
name='Allow PING',
protocol='ICMP',
icmp_type=8,
icmp_code=0
)
fw_rules = [fwrule1, fwrule2]
nic1 = NIC(
name='nic1',
ips=['10.2.2.3'],
dhcp='true',
lan=1,
firewall_active=True,
firewall_rules=fw_rules
)
nic2 = NIC(
name='nic2',
ips=['10.2.3.4'],
dhcp='true',
lan=1,
firewall_active=True,
firewall_rules=fw_rules
)
nics = [nic1, nic2]
volume1 = Volume(
name='volume1',
size=56,
image='<IMAGE/SNAPSHOT-ID>',
bus='VIRTIO'
)
volume2 = Volume(
name='volume2',
size=56,
image='<IMAGE/SNAPSHOT-ID>',
bus='VIRTIO'
)
volumes = [volume2]
server1 = Server(
name='server1',
ram=4096,
cores=4,
nics=nics,
create_volumes=[volume1]
)
servers = [server1]
balancednics = ['<NIC-ID-1>', '<NIC-ID-2>']
loadbalancer1 = LoadBalancer(
name='My LB',
balancednics=balancednics)
loadbalancers = [loadbalancer1]
lan1 = LAN(
name='public Lan 4',
public=True
)
lan2 = LAN(
name='public Lan 4',
public=True
)
lans = [lan1, lan2]
d = Datacenter(
name='datacenter1',
description='my DC',
location='de/fkb',
servers=servers,
volumes=volumes,
loadbalancers=loadbalancers,
lans=lans
)
response = self.datacenter.create_datacenter(datacenter=d)
print(response)
self.assertEqual(response['id'], datacenter_id)
self.assertEqual(response['properties']['name'], 'My New Datacenter')
self.assertEqual(response['properties']['description'], 'Production environment')
self.assertEqual(response['properties']['version'], 4)
self.assertEqual(response['properties']['location'], 'de/fkb')