Exemple #1
0
def setup_module(module_patch, params=None):
    mock_module = MagicMock()
    module_patch.return_value = mock_module
    if params is None:
        mock_module.params = TEST_PARAMS
    else:
        mock_module.params = params

    return mock_module
Exemple #2
0
def req():
    """XXX: Very simple mock request, improve this"""
    req = MagicMock()
    req.header = ["0", "1", "2", "3", "4", "5"]
    req.session = {}
    req.params = {}
    return req
    def test_removes_rotate_metadata(self):

        mov_path = '/utils/test/rotated.mov'
        orig_path = __base_path__ + mov_path

        # Create a copy that to be altered in test, then removed.
        with tempfile.NamedTemporaryFile(delete=False) as in_file:

            try:
                shutil.copy(orig_path, in_file.name)
                info = {'filepath': in_file.name.decode('utf-8')}
                mock_ydl = MagicMock()
                mock_ydl.params = {
                    'ffmpeg_location': TestFFmpegRotatorPP.get_ffmpeg_path()}
                with tempfile.NamedTemporaryFile(suffix='.mp4') as out_file:

                    processor = uvd.FFmpegRotatorPP(mock_ydl, out_file.name)
                    paths, info = processor.run(info)

                    # Assert output video's rotation metadata is removed.
                    output = subprocess.check_output([
                            'ffprobe',
                            '-v',
                            'quiet',
                            '-show_streams',
                            info['filepath']],
                        stderr=subprocess.STDOUT)
                    self.assertEqual(-1, output.find('rotation'))
            finally:
                # Manually clean the input temp file if something went wrong.
                if os.path.exists(in_file.name):
                    os.unlink(in_file.name)
Exemple #4
0
    def test_on_create_target_action(self, _getfqdn):
        _getfqdn.return_value = 'ceph-iscsi-0.example'
        self.add_cluster_relation()
        self.harness.begin()
        action_event = MagicMock()
        action_event.params = {
            'iqn': 'iqn.mock.iscsi-gw:iscsi-igw',
            'gateway-units': 'ceph-iscsi/0 ceph-iscsi/1',
            'pool-name': 'iscsi-pool',
            'image-name': 'disk1',
            'image-size': '5G',
            'client-initiatorname': 'client-initiator',
            'client-username': '******',
            'client-password': '******'
        }
        self.harness.charm.on_create_target_action(action_event)
        self.gwc.add_gateway_to_target.assert_has_calls([
            call('iqn.mock.iscsi-gw:iscsi-igw', '10.0.0.10',
                 'ceph-iscsi-0.example'),
            call('iqn.mock.iscsi-gw:iscsi-igw', '10.0.0.2',
                 'ceph-iscsi-1.example')
        ])

        self.gwc.create_pool.assert_called_once_with('iscsi-pool', 'disk1',
                                                     '5G')
        self.gwc.add_client_to_target.assert_called_once_with(
            'iqn.mock.iscsi-gw:iscsi-igw', 'client-initiator')
        self.gwc.add_client_auth.assert_called_once_with(
            'iqn.mock.iscsi-gw:iscsi-igw', 'client-initiator', 'myusername',
            'mypassword')
        self.gwc.add_disk_to_client.assert_called_once_with(
            'iqn.mock.iscsi-gw:iscsi-igw', 'client-initiator', 'iscsi-pool',
            'disk1')
Exemple #5
0
def req():
    """XXX: Very simple mock request, improve this"""
    req = MagicMock()
    req.header = ["0", "1", "2", "3", "4", "5"]
    req.session = {}
    req.params = {}
    return req
Exemple #6
0
 def test_collection_get2(self):
     from lembrar import service
     db = MagicMock()
     service.get_doc_db_from_request = lambda x: db
     request = MagicMock()
     request.params = {}
     test_ob = service.Docs(request)
     request.params['skip'] = 20
     test_ob.collection_get()
     assert call(skip=20, limit=20) == db.find.mock_calls[0]
Exemple #7
0
 def test_date_converter2(self):
     from lembrar.service import date_converter
     request = MagicMock()
     request.validated = {}
     request.params = {}
     request.params['created'] = 'crap'
     date_converter(request)
     assert [call.add('parameters', 'created',
             'Cannot parse date format')] \
         == request.errors.mock_calls
Exemple #8
0
 def test_date_converter1(self):
     from lembrar.service import date_converter
     from datetime import datetime
     before = datetime.utcnow()
     request = MagicMock()
     request.validated = {}
     request.params = {}
     date_converter(request)
     after = datetime.utcnow()
     assert before <= request.validated['created'] <= after
Exemple #9
0
def test_parameter_validator(monkeypatch):
    request = MagicMock(name='request')
    request.args = {}
    request.headers = {}
    request.params = {}
    app = MagicMock(name='app')

    app.response_class = flask.Response
    monkeypatch.setattr('flask.request', request)
    monkeypatch.setattr('flask.current_app', app)

    def orig_handler(*args, **kwargs):
        return 'OK'

    params = [{'name': 'p1', 'in': 'path', 'type': 'integer', 'required': True},
              {'name': 'h1', 'in': 'header', 'type': 'string', 'enum': ['a', 'b']},
              {'name': 'q1', 'in': 'query', 'type': 'integer', 'maximum': 3},
              {'name': 'a1', 'in': 'query', 'type': 'array', 'minItems': 2, 'maxItems': 3,
               'items': {'type': 'integer', 'minimum': 0}}]
    validator = ParameterValidator(params, FlaskApi)
    handler = validator(orig_handler)

    kwargs = {'query': {}, 'headers': {}}
    request = MagicMock(path_params={}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Missing path parameter 'p1'"
    request = MagicMock(path_params={'p1': '123'}, **kwargs)
    assert handler(request) == 'OK'
    request = MagicMock(path_params={'p1': ''}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Wrong type, expected 'integer' for path parameter 'p1'"
    request = MagicMock(path_params={'p1': 'foo'}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Wrong type, expected 'integer' for path parameter 'p1'"
    request = MagicMock(path_params={'p1': '1.2'}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Wrong type, expected 'integer' for path parameter 'p1'"

    request = MagicMock(path_params={'p1': 1}, query={'q1': '4'}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith('4 is greater than the maximum of 3')
    request = MagicMock(path_params={'p1': 1}, query={'q1': '3'}, headers={})
    assert handler(request) == 'OK'

    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', '2']}, headers={})
    assert handler(request) == "OK"
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', 'a']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("'a' is not of type 'integer'")
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', '-1']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("-1 is less than the minimum of 0")
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("[1] is too short")
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', '2', '3', '4']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("[1, 2, 3, 4] is too long")

    request = MagicMock(path_params={'p1': '123'}, query={}, headers={'h1': 'a'})
    assert handler(request) == 'OK'

    request = MagicMock(path_params={'p1': '123'}, query={}, headers={'h1': 'x'})
    assert json.loads(handler(request).data.decode())['detail'].startswith("'x' is not one of ['a', 'b']")
Exemple #10
0
def test_parameter_validator(monkeypatch):
    request = MagicMock(name='request')
    request.args = {}
    request.headers = {}
    request.params = {}
    app = MagicMock(name='app')

    app.response_class = flask.Response
    monkeypatch.setattr('flask.request', request)
    monkeypatch.setattr('flask.current_app', app)

    def orig_handler(*args, **kwargs):
        return 'OK'

    params = [{'name': 'p1', 'in': 'path', 'type': 'integer', 'required': True},
              {'name': 'h1', 'in': 'header', 'type': 'string', 'enum': ['a', 'b']},
              {'name': 'q1', 'in': 'query', 'type': 'integer', 'maximum': 3},
              {'name': 'a1', 'in': 'query', 'type': 'array', 'minItems': 2, 'maxItems': 3,
               'items': {'type': 'integer', 'minimum': 0}}]
    validator = ParameterValidator(params, FlaskApi)
    handler = validator(orig_handler)

    kwargs = {'query': {}, 'headers': {}}
    request = MagicMock(path_params={}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Missing path parameter 'p1'"
    request = MagicMock(path_params={'p1': '123'}, **kwargs)
    assert handler(request) == 'OK'
    request = MagicMock(path_params={'p1': ''}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Wrong type, expected 'integer' for path parameter 'p1'"
    request = MagicMock(path_params={'p1': 'foo'}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Wrong type, expected 'integer' for path parameter 'p1'"
    request = MagicMock(path_params={'p1': '1.2'}, **kwargs)
    assert json.loads(handler(request).data.decode())['detail'] == "Wrong type, expected 'integer' for path parameter 'p1'"

    request = MagicMock(path_params={'p1': 1}, query={'q1': '4'}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith('4 is greater than the maximum of 3')
    request = MagicMock(path_params={'p1': 1}, query={'q1': '3'}, headers={})
    assert handler(request) == 'OK'

    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', '2']}, headers={})
    assert handler(request) == "OK"
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', 'a']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("'a' is not of type 'integer'")
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', '-1']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("-1 is less than the minimum of 0")
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("[1] is too short")
    request = MagicMock(path_params={'p1': 1}, query={'a1': ['1', '2', '3', '4']}, headers={})
    assert json.loads(handler(request).data.decode())['detail'].startswith("[1, 2, 3, 4] is too long")

    request = MagicMock(path_params={'p1': '123'}, query={}, headers={'h1': 'a'})
    assert handler(request) == 'OK'

    request = MagicMock(path_params={'p1': '123'}, query={}, headers={'h1': 'x'})
    assert json.loads(handler(request).data.decode())['detail'].startswith("'x' is not one of ['a', 'b']")
Exemple #11
0
 def test_collection_put(self):
     from lembrar import service
     db = MagicMock()
     service.get_doc_db_from_request = lambda x: db
     request = MagicMock()
     request.params = dict(test='test1', file=MagicMock())
     test_ob = service.Docs(request)
     test_ob.collection_put()
     assert [call(request.params['file'].file,
             request.validated['created'], test='test1')] \
         == db.add_one.mock_calls
    def test_change_tf_for_population(self):
        mock_tf = MagicMock()
        mock_tf.params = []
        mock_tf.source = "tf_source node_name"
        tfs = [mock_tf]
        ROSCLEServer.ROSCLEServer.change_transfer_function_for_population(
            MagicMock(), MagicMock(), MagicMock(), tfs)
        # check nothing has changed
        self.assertEqual(mock_tf.source, "tf_source node_name")

        mock_mapping = MagicMock()
        mock_mapping.name = "node_name"

        mock_spec = MagicMock(spec=["neurons"])
        mock_spec.neurons = mock_mapping

        mock_params = MagicMock(spec=["spec"])
        mock_params.spec = mock_spec
        mock_tf.params = [
            "t", mock_params
        ]  # for some reason the real data has a t as in the list

        tfs = [mock_tf]
        self.assertEqual(
            ROSCLEServer.ROSCLEServer.change_transfer_function_for_population(
                srv.SetPopulationsRequest.ASK_RENAME_POPULATION, "node_name",
                MagicMock(), tfs),
            ["we ask the user if we change TFs", 0, 0, 1])
        self.assertEqual(mock_tf.source, "tf_source node_name")

        mock_mapping.name = ""
        mock_parent = MagicMock()
        mock_parent.name = "node_name"
        mock_mapping.parent = mock_parent

        ROSCLEServer.ROSCLEServer.change_transfer_function_for_population(
            srv.SetPopulationsRequest.DO_RENAME_POPULATION, "node_name",
            "new_node_name", tfs)
        self.assertEqual(mock_parent.name, "new_node_name")
        self.assertEqual(mock_tf.source, "tf_source new_node_name")
def make_request(secure, host, path, params):
    request = MagicMock()

    # Generate the string of paramaters1
    params_str = ''
    for param in params:
        params_str += '%s=%s&' % (param, params[param])

    secure = 's' if secure else ''
    request.url = 'http%s://%s/%s?%s' % (secure, host, path, params_str)
    request.host = host
    request.host_url = 'http%s://%s' % (secure, host)
    request.params = params
    return request
Exemple #14
0
def make_request(secure, host, path, params):
    request = MagicMock()

    # Generate the string of paramaters1
    params_str = ""
    for param in params:
        params_str += "%s=%s&" % (param, params[param])

    secure = "s" if secure else ""
    request.url = "http%s://%s/%s?%s" % (secure, host, path, params_str)
    request.host = host
    request.host_url = "http%s://%s" % (secure, host)
    request.params = params
    return request
Exemple #15
0
def test_injection(monkeypatch):
    request = MagicMock(name='request', path_params={'p1': '123'})
    request.args = {}
    request.headers = {}
    request.params = {}

    func = MagicMock()

    def handler(**kwargs):
        func(**kwargs)

    parameter_to_arg({}, [], handler)(request)

    func.assert_called_with(p1='123')
Exemple #16
0
    def test_collection_get1(self):
        from lembrar import service
        db = MagicMock()
        service.get_doc_db_from_request = lambda x: db
        request = MagicMock()
        request.params = {}
        test_ob = service.Docs(request)
        fake_doc = MagicMock()

        def find(limit, skip):
            return [fake_doc]

        db.find = find
        assert [fake_doc.to_jsonable_dict()] == test_ob.collection_get()
Exemple #17
0
def make_request(secure, host, path, params):
    request = MagicMock()

    # Generate the string of paramaters1
    params_str = ''
    for param in params:
        params_str += '%s=%s&' % (param, params[param])

    secure = 's' if secure else ''
    request.url = 'http%s://%s/%s?%s' % (secure, host, path, params_str)
    request.host = host
    request.host_url = 'http%s://%s' % (secure, host)
    request.params = params
    return request
def test_parameter_validator(monkeypatch):
    request = MagicMock(name='request')
    request.args = {}
    request.headers = {}
    request.params = {}
    app = MagicMock(name='app')
    app.response_class = lambda a, mimetype, status: json.loads(''.join(a))['detail']
    monkeypatch.setattr('flask.request', request)
    monkeypatch.setattr('flask.current_app', app)

    def orig_handler(*args, **kwargs):
        return 'OK'

    params = [{'name': 'p1', 'in': 'path', 'type': 'integer', 'required': True},
              {'name': 'h1', 'in': 'header', 'type': 'string', 'enum': ['a', 'b']},
              {'name': 'q1', 'in': 'query', 'type': 'integer', 'maximum': 3},
              {'name': 'a1', 'in': 'query', 'type': 'array', 'minItems': 2, 'maxItems': 3,
               'items': {'type': 'integer', 'minimum': 0}}]
    validator = ParameterValidator(params)
    handler = validator(orig_handler)

    assert handler() == "Missing path parameter 'p1'"
    assert handler(p1='123') == 'OK'
    assert handler(p1='') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(p1='foo') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(p1='1.2') == "Wrong type, expected 'integer' for path parameter 'p1'"

    request.args = {'q1': '4'}
    assert handler(p1=1).startswith('4 is greater than the maximum of 3')
    request.args = {'q1': '3'}
    assert handler(p1=1) == 'OK'

    request.args = {'a1': "1,2"}
    assert handler(p1=1) == "OK"
    request.args = {'a1': "1,a"}
    assert handler(p1=1).startswith("'a' is not of type 'integer'")
    request.args = {'a1': "1,-1"}
    assert handler(p1=1).startswith("-1 is less than the minimum of 0")
    request.args = {'a1': "1"}
    assert handler(p1=1).startswith("[1] is too short")
    request.args = {'a1': "1,2,3,4"}
    assert handler(p1=1).startswith("[1, 2, 3, 4] is too long")
    del request.args['a1']

    request.headers = {'h1': 'a'}
    assert handler(p1='123') == 'OK'

    request.headers = {'h1': 'x'}
    assert handler(p1='123').startswith("'x' is not one of ['a', 'b']")
Exemple #19
0
 def test_date_converter3(self):
     from lembrar.service import date_converter
     from datetime import datetime
     request = MagicMock()
     request.validated = {}
     request.params = {}
     request.params['created'] = '2011-07-22 10:11:33'
     date_converter(request)
     assert datetime(
         2011,
         7,
         22,
         10,
         11,
         33,
         ) == request.validated['created']
    def test_list_members(self):
        collection_handler = webservice.CollectionHandler(r'/', '')
        collection_handler.model = webservice.SimpleDataModel("test")
        request = MagicMock()
        request.body = '{"key": "value"}'
        request.params = MagicMock()
        request.path = "/"
        response = collection_handler.list_members(request)
        items = collection_handler.model.get_items(
            request.params,
            context=collection_handler._get_context(request))

        expected_body = "%s\n" % json.dumps(items, indent=2)
        self.assertEqual('application/json', response.content_type)

        self.assertEqual(expected_body, response.body)
        self.assertEqual('application/json', response.content_type)
        self.assertEqual(str(httplib.OK) + " OK", response.status)
def test_parameter_validator(monkeypatch):
    request = MagicMock(name='request')
    request.args = {}
    request.headers = {}
    request.params = {}
    app = MagicMock(name='app')
    app.response_class = lambda a, mimetype, status: json.loads(a)['detail']
    monkeypatch.setattr('flask.request', request)
    monkeypatch.setattr('flask.current_app', app)

    def orig_handler(*args, **kwargs):
        return 'OK'

    params = [{'name': 'p1', 'in': 'path', 'type': 'integer', 'required': True},
              {'name': 'h1', 'in': 'header', 'type': 'string', 'enum': ['a', 'b']},
              {'name': 'q1', 'in': 'query', 'type': 'integer', 'maximum': 3},
              {'name': 'a1', 'in': 'query', 'type': 'array', 'items': {'type': 'integer', 'minimum': 0}}]
    validator = ParameterValidator(params)
    handler = validator(orig_handler)

    assert handler() == "Missing path parameter 'p1'"
    assert handler(p1='123') == 'OK'
    assert handler(p1='') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(p1='foo') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(p1='1.2') == "Wrong type, expected 'integer' for path parameter 'p1'"

    request.args = {'q1': '4'}
    assert handler(p1=1) == 'Invalid value, must be at most 3'
    request.args = {'q1': '3'}
    assert handler(p1=1) == 'OK'

    request.args = {'a1': '1,2'}
    assert handler(p1=1) == "OK"
    request.args = {'a1': '1,a'}
    assert handler(p1=1) == "Wrong type, expected 'integer' for query parameter 'a1'"
    request.args = {'a1': '1,-1'}
    assert handler(p1=1) == "Invalid value, must be at least 0"
    del request.args['a1']

    request.headers = {'h1': 'a'}
    assert handler(p1='123') == 'OK'

    request.headers = {'h1': 'x'}
    assert handler(p1='123') == "Enum value must be one of ['a', 'b']"
Exemple #22
0
def test_parameter_validator(monkeypatch):
    request = MagicMock(name='request')
    request.args = {}
    request.headers = {}
    request.params = {}
    app = MagicMock(name='app')
    app.response_class = lambda a, mimetype, status: json.loads(a)['detail']
    monkeypatch.setattr('flask.request', request)
    monkeypatch.setattr('flask.current_app', app)

    def orig_handler(*args, **kwargs):
        return 'OK'

    params = [{'name': 'p1', 'in': 'path', 'type': 'integer', 'required': True},
              {'name': 'h1', 'in': 'header', 'type': 'string', 'enum': ['a', 'b']},
              {'name': 'q1', 'in': 'query', 'type': 'integer', 'maximum': 3},
              {'name': 'a1', 'in': 'query', 'type': 'array', 'items': {'type': 'integer', 'minimum': 0}}]
    validator = ParameterValidator(params)
    handler = validator(orig_handler)

    assert handler() == "Missing path parameter 'p1'"
    assert handler(p1='123') == 'OK'
    assert handler(p1='') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(p1='foo') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(p1='1.2') == "Wrong type, expected 'integer' for path parameter 'p1'"

    request.args = {'q1': '4'}
    assert handler(p1=1).startswith('4 is greater than the maximum of 3')
    request.args = {'q1': '3'}
    assert handler(p1=1) == 'OK'

    request.args = {'a1': "1,2"}
    assert handler(p1=1) == "OK"
    request.args = {'a1': "1,a"}
    assert handler(p1=1).startswith("'a' is not of type 'integer'")
    request.args = {'a1': "1,-1"}
    assert handler(p1=1).startswith("-1 is less than the minimum of 0")
    del request.args['a1']

    request.headers = {'h1': 'a'}
    assert handler(p1='123') == 'OK'

    request.headers = {'h1': 'x'}
    assert handler(p1='123').startswith("'x' is not one of ['a', 'b']")
Exemple #23
0
def test_injection():
    request = MagicMock(name='request', path_params={'p1': '123'})
    request.args = {}
    request.headers = {}
    request.params = {}

    func = MagicMock()

    def handler(**kwargs):
        func(**kwargs)

    parameter_to_arg({}, [], handler)(request)

    func.assert_called_with(p1='123')

    parameter_to_arg({}, [],
                     handler,
                     pass_context_arg_name='framework_request_ctx')(request)
    func.assert_called_with(p1='123', framework_request_ctx=request.context)
def test_injection():
    request = MagicMock(name='request', path_params={'p1': '123'})
    request.args = {}
    request.headers = {}
    request.params = {}

    func = MagicMock()

    def handler(**kwargs):
        func(**kwargs)

    class Op(object):
        consumes = ['application/json']

        def get_arguments(self, *args, **kwargs):
            return {"p1": "123"}

    parameter_to_arg(Op(), handler)(request)
    func.assert_called_with(p1='123')

    parameter_to_arg(Op(), handler, pass_context_arg_name='framework_request_ctx')(request)
    func.assert_called_with(p1='123', framework_request_ctx=request.context)
    def test_action(self):
        element_handler = webservice.ElementHandler(r'/', '')
        element_handler.model = webservice.SimpleDataModel("test")
        request = MagicMock()
        request.path = "/"

        response = element_handler.action(request)
        self.assertEqual(400, response.status_code)
        self.assertEqual('application/json', response.content_type)
        self.assertEqual(json.loads(response.body)['description'],
                         "Missing required action parameter.")

        request.params = MagicMock()
        request.params.getall.return_value = ['do_test']
        request.params["action"] = "do_test"
        request.path = "/"
        response = element_handler.action(request)
        self.assertEqual(501, response.status_code)
        self.assertEqual('application/json', response.content_type)
        self.assertEqual(json.loads(response.body)['description'],
                         "Method not supported")

        # test action impl returning python primitives
        simple_data = [1, 2]
        element_handler.model.do_test_action = lambda *a, **kwa: simple_data
        response = element_handler.action(request)
        self.assertEqual(200, response.status_code)
        self.assertEqual('application/json', response.content_type)
        self.assertEqual(json.loads(response.body), simple_data)

        # test action impl returning custom webob response
        custom_data = webob.Response(body="test", status=599,
                                     content_type="custom/test")
        element_handler.model.do_test_action = lambda *a, **kwa: custom_data
        response = element_handler.action(request)
        self.assertEqual(599, response.status_code)
        self.assertEqual('custom/test', response.content_type)
        self.assertEqual(response.body, "test")
Exemple #26
0
def test_parameter_validator(monkeypatch):
    request = MagicMock(name='request')
    request.args = {}
    request.headers = {}
    request.params = {}
    app = MagicMock(name='app')
    app.response_class = lambda a, mimetype, status: json.loads(a)['detail']
    monkeypatch.setattr('flask.request', request)
    monkeypatch.setattr('flask.current_app', app)

    def orig_handler(*args, **kwargs):
        return 'OK'

    params = [{
        'name': 'p1',
        'in': 'path',
        'type': 'integer',
        'required': True
    }, {
        'name': 'h1',
        'in': 'header',
        'type': 'string',
        'enum': ['a', 'b']
    }, {
        'name': 'q1',
        'in': 'query',
        'type': 'integer',
        'maximum': 3
    }, {
        'name': 'a1',
        'in': 'query',
        'type': 'array',
        'items': {
            'type': 'integer',
            'minimum': 0
        }
    }]
    validator = ParameterValidator(params)
    handler = validator(orig_handler)

    assert handler() == "Missing path parameter 'p1'"
    assert handler(p1='123') == 'OK'
    assert handler(
        p1='') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(
        p1='foo') == "Wrong type, expected 'integer' for path parameter 'p1'"
    assert handler(
        p1='1.2') == "Wrong type, expected 'integer' for path parameter 'p1'"

    request.args = {'q1': '4'}
    assert handler(p1=1) == 'Invalid value, must be at most 3'
    request.args = {'q1': '3'}
    assert handler(p1=1) == 'OK'

    request.args = {'a1': '1,2'}
    assert handler(p1=1) == "OK"
    request.args = {'a1': '1,a'}
    assert handler(
        p1=1) == "Wrong type, expected 'integer' for query parameter 'a1'"
    request.args = {'a1': '1,-1'}
    assert handler(p1=1) == "Invalid value, must be at least 0"
    del request.args['a1']

    request.headers = {'h1': 'a'}
    assert handler(p1='123') == 'OK'

    request.headers = {'h1': 'x'}
    assert handler(p1='123') == "Enum value must be one of ['a', 'b']"