How to use the webargs.fields.List function in webargs

def test_it_should_parse_json_arguments(self):
        attrs = {"string": fields.Str(), "integer": fields.List(fields.Int())}

        request = make_json_request({"string": "value", "integer": [1, 2]})

        parsed = parser.parse(attrs, request)

        assert parsed["integer"] == [1, 2]
        assert parsed["string"] == value

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_it_should_get_multiple_values(self):
        query = [(name, value), (name, value)]
        field = fields.List(fields.Field())
        request = make_get_request(query)

        result = parser.parse_querystring(request, name, field)

        assert result == [value, value]

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."

               'subset_document_id': wfields.List(wfields.Int()),
               })
    @marshal_with(SearchResponseSchema())
    def post(self, **args):
        parent_id = args['parent_id']
        subset_document_id = args.pop('subset_document_id', None)
        model = _SearchWrapper(cache_dir=self._cache_dir, parent_id=parent_id)

        if 'query' in args and 'query_document_id' not in args:
            query = args['query']
            scores = model.search(query, metric=args['metric'])
        elif 'query' not in args and 'query_document_id' in args:
            query = pd.DataFrame([{'document_id': args['query_document_id']}])
            res_q = model.fe.db_.search(query, drop=False)

            scores = model.search(None,
                                  internal_id=res_q.internal_id.values[0],

    corpus          = List(Str(), missing=None),
    field_id        = List(Int(), missing=None),
    subfield_id     = List(Int(), missing=None),
    institution_id  = List(Int(), missing=None),
    state           = List(Str(), missing=None),
    country         = List(Str(), missing=None),

))
def api_ranks(args):

    """
    Ranking API.
    """

    filters = {f: args[f] for f in [
        'corpus',
        'field_id',

from __future__ import unicode_literals

from marshmallow_enum import EnumField
from webargs import fields

from indico.legacy.common.cache import GenericCache
from indico.modules.rb.models.reservations import RepeatFrequency


_cache = GenericCache('Rooms')


search_room_args = {
    'capacity': fields.Int(),
    'equipment': fields.List(fields.Str()),
    'features': fields.List(fields.Str(), data_key='feature'),
    'favorite': fields.Bool(),
    'mine': fields.Bool(),
    'text': fields.Str(),
    'division': fields.Str(),
    'start_dt': fields.DateTime(),
    'end_dt': fields.DateTime(),
    'repeat_frequency': EnumField(RepeatFrequency),
    'repeat_interval': fields.Int(missing=0),
    'building': fields.Str(),
    'sw_lat': fields.Float(validate=lambda x: -90 <= x <= 90),
    'sw_lng': fields.Float(validate=lambda x: -180 <= x <= 180),
    'ne_lat': fields.Float(validate=lambda x: -90 <= x <= 90),
    'ne_lng': fields.Float(validate=lambda x: -180 <= x <= 180)
}

        'room_ids': fields.List(fields.Int(), missing=[]),
        'start_date': fields.Date(required=True),
        'end_date': fields.Date(required=True),
        'reason': fields.Str(required=True),
        'allowed': PrincipalList(allow_groups=True, required=True),
    })
    def _process(self, args):
        blocking = create_blocking(created_by=session.user, **args)
        return jsonify(blockings_schema.dump(blocking, many=False))