Python resolve_response Examples

Example #1

File: test_publish.py Project: gotcha/morepath

def test_predicates():
    class app(App):
        pass

    dectate.commit(app)

    def view(self, request):
        return "all"

    def post_view(self, request):
        return "post"

    view_registry = app.config.view_registry

    view_registry.register_view(dict(model=Model), view)
    view_registry.register_view(
        dict(model=Model, request_method='POST'),
        post_view)

    model = Model()
    assert resolve_response(
        model, app().request(get_environ(path=''))).body == b'all'
    assert (
        resolve_response(
            model, app().request(get_environ(path='', method='POST'))).body ==
        b'post')

Example #2

def test_predicates():
    class app(App):
        pass

    dectate.commit(app)

    def view(self, request):
        return "all"

    def post_view(self, request):
        return "post"

    app.get_view.register(View(view), model=Model)
    app.get_view.register(View(post_view), model=Model, request_method="POST")

    model = Model()
    assert (
        resolve_response(model, app().request(get_environ(path=""))).body
        == b"all"
    )
    assert (
        resolve_response(
            model, app().request(get_environ(path="", method="POST"))
        ).body
        == b"post"
    )

Example #3

File: test_publish.py Project: binbrain/morepath

def test_predicates():
    config = setup()

    class app(App):
        testing_config = config

    config.commit()

    def view(self, request):
        return "all"

    def post_view(self, request):
        return "post"

    registry = app.registry
    register_view(registry, dict(model=Model), view)
    register_view(registry, dict(model=Model, request_method='POST'),
                  post_view)

    model = Model()
    assert resolve_response(
        app().request(get_environ(path='')), model).body == b'all'
    assert (resolve_response(app().
                             request(get_environ(path='', method='POST')),
                             model).body == b'post')

Example #4

File: test_publish.py Project: iapilgrim/morepath

def test_notfound_with_predicates():
    config = setup()
    app = App(testing_config=config)
    config.commit()

    def view(self, request):
        return "view"

    register_view(app, Model, view, predicates=dict(name=''))
    model = Model()
    request = app.request(get_environ())
    request.unconsumed = ['foo']
    with pytest.raises(NotFound):
        resolve_response(request, model)

Example #5

File: test_publish.py Project: DineshMohan0001/NEW_PYTHON

def test_notfound_with_predicates():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        return "view"

    app.get_view.register(View(view), model=Model)

    model = Model()
    request = app().request(get_environ(''))
    request.unconsumed = ['foo']
    with pytest.raises(HTTPNotFound):
        resolve_response(model, request)

Example #6

File: test_publish.py Project: blaflamme/morepath

def test_notfound_with_predicates():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        return "view"

    app.config.view_registry.register_view(dict(model=Model), view)

    model = Model()
    request = app().request(get_environ(''))
    request.unconsumed = ['foo']
    with pytest.raises(HTTPNotFound):
        resolve_response(model, request)

Example #7

File: test_publish.py Project: binbrain/morepath

def test_notfound_with_predicates():
    config = setup()

    class app(morepath.App):
        testing_config = config

    config.commit()

    def view(self, request):
        return "view"

    register_view(app.registry, dict(model=Model), view)
    model = Model()
    request = app().request(get_environ(''))
    request.unconsumed = ['foo']
    with pytest.raises(HTTPNotFound):
        resolve_response(request, model)

Example #8

File: test_publish.py Project: iapilgrim/morepath

def test_predicates():
    config = setup()
    app = App(testing_config=config)
    config.commit()

    def view(self, request):
        return "all"

    def post_view(self, request):
        return "post"

    register_view(app, Model, view, predicates=dict(name=''))
    register_view(app, Model, post_view,
                  predicates=dict(name='', request_method='POST'))

    model = Model()
    assert resolve_response(
        app.request(get_environ(path='')), model).data == 'all'
    assert (resolve_response(app.request(get_environ(path='', method='POST')),
                             model).data == 'post')

Example #9

File: test_publish.py Project: iapilgrim/morepath

def test_response_returned():
    config = setup()
    app = App(testing_config=config)
    config.commit()

    def view(self, request):
        return Response('Hello world!')

    register_view(app, Model, view)
    model = Model()
    response = resolve_response(app.request(get_environ(path='')), model)
    assert response.data == 'Hello world!'

Example #10

File: test_publish.py Project: iapilgrim/morepath

def test_view():
    config = setup()
    app = App(testing_config=config)
    config.commit()

    def view(self, request):
        return "View!"

    register_view(app, Model, view, predicates=dict(name=''))

    model = Model()
    result = resolve_response(app.request(get_environ(path='')), model)
    assert result.data == 'View!'

Example #11

File: test_publish.py Project: morepath/morepath

def test_predicates():
    class app(App):
        pass

    dectate.commit(app)

    def view(self, request):
        return "all"

    def post_view(self, request):
        return "post"

    app.get_view.register(View(view), model=Model)
    app.get_view.register(View(post_view), model=Model, request_method='POST')

    model = Model()
    assert resolve_response(
        model, app().request(get_environ(path=''))).body == b'all'
    assert (
        resolve_response(
            model, app().request(get_environ(path='', method='POST'))).body ==
        b'post')

Example #12

File: test_publish.py Project: blaflamme/morepath

def test_response_returned():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        return Response('Hello world!')

    app.config.view_registry.register_view(dict(model=Model), view)

    model = Model()
    response = resolve_response(model, app().request(get_environ(path='')))
    assert response.body == b'Hello world!'

Example #13

File: test_publish.py Project: webmaven/morepath

def test_response_returned():
    app = App()

    c = setup()
    c.configurable(app)
    c.commit()

    def view(request, model):
        return Response('Hello world!')

    register_view(app, Model, view)
    model = Model()
    response = resolve_response(app.request(get_environ(path='')), model)
    assert response.data == 'Hello world!'

Example #14

File: test_publish.py Project: blaflamme/morepath

def test_view():
    class app(App):
        pass

    dectate.commit(app)

    def view(self, request):
        return "View!"

    app.config.view_registry.register_view(dict(model=Model), view)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path='')))
    assert result.body == b'View!'

Example #15

File: test_publish.py Project: DineshMohan0001/NEW_PYTHON

def test_view():
    class app(App):
        pass

    dectate.commit(app)

    def view(self, request):
        return "View!"

    app.get_view.register(View(view), model=Model)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path='')))
    assert result.body == b'View!'

Example #16

File: test_publish.py Project: DineshMohan0001/NEW_PYTHON

def test_response_returned():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        return Response('Hello world!')

    app.get_view.register(View(view), model=Model)

    model = Model()
    response = resolve_response(model, app().request(get_environ(path='')))
    assert response.body == b'Hello world!'

Example #17

File: test_publish.py Project: webmaven/morepath

def test_view():
    app = App()

    c = setup()
    c.configurable(app)
    c.commit()

    def view(request, model):
        return "View!"

    register_view(app, Model, view, predicates=dict(name=''))

    model = Model()
    result = resolve_response(app.request(get_environ(path='')), model)
    assert result.data == 'View!'

Example #18

File: test_publish.py Project: iapilgrim/morepath

def test_render_html():
    config = setup()
    app = App(testing_config=config)
    config.commit()

    def view(self, request):
        return '<p>Hello world!</p>'

    register_view(app, Model, view, render=render_html)

    request = app.request(get_environ(path=''))
    model = Model()
    response = resolve_response(request, model)
    assert response.data == '<p>Hello world!</p>'
    assert response.content_type == 'text/html'

Example #19

File: test_publish.py Project: binbrain/morepath

def test_response_returned():
    config = setup()

    class app(morepath.App):
        testing_config = config

    config.commit()

    def view(self, request):
        return Response('Hello world!')

    register_view(app.registry, dict(model=Model), view)
    model = Model()
    response = resolve_response(app().request(get_environ(path='')), model)
    assert response.body == b'Hello world!'

Example #20

File: test_publish.py Project: DineshMohan0001/NEW_PYTHON

def test_render_html():
    class app(App):
        pass

    dectate.commit(app)

    def view(self, request):
        return '<p>Hello world!</p>'

    app.get_view.register(View(view, render=render_html), model=Model)

    request = app().request(get_environ(path=''))
    model = Model()
    response = resolve_response(model, request)
    assert response.body == b'<p>Hello world!</p>'
    assert response.content_type == 'text/html'

Example #21

File: test_publish.py Project: morepath/morepath

def test_render_html():
    class app(App):
        pass

    dectate.commit(app)

    def view(self, request):
        return '<p>Hello world!</p>'

    app.get_view.register(View(view, render=render_html), model=Model)

    request = app().request(get_environ(path=''))
    model = Model()
    response = resolve_response(model, request)
    assert response.body == b'<p>Hello world!</p>'
    assert response.content_type == 'text/html'

Example #22

File: test_publish.py Project: binbrain/morepath

def test_view():
    config = setup()

    class app(App):
        testing_config = config

    config.commit()

    def view(self, request):
        return "View!"

    register_view(app.registry, dict(model=Model), view)

    model = Model()
    result = resolve_response(app().request(get_environ(path='')), model)
    assert result.body == b'View!'

Example #23

File: test_publish.py Project: iapilgrim/morepath

def test_view_after():
    config = setup()
    app = App(testing_config=config)
    config.commit()

    def view(self, request):
        @request.after
        def set_header(response):
            response.headers.add('Foo', 'FOO')
        return "View!"

    register_view(app, Model, view, predicates=dict(name=''))

    model = Model()
    result = resolve_response(app.request(get_environ(path='')), model)
    assert result.data == 'View!'
    assert result.headers.get('Foo') == 'FOO'

Example #24

File: test_publish.py Project: morepath/morepath

def test_view_after():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        @request.after
        def set_header(response):
            response.headers.add('Foo', 'FOO')
        return "View!"

    app.get_view.register(View(view), model=Model)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path='')))
    assert result.body == b'View!'
    assert result.headers.get('Foo') == 'FOO'

Example #25

def test_view_after():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        @request.after
        def set_header(response):
            response.headers.add('Foo', 'FOO')
        return "View!"

    app.get_view.register(View(view), model=Model)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path='')))
    assert result.body == b'View!'
    assert result.headers.get('Foo') == 'FOO'

Example #26

File: test_publish.py Project: binbrain/morepath

def test_render_html():
    config = setup()

    class app(App):
        testing_config = config

    config.commit()

    def view(self, request):
        return '<p>Hello world!</p>'

    register_view(app.registry, dict(model=Model), view, render=render_html)

    request = app().request(get_environ(path=''))
    model = Model()
    response = resolve_response(request, model)
    assert response.body == b'<p>Hello world!</p>'
    assert response.content_type == 'text/html'

Example #27

File: test_publish.py Project: gotcha/morepath

def test_view_after_non_decorator():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def set_header(response):
        response.headers.add('Foo', 'FOO')

    def view(self, request):
        request.after(set_header)
        return "View!"

    app.config.view_registry.register_view(dict(model=Model), view)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path='')))
    assert result.body == b'View!'
    assert result.headers.get('Foo') == 'FOO'

Example #28

File: test_publish.py Project: morepath/morepath

def test_view_after_redirect():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        @request.after
        def set_header(response):
            response.headers.add('Foo', 'FOO')
        return morepath.redirect('http://example.org')

    app.get_view.register(View(view), model=Model)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path='')))
    assert result.status_code == 302
    assert result.headers.get('Location') == 'http://example.org'
    assert result.headers.get('Foo') == 'FOO'

Example #29

def test_view_after_redirect():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        @request.after
        def set_header(response):
            response.headers.add('Foo', 'FOO')
        return morepath.redirect('http://example.org')

    app.get_view.register(View(view), model=Model)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path='')))
    assert result.status_code == 302
    assert result.headers.get('Location') == 'http://example.org'
    assert result.headers.get('Foo') == 'FOO'

Example #30

def test_view_after_non_decorator():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def set_header(response):
        response.headers.add("Foo", "FOO")

    def view(self, request):
        request.after(set_header)
        return "View!"

    app.get_view.register(View(view), model=Model)

    model = Model()
    result = resolve_response(model, app().request(get_environ(path="")))
    assert result.body == b"View!"
    assert result.headers.get("Foo") == "FOO"

Example #31

File: test_publish.py Project: kod3r/morepath

def test_request_view():
    app = App()

    c = setup()
    c.configurable(app)
    c.commit()

    def view(request, model):
        return {'hey': 'hey'}

    register_view(app, Model, view, render=render_json)

    request = app.request(get_environ(path=''))
    model = Model()
    response = resolve_response(request, model)
    # when we get the response, the json will be rendered
    assert response.data == '{"hey": "hey"}'
    assert response.content_type == 'application/json'
    # but we get the original json out when we access the view
    assert request.view(model) == {'hey': 'hey'}

Example #32

File: test_publish.py Project: iapilgrim/morepath

def test_request_view():
    config = setup()
    app = App(testing_config=config)
    config.commit()

    def view(self, request):
        return {'hey': 'hey'}

    register_view(app, Model, view, render=render_json)

    request = app.request(get_environ(path=''))
    request.mounts = [app]  # XXX should do this centrally

    model = Model()
    response = resolve_response(request, model)
    # when we get the response, the json will be rendered
    assert response.data == '{"hey": "hey"}'
    assert response.content_type == 'application/json'
    # but we get the original json out when we access the view
    assert request.view(model) == {'hey': 'hey'}

Example #33

File: test_publish.py Project: morepath/morepath

def test_request_view():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        return {'hey': 'hey'}

    app.get_view.register(View(view, render=render_json), model=Model)

    request = app().request(get_environ(path=''))

    model = Model()
    response = resolve_response(model, request)
    # when we get the response, the json will be rendered
    assert response.body == b'{"hey":"hey"}'
    assert response.content_type == 'application/json'
    # but we get the original json out when we access the view
    assert request.view(model) == {'hey': 'hey'}

Example #34

File: test_publish.py Project: DineshMohan0001/NEW_PYTHON

def test_request_view():
    class app(morepath.App):
        pass

    dectate.commit(app)

    def view(self, request):
        return {'hey': 'hey'}

    app.get_view.register(View(view, render=render_json), model=Model)

    request = app().request(get_environ(path=''))

    model = Model()
    response = resolve_response(model, request)
    # when we get the response, the json will be rendered
    assert response.body == b'{"hey":"hey"}'
    assert response.content_type == 'application/json'
    # but we get the original json out when we access the view
    assert request.view(model) == {'hey': 'hey'}

Example #35

File: test_publish.py Project: webmaven/morepath

def test_view_after_non_decorator():
    app = App()

    c = setup()
    c.configurable(app)
    c.commit()

    def set_header(response):
        response.headers.add('Foo', 'FOO')

    def view(request, model):
        request.after(set_header)
        return "View!"

    register_view(app, Model, view, predicates=dict(name=''))

    model = Model()
    result = resolve_response(app.request(get_environ(path='')), model)
    assert result.data == 'View!'
    assert result.headers.get('Foo') == 'FOO'

Example #36

File: test_publish.py Project: binbrain/morepath

def test_view_after_non_decorator():
    config = setup()

    class app(morepath.App):
        testing_config = config

    config.commit()

    def set_header(response):
        response.headers.add('Foo', 'FOO')

    def view(self, request):
        request.after(set_header)
        return "View!"

    register_view(app.registry, dict(model=Model), view)

    model = Model()
    result = resolve_response(app().request(get_environ(path='')), model)
    assert result.body == b'View!'
    assert result.headers.get('Foo') == 'FOO'

Example #37

File: test_publish.py Project: AndydeCleyre/morepath

def test_conditional_view_after():
    config = setup()

    class app(morepath.App):
        testing_config = config

    config.commit()

    def view(self, request):
        if False:
            @request.after
            def set_header(response):
                response.headers.add('Foo', 'FOO')
        return "View!"

    register_view(app.registry, Model, view, predicates=dict(name=''))

    model = Model()
    result = resolve_response(app().request(get_environ(path='')), model)
    assert result.body == b'View!'
    assert result.headers.get('Foo') is None

Example #38

File: test_publish.py Project: binbrain/morepath

def test_request_view():
    config = setup()

    class app(morepath.App):
        testing_config = config

    config.commit()

    def view(self, request):
        return {'hey': 'hey'}

    register_view(app.registry, dict(model=Model), view, render=render_json)

    request = app().request(get_environ(path=''))

    model = Model()
    response = resolve_response(request, model)
    # when we get the response, the json will be rendered
    assert response.body == b'{"hey": "hey"}'
    assert response.content_type == 'application/json'
    # but we get the original json out when we access the view
    assert request.view(model) == {'hey': 'hey'}