def tearDownClass(cls):
job = cls.conn.load_balancer.delete_load_balancer(cls.lb)
job = _job.Job(id=job.job_id)
resource2.wait_for_status(cls.conn.load_balancer._session,
job,
"SUCCESS",
interval=3,
failures=["FAIL"])
def tearDownClass(cls):
# delete listener created in setup
cls.conn.load_balancer.delete_listener(cls.listener)
# delete load balancer created in setup
job = cls.conn.load_balancer.delete_load_balancer(cls.lb)
job = _job.Job(id=job.job_id)
resource2.wait_for_status(cls.conn.load_balancer._session,
job,
"SUCCESS",
interval=5,
failures=["FAIL"])
def test_5_remove_router_of_zone(self):
resource2.wait_for_status(self.conn.dns._session,
self.zone,
"ACTIVE",
interval=5,
failures=["ERROR"])
result = self.conn.dns.remove_router_from_zone(self.zone, **{
"router_id": self.router.id,
"router_region": "eu-de"
})
self.assertEqual(result.router_id, self.router.id)
self.assertEqual(result.router_region, "eu-de")
def setUpClass(cls):
super(TestRecordset, cls).setUpClass()
# get a router
cls.router = cls.get_first_router()
# create zone for test
cls.zone = test_zone.auto_create_private_zone(cls.conn, cls.ZONE_NAME,
cls.router.id, "eu-de")
# waiting until zone's status turn into ACTIVE
resource2.wait_for_status(cls.conn.dns._session,
cls.zone,
"ACTIVE",
interval=5,
failures=["ERROR"])
cls.recordset = auto_create_recordset(cls.conn, cls.zone, cls.NAME)
def wait_for_status(self,
value,
status,
failures=[],
interval=2,
wait=120):
"""Wait for a resource to be in a particular status.
:param value: The resource to wait on to reach the status. The
resource must have a status attribute.
:type value: :class:`~openstack.resource2.Resource`
:param status: Desired status of the resource2.
:param list failures: Statuses that would indicate the transition
failed such as 'ERROR'.
:param interval: Number of seconds to wait between checks.
:param wait: Maximum number of seconds to wait for the change.
:return: Method returns resource on success.
:raises: :class:`~openstack.exceptions.ResourceTimeout` transition
to status failed to occur in wait seconds.
:raises: :class:`~openstack.exceptions.ResourceFailure` resource
transitioned to one of the failure states.
:raises: :class:`~AttributeError` if the resource does not have a
status attribute
"""
return resource2.wait_for_status(self._session, value, status,
failures, interval, wait)
def wait_for_status(self,
resource,
status,
failures=[],
interval=2,
wait=120):
"""Wait for a resource to be in a particular status.
:param resource: The resource to wait on to reach the specified status.
The resource must have a ``status`` attribute.
:type resource: A :class:`~openstack.resource2.Resource` object.
:param status: Desired status.
:param failures: Statuses that would be interpreted as failures.
:type failures: :py:class:`list`
:param interval: Number of seconds to wait before to consecutive
checks. Default to 2.
:param wait: Maximum number of seconds to wait before the change.
Default to 120.
:returns: The resource is returned on success.
:raises: :class:`~openstack.exceptions.ResourceTimeout` if transition
to the desired status failed to occur in specified seconds.
:raises: :class:`~openstack.exceptions.ResourceFailure` if the resource
has transited to one of the failure statuses.
:raises: :class:`~AttributeError` if the resource does not have a
``status`` attribute.
"""
return resource2.wait_for_status(self._session, resource, status,
failures, interval, wait)
def test_4_add_router_to_zone(self):
resource2.wait_for_status(self.conn.dns._session,
self.zone,
"ACTIVE",
interval=5,
failures=["ERROR"])
result = self.conn.dns.add_router_to_zone(self.zone, **{
"router_id": self.router2.id,
"router_region": "eu-de"
})
self.assertEqual(result.router_id, self.router2.id)
self.assertEqual(result.router_region, "eu-de")
zone = self.conn.dns.get_zone(self.zone)
self.assertEqual(2, len(zone.routers))
router_ids = [_router["router_id"] for _router in zone.routers]
self.assertIn(self.router.id, router_ids)
def wait_for_execution(self,
execution,
status='SUCCESS',
failures=['ERROR'],
interval=2,
wait=120):
return resource2.wait_for_status(self.session, execution, status,
failures, interval, wait)
def wait_for_server(self,
server,
status='ACTIVE',
failures=['ERROR'],
interval=2,
wait=120):
return resource2.wait_for_status(self._session, server, status,
failures, interval, wait)
def test_immediate_status(self):
status = "loling"
resource = mock.Mock()
resource.status = status
result = resource2.wait_for_status("session", resource, status,
"failures", "interval", "wait")
self.assertEqual(result, resource)
def test_immediate_status(self):
status = "loling"
resource = mock.Mock()
resource.status = status
result = resource2.wait_for_status("session", resource, status,
"failures", "interval", "wait")
self.assertEqual(result, resource)
def test_update_lb(self):
updated = {
"description": "lb created by functional test",
"bandwidth": 2,
"admin_state_up": True
}
job = self.conn.load_balancer.update_load_balancer(self.lb, **updated)
job = _job.Job(id=job.job_id)
resource2.wait_for_status(self.conn.load_balancer._session,
job,
"SUCCESS",
interval=3,
failures=["FAIL"])
self.conn.load_balancer.wait_for_status(job, "SUCCESS", interval=2)
lb = self.conn.load_balancer.get_load_balancer(self.lb)
self.assertEqual(updated["description"], lb.description)
self.assertEqual(updated["bandwidth"], lb.bandwidth)
self.assertEqual(updated["admin_state_up"], lb.is_admin_state_up)
self.lb = lb
def test_status_match(self, mock_sleep):
status = "loling"
resource = mock.Mock()
# other gets past the first check, two anothers gets through
# the sleep loop, and the third matches
statuses = ["other", "another", "another", status]
type(resource).status = mock.PropertyMock(side_effect=statuses)
result = resource2.wait_for_status("session", resource, status,
None, 1, 5)
self.assertEqual(result, resource)
def test_status_match(self, mock_sleep):
status = "loling"
resource = mock.Mock()
# other gets past the first check, two anothers gets through
# the sleep loop, and the third matches
statuses = ["other", "another", "another", status]
type(resource).status = mock.PropertyMock(side_effect=statuses)
result = resource2.wait_for_status("session", resource, status, None,
1, 5)
self.assertEqual(result, resource)
def auto_create_external_lb(conn, name, vpc_id):
"""auto create a lb for functional test
:param conn:
:param name:
:return:
"""
_lb = {
"name": name,
"vpc_id": vpc_id,
"bandwidth": 1,
"type": "External",
"is_admin_state_up": True
}
job = conn.load_balancer.create_load_balancer(**_lb)
job = _job.Job(id=job.job_id)
resource2.wait_for_status(conn.load_balancer._session,
job,
"SUCCESS",
interval=3,
failures=["FAIL"])
elb_id = job.entities["elb"]["id"]
return conn.load_balancer.get_load_balancer(elb_id)
def test_operate_members(self):
members = []
servers = self.conn.compute.servers()
for server in servers:
vpc_list = server.addresses.keys()
if self.router.id in vpc_list:
addr = server.addresses[self.router.id][0]["addr"]
members.append(dict(server_id=server.id, address=addr))
if len(members) == 2:
break
job = self.conn.load_balancer.add_members_to_listener(
self.listener, members)
# waiting for add members job done
job = _job.Job(id=job.id)
resource2.wait_for_status(self.conn.load_balancer._session,
job,
"SUCCESS",
interval=5,
failures=["FAIL"])
added_members = self.conn.load_balancer.listener_members(self.listener)
self.assertEqual(2, len(list(added_members)))
member_ids = [member["server_id"] for member in members]
job = self.conn.load_balancer.remove_members_of_listener(
self.listener, member_ids)
job = _job.Job(id=job.id)
resource2.wait_for_status(self.conn.load_balancer._session,
job,
"SUCCESS",
interval=5,
failures=["FAIL"])
added_members = self.conn.load_balancer.listener_members(self.listener)
self.assertEqual(0, len(list(added_members)))
def wait_for_status(self, value, status, failures=[], interval=2,
wait=120):
"""Wait for a resource to be in a particular status.
:param value: The resource to wait on to reach the status. The
resource must have a status attribute.
:type value: :class:`~openstack.resource2.Resource`
:param status: Desired status of the resource2.
:param list failures: Statuses that would indicate the transition
failed such as 'ERROR'.
:param interval: Number of seconds to wait between checks.
:param wait: Maximum number of seconds to wait for the change.
:return: Method returns resource on success.
:raises: :class:`~openstack.exceptions.ResourceTimeout` transition
to status failed to occur in wait seconds.
:raises: :class:`~openstack.exceptions.ResourceFailure` resource
transitioned to one of the failure states.
:raises: :class:`~AttributeError` if the resource does not have a
status attribute
"""
return resource2.wait_for_status(self.session, value, status,
failures, interval, wait)
def wait_for_server(self, server, status='ACTIVE', failures=['ERROR'],
interval=2, wait=120):
return resource2.wait_for_status(self.session, server, status,
failures, interval, wait)
