def test_with_bad_arguments(self, mocked_use_case):
invalid_request = InvalidRequestObject()
invalid_request.add_error('filter', 'bad filter')
error = errors.Error.build_from_invalid_request_object(invalid_request)
mocked_use_case().execute.return_value = ro.ResponseFailure.from_error(error)
response = self.c.get(reverse('books_list'), {})
self.assertEqual(response.status_code, 400)
response_error_data = {'filter': ['bad filter']}
self.assertEqual(json.loads(response.content.decode('utf-8')), response_error_data)
def give(cls, pk, patch):
try:
if Book.objects.get(pk=pk).is_available:
Book.objects.filter(pk=pk).update(is_available=False,
reader=patch.get('reader'))
book = Book.objects.get(pk=pk)
return cls._convert_to_domain(book)
else:
inv_req = InvalidRequestObject()
inv_req.add_error('primary key', 'this book is not available')
error = errors.Error.build_from_invalid_request_object(inv_req)
return error
except Exception:
error = errors.Error.build_resource_error()
return error
def take(cls, pk, patch):
try:
if not Book.objects.get(pk=pk).is_available:
Book.objects.filter(pk=pk).update(is_available=True,
reader=None)
book = Book.objects.get(pk=pk)
return cls._convert_to_domain(book)
else:
inv_req = InvalidRequestObject()
inv_req.add_error('primary key', 'this book is in the library')
error = errors.Error.build_from_invalid_request_object(inv_req)
return error
except Exception:
error = errors.Error.build_resource_error()
return error
def from_dict(cls, adict):
invalid_req = InvalidRequestObject()
schema = Schema(
{
Required('full_name'):
All(str, Length(min=1, max=128)),
Required('reg_date'):
Any(
All(
datetime.date,
Range(min=datetime.date(1000, 1, 1),
max=datetime.date.today())),
Datetime('%Y-%m-%d')),
},
extra=REMOVE_EXTRA)
try:
values = schema(adict)
except MultipleInvalid as exc:
for error in exc.errors:
try:
invalid_req.add_error(parameter='.'.join(
[p for p in error.path]),
message=error.error_message)
except TypeError as e:
invalid_req.add_error(parameter='.'.join(
[p.schema for p in error.path]),
message=error.error_message)
if invalid_req.has_errors():
return invalid_req
return ReaderAddRequestObject(init_values=values)
def from_dict(cls, adict):
invalid_req = InvalidRequestObject()
if not bool(adict):
invalid_req.add_error('request dictionary',
'is empty, has to pass primary key')
elif 'pk' not in adict.keys():
invalid_req.add_error('primary key', 'has to pass primary key')
elif not isinstance(adict.get('pk'), int) and not check_if_int(
adict.get('pk')):
invalid_req.add_error('primary key', 'has to be integer')
if invalid_req.has_errors():
return invalid_req
return ReaderDeleteRequestObject(pk=int(adict.get('pk')))
def from_dict(cls, adict):
invalid_req = InvalidRequestObject()
schema = Schema(
{
Required('title'):
All(str, Length(min=1, max=128)),
Required('author'):
All(str, Length(min=1, max=128)),
Required('year'):
Any(
Datetime('%Y'),
All(int, Range(min=1000,
max=datetime.datetime.now().year))),
Required('language'):
All(str, Length(min=1, max=128)),
},
extra=REMOVE_EXTRA)
try:
values = schema(adict)
except MultipleInvalid as exc:
for error in exc.errors:
try:
invalid_req.add_error(parameter='.'.join(
[p for p in error.path]),
message=error.error_message)
except TypeError as e:
invalid_req.add_error(parameter='.'.join(
[p.schema for p in error.path]),
message=error.error_message)
if invalid_req.has_errors():
return invalid_req
return BookAddRequestObject(init_values=values)
def test_validation_error_messages(dictionaries):
try:
request_object_errors = readers.ReaderAddRequestObject.from_dict(
dictionaries[0]).errors
except AttributeError:
request_object_errors = True
assert bool(request_object_errors) is True
invalid_request_object = InvalidRequestObject()
invalid_request_object.add_error(parameter='full_name',
message=['required key not provided'])
invalid_request_object.add_error(parameter='reg_date',
message=['required key not provided'])
assert sorted(request_object_errors) == sorted(
invalid_request_object.errors)
try:
request_object_errors = readers.ReaderAddRequestObject.from_dict(
dictionaries[1]).errors
except AttributeError:
request_object_errors = True
assert bool(request_object_errors) is True
invalid_request_object = InvalidRequestObject()
invalid_request_object.add_error(parameter='full_name',
message=['expected str'])
invalid_request_object.add_error(
parameter='reg_date', message=['does not match regular expression'])
assert sorted(request_object_errors) == sorted(
invalid_request_object.errors)
try:
request_object_errors = readers.ReaderAddRequestObject.from_dict(
dictionaries[2]).errors
except AttributeError:
request_object_errors = False
assert bool(request_object_errors) is False
try:
request_object_errors = readers.ReaderAddRequestObject.from_dict(
dictionaries[3]).errors
except AttributeError:
request_object_errors = False
assert bool(request_object_errors) is False
def from_dict(cls, adict):
invalid_req = InvalidRequestObject()
if 'filters' in adict:
if not isinstance(adict['filters'], collections.Mapping):
invalid_req.add_error('filters', 'Is not iterable')
else:
good_operators = ('eq', )
for key in adict['filters'].keys():
try:
field, operator = key.split('__')
if field == 'reg_date':
if operator not in ('eq', 'gt', 'lt'):
invalid_req.add_error(
field, 'no such comparison operator %s' %
operator)
else:
if operator not in good_operators:
invalid_req.add_error(
field, 'no such comparison operator %s' %
operator)
if field not in Reader.__slots__:
invalid_req.add_error(field, 'no such field')
except ValueError:
invalid_req.add_error(key, 'invalid filter')
if invalid_req.has_errors():
return invalid_req
return ReaderListRequestObject(filters=adict.get('filters', None))
def from_dict(cls, adict):
invalid_req = InvalidRequestObject()
if not bool(adict):
invalid_req.add_error('request dictionary',
'is empty, has to pass primary key')
elif 'pk' not in adict.keys():
invalid_req.add_error('primary key', 'has to pass primary key')
elif not isinstance(adict.get('pk'), int) and not check_if_int(
adict.get('pk')):
invalid_req.add_error('primary key', 'has to be integer')
elif 'patch' not in adict.keys():
invalid_req.add_error('patch', 'has to pass patch instructions')
elif not isinstance(adict.get('patch'), collections.Mapping):
invalid_req.add_error('patch', 'is not iterable')
elif not set(adict.get('patch').keys()) < set(Reader.__slots__):
invalid_req.add_error('patch', 'parameters in patch are wrong')
if invalid_req.has_errors():
return invalid_req
if invalid_req.has_errors():
return invalid_req
return ReaderUpdateRequestObject(pk=int(adict.get('pk')),
patch=adict.get('patch', None))
def from_dict(cls, adict):
invalid_req = InvalidRequestObject()
adict['action'] = 'update'
patch_list = list(Book.__slots__)
patch_list.append('action')
if not bool(adict):
invalid_req.add_error('request dictionary',
'is empty, has to pass primary key')
elif 'pk' not in adict.keys():
invalid_req.add_error('primary key', 'has to pass primary key')
elif not isinstance(adict.get('pk'), int) and not check_if_int(
adict.get('pk')):
invalid_req.add_error('primary key', 'has to be integer')
elif 'patch' not in adict.keys():
invalid_req.add_error('patch', 'has to pass patch instructions')
elif not isinstance(adict.get('patch'), collections.Mapping):
invalid_req.add_error('patch', 'is not iterable')
elif not set(adict.get('patch').keys()) < set(patch_list):
invalid_req.add_error('patch', 'parameters in patch are wrong')
if invalid_req.has_errors():
return invalid_req
if 'reader' in adict.get('patch'):
if len(adict) > 1:
invalid_req.add_error(
'patch', 'reader with other parameters is forbidden')
elif adict.get['reader'] is None:
adict['action'] = 'take'
elif not isinstance(adict.get['reader'], Reader):
invalid_req.add_error('reader', 'just super wrong')
else:
adict['action'] = 'give'
if invalid_req.has_errors():
return invalid_req
return BookUpdateRequestObject(pk=int(adict.get('pk')),
patch=adict.get('patch', None))
def test_validation_error_messages(dictionaries):
try:
request_object_errors = books.BookAddRequestObject.from_dict(
dictionaries[0]).errors
except AttributeError:
request_object_errors = False
assert bool(request_object_errors) is False
try:
request_object_errors = books.BookAddRequestObject.from_dict(
dictionaries[1]).errors
except AttributeError:
request_object_errors = False
assert bool(request_object_errors) is True
invalid_request_object = InvalidRequestObject()
invalid_request_object.add_error(parameter='year',
message=['required key not provided'])
invalid_request_object.add_error(parameter='title',
message=['required key not provided'])
invalid_request_object.add_error(parameter='author',
message=['required key not provided'])
invalid_request_object.add_error(parameter='language',
message=['required key not provided'])
assert sorted(request_object_errors) == sorted(
invalid_request_object.errors)
try:
request_object_errors = books.BookAddRequestObject.from_dict(
dictionaries[2]).errors
except AttributeError:
request_object_errors = False
assert bool(request_object_errors) is True
invalid_request_object = InvalidRequestObject()
invalid_request_object.add_error(
parameter='year', message=['does not match regular expression'])
assert sorted(request_object_errors) == sorted(
invalid_request_object.errors)
try:
request_object_errors = books.BookAddRequestObject.from_dict(
dictionaries[3]).errors
except AttributeError:
request_object_errors = False
assert bool(request_object_errors) is False
try:
request_object_errors = books.BookAddRequestObject.from_dict(
dictionaries[4]).errors
except AttributeError:
request_object_errors = False
assert bool(request_object_errors) is True
invalid_request_object = InvalidRequestObject()
invalid_request_object.add_error(
parameter='year', message=['does not match regular expression'])
invalid_request_object.add_error(parameter='author',
message=['expected str'])
assert sorted(request_object_errors) == sorted(
invalid_request_object.errors)
