def test_parse_form_called_by_parse_arg(parse_form, web_request):
field = fields.Field()
p = Parser()
p.parse_arg('foo', field, web_request)
assert parse_form.called_once()
def test_missing_with_default(parser, web_request):
web_request.json = {}
args = {'val': fields.Field(missing='pizza')}
result = parser.parse(args, web_request, locations=('json', ))
assert result['val'] == 'pizza'
def test_value_error_raised_if_parse_arg_called_with_invalid_location(web_request):
field = fields.Field()
p = Parser()
with pytest.raises(ValueError) as excinfo:
p.parse_arg('foo', field, web_request, locations=('invalidlocation', 'headers'))
assert 'Invalid locations arguments: {0}'.format(['invalidlocation']) in str(excinfo)
def test_parse_required_list(parser, web_request):
web_request.json = {'bar': []}
args = {'foo': fields.List(fields.Field(), required=True)}
with pytest.raises(ValidationError) as excinfo:
parser.parse(args, web_request)
assert excinfo.value.messages['foo'][0] == 'Missing data for required field.'
def test_parse_list_dont_allow_none(parser, web_request):
web_request.json = {'foo': None}
args = {'foo': fields.List(fields.Field(), allow_none=False)}
with pytest.raises(ValidationError) as excinfo:
parser.parse(args, web_request)
assert excinfo.value.messages['foo'][0] == 'Field may not be null.'
def echo_file(request):
args = {"myfile": fields.Field()}
result = parser.parse(args, request, location="files")
myfile = result["myfile"]
content = myfile.read().decode("utf8")
return json_response({"myfile": content})
def test_parse_required_arg_raises_validation_error(parser, web_request):
web_request.json = {}
args = {'foo': fields.Field(required=True)}
with pytest.raises(ValidationError) as excinfo:
parser.parse(args, web_request)
assert 'Missing data for required field.' in str(excinfo)
def test_parse_required_arg(parser, web_request):
web_request.json = {"foo": 42}
result = parser.parse({"foo": fields.Field(required=True)}, web_request)
assert result == {"foo": 42}
def test_parse_empty_list(parser, web_request):
web_request.json = {"things": []}
args = {"things": fields.List(fields.Field())}
assert parser.parse(args, web_request) == {"things": []}
class CustomSchema(Schema):
username = fields.Field()
password = fields.Field()
def test_parse_required_arg_raises_validation_error(parser, web_request):
web_request.json = {}
args = {"foo": fields.Field(required=True)}
with pytest.raises(ValidationError, match="Missing data for required field."):
parser.parse(args, web_request)
def __init__(self):
super(ClassicSearchRedirectView, self).__init__()
self.translation = TranslationValue()
# all the parameters from classic
# typically integer fields must be represented by Field to allow None values
# some of these need use type fields.List
self.api = {
# the following we currently translate
'article_sel': fields.Str(required=False),
'aut_logic': fields.Str(required=False),
'aut_xct': fields.Str(required=False),
'author': fields.Str(required=False),
'data_link': fields.Str(required=False),
'db_key': fields.Str(required=False),
'end_entry_day': fields.Field(required=False),
'end_entry_mon': fields.Field(required=False),
'end_entry_year': fields.Field(required=False),
'end_mon': fields.Field(required=False),
'end_year': fields.Field(required=False),
'jou_pick': fields.Str(required=False),
'obj_logic': fields.Str(required=False),
'object': fields.Str(required=False),
'open_link': fields.Str(required=False),
'preprint_link': fields.Str(required=False),
'qsearch': fields.Str(required=False),
'return_req': fields.Str(required=False),
'start_entry_day': fields.Field(required=False),
'start_entry_mon': fields.Field(required=False),
'start_entry_year': fields.Field(required=False),
'start_mon': fields.Field(required=False),
'start_year': fields.Field(required=False),
'text': fields.Str(required=False),
'txt_logic': fields.Str(required=False),
'title': fields.Str(required=False),
'ttl_logic': fields.Str(required=False),
# implementations for the following just create errors
# perhaps because there is no ads/bumbleebee support yet
'nr_to_return': fields.Field(required=False),
'start_nr': fields.Field(required=False),
# golnaz - 3/5/2018
'article_link': fields.Str(required=False),
'gif_link': fields.Str(required=False),
'article': fields.Str(required=False),
'simb_obj': fields.Str(required=False),
'ned_obj': fields.Str(required=False),
'data_and': fields.Str(required=False),
'toc_link': fields.Str(required=False),
'pds_link': fields.Str(required=False),
'multimedia_link': fields.Str(required=False),
'ref_link': fields.Str(required=False),
'citation_link': fields.Str(required=False),
'associated_link': fields.Str(required=False),
'lib_link': fields.Str(required=False),
'ar_link': fields.Str(required=False),
'aut_note': fields.Str(required=False),
'spires_link': fields.Str(required=False),
'group_and': fields.Str(required=False),
'group_sel': fields.Str(required=False),
'abstract': fields.Str(required=False),
'sort': fields.Str(required=False),
'aut_wt': fields.Field(required=False),
'obj_wt': fields.Field(required=False),
'ttl_wt': fields.Field(required=False),
'txt_wt': fields.Field(required=False),
'aut_wgt': fields.Str(required=False),
'obj_wgt': fields.Str(required=False),
'ttl_wgt': fields.Str(required=False),
'txt_wgt': fields.Str(required=False),
'aut_syn': fields.Str(required=False),
'ttl_syn': fields.Str(required=False),
'txt_syn': fields.Str(required=False),
'aut_sco': fields.Str(required=False),
'ttl_sco': fields.Str(required=False),
'txt_sco': fields.Str(required=False),
'aut_req': fields.Str(required=False),
'obj_req': fields.Str(required=False),
'ttl_req': fields.Str(required=False),
'txt_req': fields.Str(required=False),
'ref_stems': fields.Str(required=False),
'arxiv_sel': fields.Str(required=False),
# these can be ignored, at least for now
'sim_query': fields.Str(required=False),
'ned_query': fields.Str(required=False),
'mail_link': fields.Str(required=False),
'gpndb_obj': fields.Str(required=False),
'min_score': fields.Str(required=False),
'lpi_query': fields.Str(required=False),
'iau_query': fields.Str(required=False),
'data_type': fields.Str(required=False),
'adsobj_query': fields.Str(required=False),
# and the following are not yet translated
'kwd_wt': fields.Field(required=False),
'full_wt': fields.Field(required=False),
'aff_wt': fields.Field(required=False),
'full_syn': fields.Str(required=False),
'aff_syn': fields.Str(required=False),
'kwd_wgt': fields.Str(required=False),
'full_wgt': fields.Str(required=False),
'aff_wgt': fields.Str(required=False),
'kwd_sco': fields.Str(required=False),
'full_sco': fields.Str(required=False),
'aff_sco': fields.Str(required=False),
'kwd_req': fields.Str(required=False),
'full_req': fields.Str(required=False),
'aff_req': fields.Str(required=False),
'aut_logic': fields.Str(required=False),
'obj_logic': fields.Str(required=False),
'kwd_logic': fields.Str(required=False),
'ttl_logic': fields.Str(required=False),
'txt_logic': fields.Str(required=False),
'full_logic': fields.Str(required=False),
'aff_logic': fields.Str(required=False),
}
class AlwaysErrorResource(object):
args = {'bad': fields.Field(validate=lambda x: False)}
def on_get(self, req, resp):
parser.parse(self.args, req=req)
def test_parse_json_not_called_when_json_not_a_location(
parse_json, web_request):
field = fields.Field()
p = Parser()
p.parse_arg('foo', field, web_request, locations=('form', 'querystring'))
assert parse_json.call_count == 0
meta = {
'Name': None,
'Version': None,
'Summary': None,
'Home-page': None,
'Author': None,
'Author-email': None,
'License': None,
}
for line in pkg.get_metadata_lines("PKG-INFO"):
for par in meta:
if line.startswith(par):
_, value = line.split(": ", 1)
meta[par] = value
# Update information with Docker info (provided as 'CONTAINER_*' env variables)
r = re.compile("^CONTAINER_(.*?)$")
container_vars = list(filter(r.match, list(os.environ)))
for var in container_vars:
meta[var.capitalize()] = os.getenv(var)
return meta
schema = {
"status": fields.Str(),
"message": fields.Str(),
"predictions": fields.Field()
}
def test_missing_with_default(parser, web_request):
web_request.json = {}
args = {"val": fields.Field(missing="pizza")}
result = parser.parse(args, web_request)
assert result["val"] == "pizza"
def test_parse_form_returns_missing_if_no_form():
req = mock.Mock()
req.form.get.side_effect = AttributeError("no form")
assert parser.parse_form(req, "foo", fields.Field()) is missing
def test_default_can_be_none(parser, web_request):
web_request.json = {}
args = {"val": fields.Field(missing=None, allow_none=True)}
result = parser.parse(args, web_request)
assert result["val"] is None
def echo_file(request):
args = {'myfile': fields.Field()}
result = parser.parse(args, request, locations=('files', ))
myfile = result['myfile']
content = myfile.file.read().decode('utf8')
return {'myfile': content}
def test_value_error_raised_if_parse_called_with_invalid_location(parser, web_request):
field = fields.Field()
with pytest.raises(ValueError, match="Invalid location argument: invalidlocation"):
parser.parse({"foo": field}, web_request, location="invalidlocation")
def test_parse_required_arg(parse_json, web_request):
arg = fields.Field(required=True)
parse_json.return_value = 42
p = Parser()
result = p.parse_arg('foo', arg, web_request, locations=('json', ))
assert result == 42
def test_location_as_init_argument(load_headers, web_request):
p = Parser(location="headers")
load_headers.return_value = {}
p.parse({"foo": fields.Field()}, web_request)
assert load_headers.called
def test_parse_list_allow_none(parser, web_request):
web_request.json = {'foo': None}
args = {'foo': fields.List(fields.Field(allow_none=True), allow_none=True)}
assert parser.parse(args, web_request) == {'foo': None}
def test_load_json_called_by_parse_default(load_json, web_request):
schema = Schema.from_dict({"foo": fields.Field()})()
load_json.return_value = {"foo": 1}
p = Parser()
p.parse(schema, web_request)
load_json.assert_called_with(web_request, schema)
def test_parse_missing_list(parser, web_request):
web_request.json = {}
args = {'things': fields.List(fields.Field())}
assert parser.parse(args, web_request) == {}
class MySchema(Schema):
foo = fields.Field()
def test_default_can_be_none(parser, web_request):
web_request.json = {}
args = {'val': fields.Field(missing=None, allow_none=True)}
result = parser.parse(args, web_request, locations=('json', ))
assert result['val'] is None
def test_parse(parser, web_request):
web_request.json = {"username": 42, "password": 42}
argmap = {"username": fields.Field(), "password": fields.Field()}
ret = parser.parse(argmap, web_request)
assert {"username": 42, "password": 42} == ret
def test_value_error_raised_if_invalid_location_on_field(web_request, parser):
with pytest.raises(ValueError) as excinfo:
parser.parse({'foo': fields.Field(location='invalidlocation')}, web_request)
assert 'Invalid locations arguments: {0}'.format(['invalidlocation']) in str(excinfo)
def test_parse_querystring_called_by_parse_arg(parse_querystring, web_request):
field = fields.Field()
p = Parser()
p.parse_arg('foo', field, web_request)
assert parse_querystring.called_once()
