Esempio n. 1
0
 def pack(self, results):
     packed = Namespace()
     for keys, value in results:
         target = packed
         for k in keys[:-1]:
             target = target.setdefault(k, Namespace())
         target[keys[-1]] = value
     return packed
def test_datatables():
    req = MockRequest()
    req.values = {
        'draw': '1',
        'start': '9',
        'length': '50',
        'search[value]': 'filter',
        'search[regex]': 'false',
        'order[1][column]': '3',
        'order[1][dir]': 'asc',
        'order[2][column]': '1',
        'order[2][dir]': 'desc',
        'columns[1][data]': 'date',
        'columns[1][name]': 'Date',
        'columns[1][searchable]': 'false',
        'columns[1][orderable]': 'true',
        'columns[2][data]': 'idx',
        'columns[2][name]': 'Index',
        'columns[2][searchable]': 'true',
        'columns[2][orderable]': 'true',
        'columns[2][search][value]': '112x3',
        'columns[2][search][regex]': 'true',
        'columns[3][data]': 'name',
        'columns[3][name]': 'Name',
        'columns[3][searchable]': 'true',
        'columns[3][orderable]': 'true',
    }
    expected = Namespace()
    expected['draw'] = 1
    expected['start'] = 9
    expected['length'] = 50
    expected['search'] = Namespace(value='filter', regex=False)
    expected['order'] = Namespace({
        1: Namespace(column=3, dir='asc'),
        2: Namespace(column=1, dir='desc'),
    })
    expected['columns'] = Namespace({
        1:
        Namespace(data='date', name='Date', searchable=False, orderable=True),
        2:
        Namespace(data='idx',
                  name='Index',
                  searchable=True,
                  orderable=True,
                  search=Namespace(value='112x3', regex=True)),
        3:
        Namespace(data='name', name='Name', searchable=True, orderable=True),
    })

    arg = datatables.parser.parse_args(req)
    assert arg == expected
Esempio n. 3
0
    def account_input(self, data: reqparse.Namespace) -> dict:
        """Request parameters.

        Args:
            data (reqparse.Namespace): reqparse object

        Returns:
            dict: request parameters
        """
        account = data.get('account')
        password = data.get('password')
        return {
            'account': account,
            'password': password,
        }
Esempio n. 4
0
    def parse_single(self, keys, values, bundle_errors):
        arg = self.type
        formatted_keys = []
        for idx, k in enumerate(keys):
            formatted_k, arg = arg.get_argument(k)
            formatted_keys.append(formatted_k)
            if isinstance(arg, Argument):
                # hit leaf argument
                if idx != len(keys) - 1:
                    return self.handle_validation_error(
                        ValueError('key %r exceeded desired level' % (keys, )),
                        bundle_errors)
        if not isinstance(arg, Argument):
            return self.handle_validation_error(
                ValueError('key %r unmet desired level' % (keys, )),
                bundle_errors)

        if isinstance(arg.location, six.string_types):
            location = arg.location
        else:
            location = arg.location[0]
        req = Namespace()
        req['unparsed_arguments'] = dict()
        req[location] = {arg.name: values}

        result, found = arg.parse(req, bundle_errors)
        return tuple(formatted_keys), result, found
def test_structured():
    req = MockRequest()
    req.values = {
        'rate': 10,
        'name': 'request1',
        'arr[x]': 'a',
        'arr[y]': '1',
        'arr[z]': 'z',
    }
    parser = reqparse.RequestParser()
    parser.add_argument('rate', type=int, help='Rate cannot be converted')
    parser.add_argument('name')

    sub_parser = NestParser()
    sub_parser.add_argument('x')
    sub_parser.add_argument('y', type=int, help='y should be int')
    sub_parser.add_argument('z')

    parser.add_argument(ArrayArgument('arr', type=sub_parser))

    args = parser.parse_args(req)
    assert args['rate'] == 10
    assert args['name'] == 'request1'

    assert args['arr'] == Namespace(x='a', y=1, z='z')
def test_nested():
    req = MockRequest()
    req.values = {
        'rate': 10,
        'name': 'request1',
        'arr[0][x]': 'a',
        'arr[0][y]': '1',
        'arr[0][z]': 'z',
        'arr[1][x]': 'b',
        'arr[1][y]': '3',
        'arr[1][z]': 's',
        'arr[2][x]': 'c',
        'arr[2][z]': 'z',
    }
    parser = reqparse.RequestParser()
    parser.add_argument('rate', type=int, help='Rate cannot be converted')
    parser.add_argument('name')

    sub_parser = NestParser()
    sub_parser.add_argument('x')
    sub_parser.add_argument('y', type=int, help='y should be int')
    sub_parser.add_argument('z')

    parser.add_argument(
        ArrayArgument('arr', type=ScalarParser(type=sub_parser)))

    args = parser.parse_args(req)
    assert args['rate'] == 10
    assert args['name'] == 'request1'

    assert args['arr'][0] == Namespace(x='a', y=1, z='z')
    assert args['arr'][1] == Namespace(x='b', y=3, z='s')

    # TODO add default value to missing nested arguments
    # assert args['arr'][2] == Namespace(
    #     x='c', y=None, z='z'
    # )
    assert args['arr'][2] == Namespace(x='c', z='z')
Esempio n. 7
0
 def test_namespace_existence(self):
     namespace = Namespace()
     namespace.foo = 'bar'
     namespace['bar'] = 'baz'
     self.assertEquals(namespace['foo'], 'bar')
     self.assertEquals(namespace.bar, 'baz')
 def test_namespace_missing(self):
     namespace = Namespace()
     self.assertRaises(AttributeError, lambda: namespace.spam)
     self.assertRaises(KeyError, lambda: namespace['eggs'])
 def test_namespace_existence(self):
     namespace = Namespace()
     namespace.foo = 'bar'
     namespace['bar'] = 'baz'
     self.assertEquals(namespace['foo'], 'bar')
     self.assertEquals(namespace.bar, 'baz')
Esempio n. 10
0
 def test_namespace_existence(self):
     namespace = Namespace()
     namespace.foo = "bar"
     namespace["bar"] = "baz"
     self.assertEquals(namespace["foo"], "bar")
     self.assertEquals(namespace.bar, "baz")