def test_index_marker_not_found(self, mock_get_all, mock_segment): req = fakes.HTTPRequest.blank('/v1/segments/%s/hosts?marker=123456' % ( uuidsentinel.fake_segment1), use_admin_context=True) mock_segment.return_value = mock.Mock() mock_get_all.side_effect = exception.MarkerNotFound(marker="123456") self.assertRaises(exc.HTTPBadRequest, self.controller.index, req, uuidsentinel.fake_segment1)
def test_get_limit_and_marker_invalid_marker(self, mock_api_get): host_name = 'fake-host' mock_api_get.side_effect = exception.MarkerNotFound(marker=host_name) self.assertRaises(exception.MarkerNotFound, host.HostList.get_all, self.context, limit=5, marker=host_name)
def test_get_limit_and_marker_invalid_marker(self, mock_api_get): segment_name = 'unknown_segment' mock_api_get.side_effect = exception.MarkerNotFound(marker=segment_name ) self.assertRaises(exception.MarkerNotFound, segment.FailoverSegmentList.get_all, self.context, limit=5, marker=segment_name)
def test_get_all_marker_not_found(self, mock_get_all): mock_get_all.side_effect = exception.MarkerNotFound(marker="100") self.req = fakes.HTTPRequest.blank('/v1/notifications?marker=100', use_admin_context=True) self.assertRaises(exception.MarkerNotFound, self.notification_api.get_all, self.context, self.req)
def test_get_limit_and_marker_invalid_marker(self, mock_api_get): notification_uuid = uuidsentinel.fake_notification mock_api_get.side_effect = (exception.MarkerNotFound( marker=notification_uuid)) self.assertRaises(exception.MarkerNotFound, notification.NotificationList.get_all, self.context, limit=5, marker=notification_uuid)
def notifications_get_all_by_filters(context, filters=None, sort_keys=None, sort_dirs=None, limit=None, marker=None): # NOTE(Dinesh_Bhor): If the limit is 0 there is no point in even going # to the database since nothing is going to be returned anyway. if limit == 0: return [] sort_keys, sort_dirs = _process_sort_params(sort_keys, sort_dirs) filters = filters or {} query = model_query(context, models.Notification) if 'source_host_uuid' in filters: query = query.filter(models.Notification.source_host_uuid == filters['source_host_uuid']) if 'type' in filters: query = query.filter(models.Notification.type == filters['type']) if 'status' in filters: status = filters['status'] if isinstance(status, (list, tuple, set, frozenset)): column_attr = getattr(models.Notification, 'status') query = query.filter(column_attr.in_(status)) else: query = query.filter(models.Notification.status == status) if 'generated-since' in filters: generated_since = timeutils.normalize_time(filters['generated-since']) query = query.filter( models.Notification.generated_time >= generated_since) marker_row = None if marker is not None: marker_row = model_query( context, models.Notification).filter_by(id=marker).first() if not marker_row: raise exception.MarkerNotFound(marker=marker) try: query = sqlalchemyutils.paginate_query(query, models.Notification, limit, sort_keys, marker=marker_row, sort_dirs=sort_dirs) except db_exc.InvalidSortKey as err: raise exception.InvalidSortKey(err) return query.all()
def test_get_all_marker_not_found(self, mock_get_all): mock_get_all.side_effect = exception.MarkerNotFound(marker='123') self.assertRaises(exception.MarkerNotFound, self.segment_api.get_all, self.context, filters=None, sort_keys=None, sort_dirs=None, limit=None, marker='123')
def test_get_all_marker_not_found(self, mock_get, mock_get_all): mock_get.return_value = self.failover_segment mock_get_all.side_effect = exception.MarkerNotFound(marker="1234") self.assertRaises(exception.MarkerNotFound, self.host_api.get_all, self.context, filters=None, sort_keys=['created_at'], sort_dirs=['desc'], limit=None, marker="1234")
def host_get_all_by_filters(context, filters=None, sort_keys=None, sort_dirs=None, limit=None, marker=None): # NOTE(Dinesh_Bhor): If the limit is 0 there is no point in even going # to the database since nothing is going to be returned anyway. if limit == 0: return [] sort_keys, sort_dirs = _process_sort_params(sort_keys, sort_dirs) filters = filters or {} query = model_query(context, models.Host).options(joinedload('failover_segment')) if 'failover_segment_id' in filters: query = query.filter( models.Host.failover_segment_id == filters['failover_segment_id']) if 'type' in filters: query = query.filter(models.Host.type == filters['type']) if 'on_maintenance' in filters: query = query.filter( models.Host.on_maintenance == filters['on_maintenance']) if 'reserved' in filters: query = query.filter(models.Host.reserved == filters['reserved']) marker_row = None if marker is not None: marker_row = model_query(context, models.Host).filter_by(id=marker).first() if not marker_row: raise exception.MarkerNotFound(marker=marker) try: query = sqlalchemyutils.paginate_query(query, models.Host, limit, sort_keys, marker=marker_row, sort_dirs=sort_dirs) except db_exc.InvalidSortKey as e: raise exception.InvalidSortKey(e) return query.all()
def failover_segment_get_all_by_filters( context, filters=None, sort_keys=None, sort_dirs=None, limit=None, marker=None): # NOTE(Dinesh_Bhor): If the limit is 0 there is no point in even going # to the database since nothing is going to be returned anyway. if limit == 0: return [] sort_keys, sort_dirs = _process_sort_params(sort_keys, sort_dirs) filters = filters or {} query = model_query(context, models.FailoverSegment) if 'recovery_method' in filters: query = query.filter(models.FailoverSegment.recovery_method == filters[ 'recovery_method']) if 'service_type' in filters: query = query.filter(models.FailoverSegment.service_type == filters[ 'service_type']) marker_row = None if marker is not None: marker_row = model_query(context, models.FailoverSegment ).filter_by(id=marker).first() if not marker_row: raise exception.MarkerNotFound(marker=marker) try: query = sqlalchemyutils.paginate_query(query, models.FailoverSegment, limit, sort_keys, marker=marker_row, sort_dirs=sort_dirs) except db_exc.InvalidSortKey as e: raise exception.InvalidSortKey(e.message) return query.all()
def test_index_marker_not_found(self, mock_get_all): fake_request = fakes.HTTPRequest.blank('/v1/notifications?marker=1234', use_admin_context=True) mock_get_all.side_effect = exception.MarkerNotFound(marker="1234") self.assertRaises(exc.HTTPBadRequest, self.controller.index, fake_request)
class HostTestCase(test.TestCase): """Test Case for host api.""" bad_request = exception.ValidationError def _set_up(self): self.controller = hosts.HostsController() self.req = fakes.HTTPRequest.blank('/v1/segments/%s/hosts' % uuidsentinel.fake_segment1, use_admin_context=True) self.context = self.req.environ['masakari.context'] def setUp(self): super(HostTestCase, self).setUp() self._set_up() @property def app(self): return fakes.wsgi_app_v1(init_only='os-hosts') def _assert_host_data(self, expected, actual): self.assertTrue(obj_base.obj_equal_prims(expected, actual), "The host objects were not equal") @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid') @mock.patch.object(ha_api.HostAPI, 'get_all') def test_index(self, mock_get_all, mock_segment): mock_segment.return_value = mock.Mock() mock_get_all.return_value = HOST_LIST result = self.controller.index(self.req, uuidsentinel.fake_segment1) result = result['hosts'] self._assert_host_data(HOST_LIST, _make_hosts_list(result)) @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid') @mock.patch.object(ha_api.HostAPI, 'get_all') def test_index_valid_on_maintenance(self, mock_get_all, mock_segment): host_list = [{ "name": "host_1", "id": "1", "on_maintenance": True }, { "name": "host_2", "id": "2", "on_maintenance": True }] mock_get_all.return_value = host_list for parameter in ['1', 't', 'true', 'on', 'y', 'yes']: req = fakes.HTTPRequest.blank( '/v1/segments/%s/hosts?on_maintenance=' '%s' % (uuidsentinel.fake_segment1, parameter), use_admin_context=True) result = self.controller.index(req, uuidsentinel.fake_segment1) self.assertIn('hosts', result) self.assertEqual(len(host_list), len(result['hosts'])) for host in result['hosts']: self.assertTrue(host['on_maintenance']) host_list = [{ "name": "host_1", "id": "1", "on_maintenance": False }, { "name": "host_2", "id": "2", "on_maintenance": False }] mock_get_all.return_value = host_list for parameter in ['0', 'f', 'false', 'off', 'n', 'no']: req = fakes.HTTPRequest.blank( '/v1/segments/%s/hosts?on_maintenance=' '%s' % (uuidsentinel.fake_segment1, parameter), use_admin_context=True) result = self.controller.index(req, uuidsentinel.fake_segment1) self.assertIn('hosts', result) self.assertEqual(len(host_list), len(result['hosts'])) for host in result['hosts']: self.assertFalse(host['on_maintenance']) @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid', return_value=mock.Mock()) def test_index_invalid_on_maintenance(self, mock_segment): req = fakes.HTTPRequest.blank('/v1/segments/%s/hosts?on_maintenance=' 'abcd' % uuidsentinel.fake_segment1, use_admin_context=True) self.assertRaises(exc.HTTPBadRequest, self.controller.index, req, uuidsentinel.fake_segment1) @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid') @mock.patch.object(ha_api.HostAPI, 'get_all') def test_index_valid_reserved(self, mock_get_all, mock_segment): host_list = [{ "name": "host_1", "id": "1", "reserved": True }, { "name": "host_2", "id": "2", "reserved": True }] mock_get_all.return_value = host_list for parameter in ['1', 't', 'true', 'on', 'y', 'yes']: req = fakes.HTTPRequest.blank( '/v1/segments/%s/hosts?reserved=' '%s' % (uuidsentinel.fake_segment1, parameter), use_admin_context=True) result = self.controller.index(req, uuidsentinel.fake_segment1) self.assertIn('hosts', result) self.assertEqual(len(host_list), len(result['hosts'])) for host in result['hosts']: self.assertTrue(host['reserved']) host_list = [{ "name": "host_1", "id": "1", "reserved": False }, { "name": "host_2", "id": "2", "reserved": False }] mock_get_all.return_value = host_list for parameter in ['0', 'f', 'false', 'off', 'n', 'no']: req = fakes.HTTPRequest.blank( '/v1/segments/%s/hosts?reserved=' '%s' % (uuidsentinel.fake_segment1, parameter), use_admin_context=True) result = self.controller.index(req, uuidsentinel.fake_segment1) self.assertIn('hosts', result) self.assertEqual(len(host_list), len(result['hosts'])) for host in result['hosts']: self.assertFalse(host['reserved']) @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid', return_value=mock.Mock()) def test_index_invalid_reserved(self, mock_segment): req = fakes.HTTPRequest.blank('/v1/segments/%s/hosts?reserved=' 'abcd' % uuidsentinel.fake_segment1, use_admin_context=True) self.assertRaises(exc.HTTPBadRequest, self.controller.index, req, uuidsentinel.fake_segment1) @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid') @mock.patch.object(ha_api.HostAPI, 'get_all') def test_index_marker_not_found(self, mock_get_all, mock_segment): req = fakes.HTTPRequest.blank('/v1/segments/%s/hosts?marker=123456' % (uuidsentinel.fake_segment1), use_admin_context=True) mock_segment.return_value = mock.Mock() mock_get_all.side_effect = exception.MarkerNotFound(marker="123456") self.assertRaises(exc.HTTPBadRequest, self.controller.index, req, uuidsentinel.fake_segment1) def test_get_all_marker_negative(self): req = fakes.HTTPRequest.blank('/v1/segments/%s/hosts?limit=-1' % (uuidsentinel.fake_segment1), use_admin_context=True) self.assertRaises(exc.HTTPBadRequest, self.controller.index, req, uuidsentinel.fake_segment1) @ddt.data('sort_key', 'sort_dir') @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid', return_value=mock.Mock()) def test_index_invalid(self, sort_by, mock_segment): req = fakes.HTTPRequest.blank('/v1/segments/%s/hosts?%s=abcd' % (uuidsentinel.fake_segment1, sort_by), use_admin_context=True) self.assertRaises(exc.HTTPBadRequest, self.controller.index, req, uuidsentinel.fake_segment1) @ddt.data([ exception.MarkerNotFound(marker="123456"), "/v1/segments/%s/hosts?marker=123456", exc.HTTPBadRequest ], [ exception.FailoverSegmentNotFound(id=uuidsentinel.fake_segment1), "/v1/segments/%s/hosts", exc.HTTPNotFound ]) @ddt.unpack @mock.patch.object(segment_obj.FailoverSegment, 'get_by_uuid') @mock.patch.object(ha_api.HostAPI, 'get_all') def test_index_not_found(self, masakari_exc, url, exc, mock_get_all, mock_segment): mock_segment.return_value = mock.Mock() mock_get_all.side_effect = masakari_exc req = fakes.HTTPRequest.blank(url % uuidsentinel.fake_segment1, use_admin_context=True) self.assertRaises(exc, self.controller.index, req, uuidsentinel.fake_segment1) @mock.patch.object(ha_api.HostAPI, 'create_host') def test_create(self, mock_create): mock_create.return_value = HOST body = { "host": { "name": "host-1", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } result = self.controller.create(self.req, uuidsentinel.fake_segment1, body=body) result = result['host'] self._assert_host_data(HOST, _make_host_obj(result)) @mock.patch('masakari.rpc.get_client') @mock.patch.object(ha_api.HostAPI, 'create_host') def test_create_success_with_201_response_code(self, mock_client, mock_create): body = { "host": { "name": "host-1", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } fake_req = self.req fake_req.headers['Content-Type'] = 'application/json' fake_req.method = 'POST' fake_req.body = jsonutils.dump_as_bytes(body) resp = fake_req.get_response(self.app) self.assertEqual(http.CREATED, resp.status_code) @mock.patch.object(ha_api.HostAPI, 'create_host') def test_create_with_duplicate_host_name(self, mock_create): mock_create.side_effect = (exception.HostExists(name='host-1')) body = { "host": { "name": "host-1", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } self.assertRaises(exc.HTTPConflict, self.controller.create, self.req, uuidsentinel.fake_segment1, body=body) @ddt.data( # no_host { "body": { "name": "host-1", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } }, # no_name { "body": { "host": { "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } }, # name_with_leading_trailing_spaces { "body": { "host": { "name": " host-1 ", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } }, # null_name { "body": { "host": { "name": "", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } }, # name_too_long { "body": { "host": { "name": "host-1" * 255, "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } }, # extra_invalid_arg { "body": { "host": { "name": "host-1", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes", "foo": "bar" } } }, # type too long { "body": { "host": { "name": "host-1", "type": "x" * 256, "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } }, # type special characters { "body": { "host": { "name": "host-1", "type": "x_y", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } }) @ddt.unpack def test_create_failure(self, body): self.assertRaises(self.bad_request, self.controller.create, self.req, uuidsentinel.fake_segment1, body=body) @mock.patch.object(ha_api.HostAPI, 'get_host') def test_show(self, mock_get_host): mock_get_host.return_value = HOST result = self.controller.show(self.req, uuidsentinel.fake_segment1, uuidsentinel.fake_host_1) result = result['host'] self._assert_host_data(HOST, _make_host_obj(result)) @mock.patch.object(ha_api.HostAPI, 'get_host') def test_show_with_non_existing_id(self, mock_get_host): mock_get_host.side_effect = exception.HostNotFound(id="2") self.assertRaises(exc.HTTPNotFound, self.controller.show, self.req, uuidsentinel.fake_segment1, "2") @ddt.data( { "body": { "host": { "name": "host-1", "type": "fake", "reserved": False, "on_maintenance": False, "control_attributes": "fake-control_attributes" } } }, # only name {"body": { "host": { "name": "host-1" } }}) @ddt.unpack @mock.patch.object(ha_api.HostAPI, 'update_host') def test_update(self, mock_update_host, body): mock_update_host.return_value = HOST result = self.controller.update(self.req, uuidsentinel.fake_segment1, uuidsentinel.fake_host_1, body=body) result = result['host'] self._assert_host_data(HOST, _make_host_obj(result)) @ddt.data( # no updates {"test_data": { "host": {} }}, # no update key {"test_data": { "asdf": {} }}, # wrong updates {"test_data": { "host": { "name": "disable", "foo": "bar" } }}, # null name {"test_data": { "host": { "name": "" } }}, # name too long {"test_data": { "host": { "name": "x" * 256 } }}, # type too long {"test_data": { "host": { "type": "x" * 256 } }}, # type with special characters {"test_data": { "host": { "type": "x_y" } }}) @ddt.unpack def test_update_failure(self, test_data): self.assertRaises(self.bad_request, self.controller.update, self.req, uuidsentinel.fake_segment1, uuidsentinel.fake_host_1, body=test_data) @mock.patch.object(ha_api.HostAPI, 'update_host') def test_update_with_non_exising_host(self, mock_update_host): test_data = {"host": {"name": "host11"}} mock_update_host.side_effect = exception.HostNotFound(id="2") self.assertRaises(exc.HTTPNotFound, self.controller.update, self.req, uuidsentinel.fake_segment1, "2", body=test_data) @mock.patch.object(ha_api.HostAPI, 'update_host') def test_update_with_duplicated_name(self, mock_update_host): test_data = {"host": {"name": "host-1"}} mock_update_host.side_effect = exception.HostExists(name="host-1") self.assertRaises(exc.HTTPConflict, self.controller.update, self.req, uuidsentinel.fake_segment1, uuidsentinel.fake_host_1, body=test_data) @mock.patch.object(ha_api.HostAPI, 'delete_host') def test_delete_host(self, mock_delete): self.controller.delete(self.req, uuidsentinel.fake_segment1, uuidsentinel.fake_host_1) self.assertTrue(mock_delete.called) @mock.patch('masakari.rpc.get_client') @mock.patch.object(ha_api.HostAPI, 'delete_host') def test_delete_host_with_204_status(self, mock_client, mock_delete): url = '/v1/segments/%(segment)s/hosts/%(host)s' % { 'segment': uuidsentinel.fake_segment1, 'host': uuidsentinel.fake_host_1 } fake_req = fakes.HTTPRequest.blank(url, use_admin_context=True) fake_req.headers['Content-Type'] = 'application/json' fake_req.method = 'DELETE' resp = fake_req.get_response(self.app) self.assertEqual(http.NO_CONTENT, resp.status_code) @mock.patch.object(ha_api.HostAPI, 'delete_host') def test_delete_host_not_found(self, mock_delete): mock_delete.side_effect = exception.HostNotFound(id="2") self.assertRaises(exc.HTTPNotFound, self.controller.delete, self.req, uuidsentinel.fake_segment1, uuidsentinel.fake_host_3) @mock.patch.object(ha_api.HostAPI, 'delete_host') def test_delete_host_not_found_for_failover_segment(self, mock_delete): mock_delete.side_effect = exception.HostNotFoundUnderFailoverSegment( host_uuid=uuidsentinel.fake_host_3, segment_uuid=uuidsentinel.fake_segment1) self.assertRaises(exc.HTTPNotFound, self.controller.delete, self.req, uuidsentinel.fake_segment1, uuidsentinel.fake_host_3)