def test_delete_entry_fields_on_delete_server_response(self):
"""
Verify that the Delete entry will have all expected fields
after Server Delete
"""
self.assertEqual(
self.deleted_server.id, self.event_delete.instance,
self.msg.format("instance", self.deleted_server.id,
self.event_delete.instance,
self.delete_response.reason,
self.delete_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.launched_at_created_server),
string_to_datetime(self.event_delete.launched_at),
timedelta(seconds=self.leeway)),
self.msg.format("launched_at", self.launched_at_created_server,
self.event_delete.launched_at,
self.delete_response.reason,
self.delete_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.deleted_at),
string_to_datetime(self.event_delete.deleted_at),
timedelta(seconds=self.leeway)),
self.msg.format("deleted_at", self.deleted_at,
self.event_delete.deleted_at,
self.delete_response.reason,
self.delete_response.content))
def test_delete_entry_fields_on_delete_server_response(self):
"""
Verify that the Delete entry will have all expected fields
after Server Delete
"""
self.assertEqual(self.deleted_server.id, self.event_delete.instance,
self.msg.format("instance",
self.deleted_server.id,
self.event_delete.instance,
self.delete_response.reason,
self.delete_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.launched_at_created_server),
string_to_datetime(self.event_delete.launched_at),
timedelta(seconds=self.leeway)),
self.msg.format("launched_at",
self.launched_at_created_server,
self.event_delete.launched_at,
self.delete_response.reason,
self.delete_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.deleted_at),
string_to_datetime(self.event_delete.deleted_at),
timedelta(seconds=self.leeway)),
self.msg.format("deleted_at",
self.deleted_at,
self.event_delete.deleted_at,
self.delete_response.reason,
self.delete_response.content))
def test_launched_earlier_than_deleted_on_delete_server_response(self):
"""
Verify that the Delete entry launched_at is earlier than the
Delete entry deleted_at for a deleted server
"""
self.assertLess(
string_to_datetime(self.event_delete.launched_at),
string_to_datetime(self.event_delete.deleted_at),
self.msg.format(
"launched_at", "launched_at earlier than deleted_at",
' '.join([
self.event_delete.launched_at, self.event_delete.deleted_at
]), self.delete_response.reason, self.delete_response.content))
def test_launched_earlier_than_deleted_on_delete_server_response(self):
"""
Verify that the Delete entry launched_at is earlier than the
Delete entry deleted_at for a deleted server
"""
self.assertLess(
string_to_datetime(self.event_delete.launched_at),
string_to_datetime(self.event_delete.deleted_at),
self.msg.format("launched_at",
"launched_at earlier than deleted_at",
' '.join([self.event_delete.launched_at,
self.event_delete.deleted_at]),
self.delete_response.reason,
self.delete_response.content))
def test_get_launches_by_date_max(self):
"""
@summary: Verify that Get Launches by maximum date
returns 200 Success response
1. Get Launches for the past few days
2. Iterate through the list to look for a non null launched_at
3. Add 1 day to the launched at for maximum date filter
"""
date_min = datetime.utcnow() - timedelta(days=int(self.days_passed))
response = (self.stacktach_db_behavior
.list_launches_by_date_min(launched_at_min=date_min))
for launch in response.entity:
if launch.launched_at is not None:
launched_at = str(launch.launched_at)
break
# Microseconds may or may not be returned
date_obj = string_to_datetime(launched_at)
date_max = date_obj + timedelta(days=1)
response = (self.stacktach_db_behavior
.list_launches_by_date_max(launched_at_max=date_max))
self.assertEqual(response.status_code, 200,
self.msg.format("status code", "200",
response.status_code,
response.reason,
response.content))
self.verify_launches_entity_attribute_values(response.entity)
def validate_exist_entry_audit_period_values(
self, expected_audit_period_ending,
expected_audit_period_beginning, event_exist_server=None):
"""
@summary: Validate that the Exist entry will have all expected values
related to audit periods
@param expected_audit_period_ending: The expected audit period ending
of the server
@type expected_audit_period_ending: datetime
@param expected_audit_period_beginning: The expected audit period
beginning of the server
@type expected_audit_period_beginning: datetime
@param event_exist_server: Details of the event Exist from DB
@type event_exist_server: ServerExists
"""
self.event_exist_server = self.event_exist
if event_exist_server:
self.event_exist_server = event_exist_server
self.assertTrue(EqualityTools.are_datetimes_equal(
string_to_datetime(expected_audit_period_ending),
string_to_datetime(self.event_exist_server.audit_period_ending),
timedelta(seconds=self.leeway)))
self.assertTrue(EqualityTools.are_datetimes_equal(
string_to_datetime(expected_audit_period_beginning),
string_to_datetime(self.event_exist_server.audit_period_beginning),
timedelta(seconds=self.leeway)))
self.assertTrue(EqualityTools.are_datetimes_equal(
string_to_datetime(expected_audit_period_ending),
string_to_datetime(self.event_exist_server.received),
timedelta(seconds=self.leeway)))
def test_exists_entry_fields_on_rescue_server_response(self):
"""
Verify that the Exist entry will have all expected fields
after Server Rescue
"""
self.validate_exist_entry_field_values(server=self.unrescued_server)
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.rescue_start_time),
string_to_datetime(self.event_exist.audit_period_ending),
timedelta(seconds=self.leeway),
)
)
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.audit_period_beginning),
string_to_datetime(self.event_exist.audit_period_beginning),
timedelta(seconds=self.leeway),
)
)
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.rescue_start_time),
string_to_datetime(self.event_exist.received),
timedelta(seconds=self.leeway),
)
)
def test_get_deletes_by_date_max(self):
"""
@summary: Verify that Get Deletes by maximum date
returns 200 Success response
1. Get Deletes for the past few days
2. Choose the first deleted at for maximum date filter
"""
date_min = datetime.utcnow() - timedelta(days=int(self.days_passed))
response = self.stacktach_db_behavior.list_deletes_by_date_min(deleted_at_min=date_min)
deleted_at = response.entity[0].deleted_at
# Microseconds may or may not be returned
date_max = string_to_datetime(deleted_at)
response = self.stacktach_db_behavior.list_deletes_by_date_max(deleted_at_max=date_max)
self.assertEqual(
response.status_code,
200,
self.msg.format("status code", "200", response.status_code, response.reason, response.content),
)
self.verify_deletes_entity_attribute_values(response.entity)
def test_get_deletes_by_date_max(self):
"""
@summary: Verify that Get Deletes by maximum date
returns 200 Success response
1. Get Deletes for the past few days
2. Choose the first deleted at for maximum date filter
"""
date_min = datetime.utcnow() - timedelta(days=int(self.days_passed))
response = (self.stacktach_db_behavior.list_deletes_by_date_min(
deleted_at_min=date_min))
deleted_at = response.entity[0].deleted_at
# Microseconds may or may not be returned
date_max = string_to_datetime(deleted_at)
response = (self.stacktach_db_behavior.list_deletes_by_date_max(
deleted_at_max=date_max))
self.assertEqual(
response.status_code, 200,
self.msg.format("status code", "200", response.status_code,
response.reason, response.content))
self.verify_deletes_entity_attribute_values(response.entity)
def test_exists_entry_fields_on_rescue_server_response(self):
"""
Verify that the Exist entry will have all expected fields
after Server Rescue
"""
self.validate_exist_entry_field_values(server=self.unrescued_server)
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.rescue_start_time),
string_to_datetime(self.event_exist.audit_period_ending),
timedelta(seconds=self.leeway)))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.audit_period_beginning),
string_to_datetime(self.event_exist.audit_period_beginning),
timedelta(seconds=self.leeway)))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.rescue_start_time),
string_to_datetime(self.event_exist.received),
timedelta(seconds=self.leeway)))
def validate_exist_entry_audit_period_values(
self,
expected_audit_period_ending,
expected_audit_period_beginning,
event_exist_server=None):
"""
@summary: Validate that the Exist entry will have all expected values
related to audit periods
@param expected_audit_period_ending: The expected audit period ending
of the server
@type expected_audit_period_ending: datetime
@param expected_audit_period_beginning: The expected audit period
beginning of the server
@type expected_audit_period_beginning: datetime
@param event_exist_server: Details of the event Exist from DB
@type event_exist_server: ServerExists
"""
self.event_exist_server = self.event_exist
if event_exist_server:
self.event_exist_server = event_exist_server
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(expected_audit_period_ending),
string_to_datetime(
self.event_exist_server.audit_period_ending),
timedelta(seconds=self.leeway)))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(expected_audit_period_beginning),
string_to_datetime(
self.event_exist_server.audit_period_beginning),
timedelta(seconds=self.leeway)))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(expected_audit_period_ending),
string_to_datetime(self.event_exist_server.received),
timedelta(seconds=self.leeway)))
def validate_exist_entry_field_values(self,
server,
event_exist_server=None,
expected_flavor_ref=None,
launched_at=None):
"""
@summary: Validate that the Exist entry will have all expected values
@param server: Details of the server created in test
@type server: Server
@param event_exist_server: Details of the event Exist from DB
@type event_exist_server: ServerExists
@param expected_flavor_ref: The expected flavor to verify against
@type expected_flavor_ref: String
@param launched_at: The launched_at time of the server
@type launched_at: datetime
"""
self.event_exist_server = self.event_exist
if event_exist_server:
self.event_exist_server = event_exist_server
self.expected_flavor_ref = self.flavor_ref
if expected_flavor_ref:
self.expected_flavor_ref = expected_flavor_ref
self.launched_at = self.launched_at_created_server
if launched_at:
self.launched_at = launched_at
self.assertEqual(
server.id, self.event_exist_server.instance,
self.msg.format("instance", self.created_server.id,
self.event_exist_server.instance,
self.exist_response.reason,
self.exist_response.content))
self.assertEqual(
server.flavor.id, self.event_exist_server.instance_type_id,
self.msg.format("instance_type_id", self.created_server.flavor.id,
self.event_exist_server.instance_type_id,
self.exist_response.reason,
self.exist_response.content))
self.assertEqual(
self.expected_flavor_ref, self.event_exist_server.instance_type_id,
self.msg.format("instance_type_id", self.expected_flavor_ref,
self.event_exist_server.instance_type_id,
self.exist_response.reason,
self.exist_response.content))
self.assertEqual(
self.expected_flavor_ref,
self.event_exist_server.instance_flavor_id,
self.msg.format("instance_flavor_id", self.expected_flavor_ref,
self.event_exist_server.instance_flavor_id,
self.exist_response.reason,
self.exist_response.content))
self.assertIn(
self.event_exist_server.status, ['pending', 'verified'],
self.msg.format("status", "Not None, Empty or unexpected value",
self.event_exist_server.status,
self.exist_response.reason,
self.exist_response.content))
self.assertIn(
self.event_exist_server.send_status, [0, 201],
self.msg.format("send_status",
"Not None, Empty or unexpected value",
self.event_exist_server.status,
self.exist_response.reason,
self.exist_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.launched_at),
string_to_datetime(self.event_exist_server.launched_at),
timedelta(seconds=self.leeway)),
self.msg.format("launched_at", self.launched_at,
self.event_exist_server.launched_at,
self.exist_response.reason,
self.exist_response.content))
def validate_launch_entry_field_values(self,
server,
event_launch_server=None,
expected_flavor_ref=None,
launched_at=None):
"""
@summary: Validate that the Launch entry will have all expected values
@param server: Details of the server created in test
@type server: Server
@param event_launch_server: Details of the event Launch from DB
@type event_launch_server: ServerLaunch
@param expected_flavor_ref: The expected flavor to verify against
@type expected_flavor_ref: String
@param launched_at: The launched_at time of the server
@type launched_at: datetime
"""
self.event_launch_server = self.event_launch
if event_launch_server:
self.event_launch_server = event_launch_server
self.expected_flavor_ref = self.flavor_ref
if expected_flavor_ref:
self.expected_flavor_ref = expected_flavor_ref
self.launched_at = self.launched_at_created_server
if launched_at:
self.launched_at = launched_at
self.assertEqual(
server.id, self.event_launch_server.instance,
self.msg.format("instance", server.id,
self.event_launch_server.instance,
self.launch_response.reason,
self.launch_response.content))
self.assertEqual(
server.flavor.id, self.event_launch_server.instance_type_id,
self.msg.format("instance_type_id", server.flavor.id,
self.event_launch_server.instance_type_id,
self.launch_response.reason,
self.launch_response.content))
self.assertEqual(
self.expected_flavor_ref,
self.event_launch_server.instance_type_id,
self.msg.format("instance_type_id", self.expected_flavor_ref,
self.event_launch_server.instance_type_id,
self.launch_response.reason,
self.launch_response.content))
self.assertEqual(
self.expected_flavor_ref,
self.event_launch_server.instance_flavor_id,
self.msg.format("instance_flavor_id", self.expected_flavor_ref,
self.event_launch_server.instance_flavor_id,
self.launch_response.reason,
self.launch_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.launched_at),
string_to_datetime(self.event_launch_server.launched_at),
timedelta(seconds=self.leeway)),
self.msg.format("launched_at", self.launched_at,
self.event_launch_server.launched_at,
self.launch_response.reason,
self.launch_response.content))
def validate_exist_entry_field_values(self, server,
event_exist_server=None,
expected_flavor_ref=None,
launched_at=None):
"""
@summary: Validate that the Exist entry will have all expected values
@param server: Details of the server created in test
@type server: Server
@param event_exist_server: Details of the event Exist from DB
@type event_exist_server: ServerExists
@param expected_flavor_ref: The expected flavor to verify against
@type expected_flavor_ref: String
@param launched_at: The launched_at time of the server
@type launched_at: datetime
"""
self.event_exist_server = self.event_exist
if event_exist_server:
self.event_exist_server = event_exist_server
self.expected_flavor_ref = self.flavor_ref
if expected_flavor_ref:
self.expected_flavor_ref = expected_flavor_ref
self.launched_at = self.launched_at_created_server
if launched_at:
self.launched_at = launched_at
self.assertEqual(server.id, self.event_exist_server.instance,
self.msg.format("instance",
self.created_server.id,
self.event_exist_server.instance,
self.exist_response.reason,
self.exist_response.content))
self.assertEqual(server.flavor.id,
self.event_exist_server.instance_type_id,
self.msg.format(
"instance_type_id",
self.created_server.flavor.id,
self.event_exist_server.instance_type_id,
self.exist_response.reason,
self.exist_response.content))
self.assertEqual(self.expected_flavor_ref,
self.event_exist_server.instance_type_id,
self.msg.format(
"instance_type_id",
self.expected_flavor_ref,
self.event_exist_server.instance_type_id,
self.exist_response.reason,
self.exist_response.content))
self.assertEqual(self.expected_flavor_ref,
self.event_exist_server.instance_flavor_id,
self.msg.format(
"instance_flavor_id",
self.expected_flavor_ref,
self.event_exist_server.instance_flavor_id,
self.exist_response.reason,
self.exist_response.content))
self.assertIn(self.event_exist_server.status, ['pending', 'verified'],
self.msg.format("status",
"Not None, Empty or unexpected value",
self.event_exist_server.status,
self.exist_response.reason,
self.exist_response.content))
self.assertIn(self.event_exist_server.send_status, [0, 201],
self.msg.format("send_status",
"Not None, Empty or unexpected value",
self.event_exist_server.status,
self.exist_response.reason,
self.exist_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.launched_at),
string_to_datetime(self.event_exist_server.launched_at),
timedelta(seconds=self.leeway)),
self.msg.format("launched_at",
self.launched_at,
self.event_exist_server.launched_at,
self.exist_response.reason,
self.exist_response.content))
def validate_launch_entry_field_values(self, server,
event_launch_server=None,
expected_flavor_ref=None,
launched_at=None):
"""
@summary: Validate that the Launch entry will have all expected values
@param server: Details of the server created in test
@type server: Server
@param event_launch_server: Details of the event Launch from DB
@type event_launch_server: ServerLaunch
@param expected_flavor_ref: The expected flavor to verify against
@type expected_flavor_ref: String
@param launched_at: The launched_at time of the server
@type launched_at: datetime
"""
self.event_launch_server = self.event_launch
if event_launch_server:
self.event_launch_server = event_launch_server
self.expected_flavor_ref = self.flavor_ref
if expected_flavor_ref:
self.expected_flavor_ref = expected_flavor_ref
self.launched_at = self.launched_at_created_server
if launched_at:
self.launched_at = launched_at
self.assertEqual(server.id,
self.event_launch_server.instance,
self.msg.format(
"instance",
server.id,
self.event_launch_server.instance,
self.launch_response.reason,
self.launch_response.content))
self.assertEqual(server.flavor.id,
self.event_launch_server.instance_type_id,
self.msg.format(
"instance_type_id",
server.flavor.id,
self.event_launch_server.instance_type_id,
self.launch_response.reason,
self.launch_response.content))
self.assertEqual(self.expected_flavor_ref,
self.event_launch_server.instance_type_id,
self.msg.format(
"instance_type_id",
self.expected_flavor_ref,
self.event_launch_server.instance_type_id,
self.launch_response.reason,
self.launch_response.content))
self.assertEqual(self.expected_flavor_ref,
self.event_launch_server.instance_flavor_id,
self.msg.format(
"instance_flavor_id",
self.expected_flavor_ref,
self.event_launch_server.instance_flavor_id,
self.launch_response.reason,
self.launch_response.content))
self.assertTrue(
EqualityTools.are_datetimes_equal(
string_to_datetime(self.launched_at),
string_to_datetime(self.event_launch_server.launched_at),
timedelta(seconds=self.leeway)),
self.msg.format("launched_at",
self.launched_at,
self.event_launch_server.launched_at,
self.launch_response.reason,
self.launch_response.content))