コード例 #1
0
def test_websocket_bad_origin():
    settings = {'origins': 'http://good'}
    with testConfig(settings=settings) as config:
        config.include('h.streamer')
        req = DummyRequest(headers={'Origin': 'http://bad'})
        res = websocket(req)
        assert res.code == 403
コード例 #2
0
ファイル: test_workflow.py プロジェクト: podhmo/mokehehe
    def test_it_another_request_type(self):
        """ on /foo/craete, success redirect is /foo/list """
        from pyramid.testing import testConfig
        from zope.interface import Interface
        class IAPIRequest(Interface):
            pass

        with testConfig(autocommit=False) as config:
            config.include("mokehehe.workflow")
            config.add_route("foo.list", "/foo/list")
            config.add_route("foo.create", "/foo/create")
            config.add_route("foo.api.list", "/api/foo/list")

            with config.get_workflow().sub(IAfterModelCreate) as goto:
                goto("foo.create", "foo.list")
                goto("foo.create", "foo.api.list", request_type=IAPIRequest)
            config.commit()

            ### on request time. api request
            request2 = self._makeRequest(config)
            class route:
                name = "foo.create"
            request2.matched_route = route
            from zope.interface import directlyProvides
            directlyProvides(request2, IAPIRequest) ##on tweens

            result = request2.workflow[IAfterModelCreate].route_path()
            self.assertEqual(result, "/api/foo/list")
コード例 #3
0
    def test_register_models(self):
        with testing.testConfig() as config:
            config.include('c2cgeoform.routes')

            class MyModel:

                __tablename__ = 'mytable'

            register_models(config, [('mytable', MyModel)])
            register_routes(config, multi_application=False)

            request = testing.DummyRequest(environ={'PATH_INFO': '/mytable'})
            routes_mapper = config.registry.queryUtility(IRoutesMapper)
            info = routes_mapper(request)
            match, route = info['match'], info['route']
            self.assertEqual('c2cgeoform_index', route.name)
            self.assertEqual('mytable', match['table'])

            # We should have the single application in request.c2cgeoform_application
            application = get_application(request)
            self.assertTrue(isinstance(application, Application))
            self.assertEqual('mytable', application.tables()[0]['key'])

            self.assertEqual(
                'http://example.com/table',
                request.route_url('c2cgeoform_index', table='table'))
コード例 #4
0
ファイル: test_views.py プロジェクト: vamsikarnika/ichnaea
def views(redis, session):
    request = DummyRequest()
    with testing.testConfig(request=request) as config:
        config.include("pyramid_chameleon")
        setattr(request, "db_session", session)
        setattr(request.registry, "redis_client", redis)
        yield ContentViews(request)
コード例 #5
0
    def test_form_not_submitted(self):
        from pyramid.testing import testConfig

        class DummyRenderer(object):
            def __init__(self, macros):
                self.macros = macros

            def implementation(self):
                return self

        request = testing.DummyRequest()
        request.sdiapi = DummySDIAPI()
        context = testing.DummyResource()
        form, reset = object(), object()
        renderer = DummyRenderer({
            'login-form': form,
            'password-reset-link': reset
        })
        with testConfig() as config:
            config.testing_add_renderer(
                'substanced.sdi.views:templates/login.pt', renderer)
            result = self._callFUT(context, request)
        self.assertEqual(result['url'], '/mgmt_path')
        self.assertEqual(result['came_from'], 'http://example.com')
        self.assertEqual(result['login'], '')
        self.assertEqual(result['password'], '')
        self.assertTrue(result['login_template'] is renderer)
        self.assertEqual(request.session['sdi.came_from'],
                         'http://example.com')
コード例 #6
0
ファイル: test_views.py プロジェクト: crankycoder/ichnaea
 def views(self, map_config, redis, session):
     request = DummyRequest()
     with testing.testConfig(request=request) as config:
         config.include('pyramid_chameleon')
         setattr(request, 'db_session', session)
         setattr(request.registry, 'redis_client', redis)
         yield ContentViews(request)
コード例 #7
0
 def test_not_match(self):
     with testing.testConfig() as config:
         self._config(config, 'app')
         pred = ApplicationRoutePredicate(config, 'anything')
         context = {'match': {'application': 'not_registered_application'}}
         request = testing.DummyRequest()
         self.assertFalse(pred(context, request))
コード例 #8
0
ファイル: conftest.py プロジェクト: lamcla/lms
def pyramid_config(pyramid_request):
    """
    Return a test Pyramid config (Configurator) object.

    The returned Configurator uses the dummy request from the pyramid_request
    fixture above.

    """

    with testing.testConfig(request=pyramid_request,
                            settings=TEST_SETTINGS) as config:
        config.include("pyramid_jinja2")
        config.include("pyramid_services")
        config.include("pyramid_tm")

        config.include("lms.sentry")
        config.include("lms.models")
        config.include("lms.db")
        config.include("lms.routes")

        config.add_static_view(name="export", path="lms:static/export")
        config.add_static_view(name="static", path="lms:static")

        config.action(None, configure_jinja2_assets, args=(config, ))

        apply_request_extensions(pyramid_request)

        yield config
コード例 #9
0
ファイル: test_renderer.py プロジェクト: ramalho/substanced
 def test_functional_using_assetspec(self):
     from ..._compat import u
     renderer = self._makeOne(())
     with testing.testConfig() as config:
         config.include('pyramid_chameleon')
         result = renderer('substanced.widget.tests:fixtures/test.pt')
     self.assertEqual(result.strip(), u('<div>Test</div>'))
コード例 #10
0
ファイル: test_esstorage.py プロジェクト: vsmalladi/snovault
    def test_get_rev_links_with_switched_storage(self):
        # If we have a model that was loaded from elasticsearch
        # but the datastore is now database, we need to be sure
        # to get the rev links from the database.
        from pyramid.testing import (
            DummyRequest,
            testConfig,
        )
        from ..esstorage import (
            CachedModel,
            PickStorage,
        )

        model = CachedModel({'_source': {'uuid': 'dummy'}})
        model2 = Mock()
        read = Mock()
        write = Mock()
        write.get_by_uuid.return_value = model2
        storage = PickStorage(read, write)

        request = DummyRequest()
        request.datastore = 'database'
        with testConfig(request=request):
            storage.get_rev_links(model, 'rel')

        assert write.get_rev_links.called_once
        rev_links_model = write.get_rev_links.call_args[0][0]
        assert rev_links_model is model2
 def views(self, map_config, redis, session):
     request = DummyRequest()
     with testing.testConfig(request=request) as config:
         config.include('pyramid_chameleon')
         setattr(request, 'db_session', session)
         setattr(request.registry, 'redis_client', redis)
         yield ContentViews(request)
コード例 #12
0
ファイル: test_sdi.py プロジェクト: timgates42/substanced
 def test_get_macro_without_name(self):
     request = testing.DummyRequest()
     inst = self._makeOne(request)
     with testing.testConfig() as config:
         config.include('pyramid_chameleon')
         macro = inst.get_macro('substanced.sdi.views:templates/master.pt')
     self.assertTrue(macro.macros)
コード例 #13
0
def test_openapi_view() -> None:
    """Test registration a an openapi view."""
    with testConfig() as config:
        config.include("pyramid_openapi3")

        with tempfile.NamedTemporaryFile() as document:
            document.write(MINIMAL_DOCUMENT)
            document.seek(0)

            config.pyramid_openapi3_spec(document.name,
                                         route="/foo.yaml",
                                         route_name="foo_api_spec")

        config.add_route("foo", "/foo")
        view_func = lambda *arg: "bar"  # noqa: E731
        config.add_view(openapi=True,
                        renderer="json",
                        view=view_func,
                        route_name="foo")

        request_interface = config.registry.queryUtility(IRouteRequest,
                                                         name="foo")
        view = config.registry.adapters.registered(
            (IViewClassifier, request_interface, Interface), IView, name="")
        request = DummyRequest(config=config, content_type="text/html")
        apply_request_extensions(request)
        request.matched_route = DummyRoute(name="foo", pattern="/foo")
        context = None
        response = view(context, request)

        assert response.json == "bar"
コード例 #14
0
def pyramid_config(pyramid_request):
    """
    Return a test Pyramid config (Configurator) object.

    The returned Configurator uses the dummy request from the pyramid_request
    fixture above.

    """
    # Settings that will end up in pyramid_request.registry.settings.
    settings = {
        'lti_server': 'http://TEST_LTI_SERVER.com',
        'sqlalchemy.url': TEST_DATABASE_URL,
        'client_origin': 'http://TEST_H_SERVER.is',
        'via_url': 'http://TEST_VIA_SERVER.is',
    }

    with testing.testConfig(request=pyramid_request, settings=settings) as config:
        config.include('pyramid_services')
        config.include('lti.db')

        apply_request_extensions(pyramid_request)

#        auth_data_svc = mock.create_autospec(auth_data.AuthDataService, instance=True)
#        auth_data_svc.get_canvas_server.return_value = 'https://TEST_CANVAS_SERVER.com'
#        auth_data_svc.get_lti_secret.return_value = 'TEST_CLIENT_SECRET'
#        auth_data_svc.get_lti_token.return_value = 'TEST_OAUTH_ACCESS_TOKEN'
#        auth_data_svc.get_lti_refresh_token.return_value = 'TEST_OAUTH_REFRESH_TOKEN'
#        config.register_service(auth_data_svc, name='auth_data')

        yield config
コード例 #15
0
def test_register_routes_with_factory() -> None:
    """Test registration routes with root_factory."""
    with testConfig() as config:
        config.include("pyramid_openapi3")
        with tempfile.NamedTemporaryFile() as tempdoc:
            tempdoc.write(
                b"""\
openapi: "3.0.0"
info:
  version: "1.0.0"
  title: Foo API
paths:
  /foo:
    x-pyramid-route-name: foo
    x-pyramid-root-factory: pyramid_openapi3.tests.test_routes.dummy_factory
    get:
      responses:
        200:
          description: A foo
"""
            )
            tempdoc.seek(0)
            config.pyramid_openapi3_spec(tempdoc.name)
            config.pyramid_openapi3_register_routes()
            config.make_wsgi_app()
コード例 #16
0
def test_add_spec_view() -> None:
    """Test registration of a view that serves the openapi document."""
    with testConfig() as config:
        config.include("pyramid_openapi3")

        with tempfile.NamedTemporaryFile() as document:
            document.write(MINIMAL_DOCUMENT)
            document.seek(0)

            config.pyramid_openapi3_spec(document.name,
                                         route="/foo.yaml",
                                         route_name="foo_api_spec")

            # assert settings
            openapi_settings = config.registry.settings["pyramid_openapi3"]
            assert openapi_settings["filepath"] == document.name
            assert openapi_settings["spec_route_name"] == "foo_api_spec"
            assert openapi_settings["spec"].info.title == "Foo API"
            assert isinstance(openapi_settings["request_validator"],
                              RequestValidator)
            assert isinstance(openapi_settings["response_validator"],
                              ResponseValidator)

            # assert route
            mapper = config.registry.getUtility(IRoutesMapper)
            routes = mapper.get_routes()
            assert routes[0].name == "foo_api_spec"
            assert routes[0].path == "/foo.yaml"

            # assert view
            request = config.registry.queryUtility(IRouteRequest,
                                                   name="foo_api_spec")
            view = config.registry.adapters.registered(
                (IViewClassifier, request, Interface), IView, name="")
            assert view(request=None, context=None).body == MINIMAL_DOCUMENT
コード例 #17
0
ファイル: assets_test.py プロジェクト: Forethinker/h
def test_subscriber_predicate(settings):
    """Test that the ``asset_request`` subscriber predicate.

    It should correctly match asset requests when its value is ``True``,
    and other requests when ``False``.
    """
    mock1 = Mock()
    mock2 = Mock()

    with testConfig(settings=settings) as config:
        config.include(assets)
        config.add_subscriber(mock1, DummyEvent, asset_request=False)
        config.add_subscriber(mock2, DummyEvent, asset_request=True)

        request1 = DummyRequest('/')
        request1.matched_route = None

        pattern = config.get_webassets_env().url + '*subpath'
        request2 = DummyRequest(config.get_webassets_env().url + '/t.png')
        request2.matched_route = Route('__' + pattern, pattern)

        event1 = DummyEvent(request1)
        event2 = DummyEvent(request2)

        config.registry.notify(event1)
        config.registry.notify(event2)

        mock1.assert_called_onceventwith(event1)
        mock2.assert_called_onceventwith(event2)
コード例 #18
0
def test_echo():
    with testConfig() as config:
        config.add_route('echo', '/echo/{name}')
        req = DummyRequest(path='/echo/hello')
        resp = echo(req)

        assert resp.body == 'hello'
コード例 #19
0
ファイル: test_assets.py プロジェクト: helemaalbigt/h
def test_subscriber_predicate(settings):
    """Test that the ``asset_request`` subscriber predicate.

    It should correctly match asset requests when its value is ``True``,
    and other requests when ``False``.
    """
    mock1 = Mock()
    mock2 = Mock()

    with testConfig(settings=settings) as config:
        # pylint: disable=attribute-defined-outside-init
        config.include(assets)
        config.add_subscriber(mock1, DummyEvent, asset_request=False)
        config.add_subscriber(mock2, DummyEvent, asset_request=True)

        request1 = DummyRequest('/')
        request1.matched_route = None

        pattern = config.get_webassets_env().url + '*subpath'
        request2 = DummyRequest(config.get_webassets_env().url + '/t.png')
        request2.matched_route = Route('__' + pattern, pattern)

        event1 = DummyEvent(request1)
        event2 = DummyEvent(request2)

        config.registry.notify(event1)
        config.registry.notify(event2)

        mock1.assert_called_onceventwith(event1)
        mock2.assert_called_onceventwith(event2)
コード例 #20
0
    def test_route_with_all(self):
        from c2cgeoportal_geoportal.views.dynamic import DynamicView

        with testConfig(
            settings=self._get_settings(
                {
                    "test": {
                        "routes": {
                            "XTest": {
                                "name": "route_with_all",
                                "kw": {"key1": "v1", "key2": "v2"},
                                "elements": ["s1", "s2"],
                                "params": {"test": "value"},
                            }
                        }
                    }
                }
            )
        ) as config:
            config.add_static_view(name="static", path="/etc/geomapfish/static")
            config.add_route("base", "/", static=True)
            config.add_route("test", "/test")
            config.add_route("route_with_all", "/test/{key1}/{key2}")
            request = DummyRequest({"interface": "test"})
            request.get_organization_interface = lambda interface: interface
            dynamic = DynamicView(request).dynamic()

        assert "XTest" in dynamic["constants"], dynamic
        assert dynamic["constants"]["XTest"] == "http://example.com/test/v1/v2/s1/s2?test=value"
コード例 #21
0
 def test_view_notfound(self):
     with testing.testConfig():
         request = testing.DummyRequest()
         request.matchdict['prefix'] = 'aaaa'
         request.matchdict['name'] = 'nonexistent-image.jpg'
         with self.assertRaises(HTTPNotFound):
             ImageView(request)()
 def test_alternate_homepage(self, config):
     request = DummyRequest()
     with testing.testConfig(request=request) as config:
         assert not configure_content(config, enable=False)
         res = empty_homepage_view(request)
         assert res.content_type == 'text/html'
         assert b'It works' in res.body
コード例 #23
0
def test_init_with_debug(capsys, mock_timestamper):
    logger = structlog.get_logger()

    # Configure pyramid app
    settings = {'logging.level': 'DEBUG'}
    with pyramid_testing.testConfig(settings=settings) as config:
        config.include(includeme)
        # Create some log messages
        logger.info('info msg')
        logger.debug('debug msg')
        logger.error('error msg')

    # Check for results
    captured = capsys.readouterr()
    expected = (
        "event='logging configuration initialized' logger='press.logging'"
        " level='info' timestamp='round and round'"
        "\n"
        "event='debug logging enabled' logger='press.logging'"
        " level='debug' timestamp='round and round'"
        "\n"
        "event='info msg' logger='tests.unit.test_logging'"
        " level='info' timestamp='round and round'"
        "\n"
        "event='debug msg' logger='tests.unit.test_logging'"
        " level='debug' timestamp='round and round'"
        "\n"
        "event='error msg' logger='tests.unit.test_logging'"
        " level='error' timestamp='round and round'"
        "\n"
    )
    assert captured.out == expected
    assert captured.err == ''
コード例 #24
0
    def test_route_with_keywords(self):
        from c2cgeoportal_geoportal.views.dynamic import DynamicView

        with testConfig(settings=self._get_settings({
                "test": {
                    "routes": {
                        "XTest": {
                            "name": "route_with_keywords",
                            "kw": {
                                "key1": "v1",
                                "key2": "v2"
                            }
                        }
                    }
                }
        })) as config:
            config.add_static_view(name="static",
                                   path="/etc/geomapfish/static")
            config.add_route("test", "/test")
            config.add_route("route_with_keywords", "/test/{key1}/{key2}")
            request = DummyRequest({"interface": "test"})
            dynamic = DynamicView(request).dynamic()

        assert "XTest" in dynamic["constants"], dynamic
        assert dynamic["constants"]["XTest"] == "http://example.com/test/v1/v2"
コード例 #25
0
ファイル: tests.py プロジェクト: douardda/pyramid_multiauth
    def test_policy_selected_event(self):
        from pyramid.testing import testConfig
        from pyramid_multiauth import MultiAuthPolicySelected

        policies = [TestAuthnPolicy2(), TestAuthnPolicy3()]
        policy = MultiAuthenticationPolicy(policies)
        # Simulate loading from config:
        policies[0]._pyramid_multiauth_name = "name"

        with testConfig() as config:
            request = DummyRequest()

            selected_policy = []

            def track_policy(event):
                selected_policy.append(event)

            config.add_subscriber(track_policy, MultiAuthPolicySelected)

            self.assertEquals(policy.authenticated_userid(request), "test2")

            self.assertEquals(selected_policy[0].policy, policies[0])
            self.assertEquals(selected_policy[0].policy_name, "name")
            self.assertEquals(selected_policy[0].userid, "test2")
            self.assertEquals(selected_policy[0].request, request)
            self.assertEquals(len(selected_policy), 1)

            # Effective principals also triggers an event when groupfinder
            # is provided.
            policy_with_group = MultiAuthenticationPolicy(
                policies, lambda u, r: ['foo'])
            policy_with_group.effective_principals(request)
            self.assertEquals(len(selected_policy), 2)
コード例 #26
0
ファイル: test_sdi.py プロジェクト: timgates42/substanced
 def test_main_template(self):
     self.config.testing_securitypolicy(permissive=False)
     request = testing.DummyRequest()
     inst = self._makeOne(request)
     with testing.testConfig() as config:
         config.include('pyramid_chameleon')
         self.assertTrue(inst.main_template)
コード例 #27
0
 def test_url_segment_not_match(self):
     with testing.testConfig() as config:
         self._config(config, 'app', url_segment='some_segment_url')
         pred = ApplicationRoutePredicate(config, 'anything')
         context = {'match': {'application': 'app'}}
         request = testing.DummyRequest()
         self.assertFalse(pred(context, request))
コード例 #28
0
    def test_policy_selected_event(self):
        from pyramid.testing import testConfig
        from pyramid_multiauth import MultiAuthPolicySelected

        policies = [TestAuthnPolicy2(), TestAuthnPolicy3()]
        policy = MultiAuthenticationPolicy(policies)
        # Simulate loading from config:
        policies[0]._pyramid_multiauth_name = "name"

        with testConfig() as config:
            request = DummyRequest()

            selected_policy = []

            def track_policy(event):
                selected_policy.append(event)

            config.add_subscriber(track_policy, MultiAuthPolicySelected)

            self.assertEquals(policy.authenticated_userid(request), "test2")

            self.assertEquals(selected_policy[0].policy, policies[0])
            self.assertEquals(selected_policy[0].policy_name, "name")
            self.assertEquals(selected_policy[0].userid, "test2")
            self.assertEquals(selected_policy[0].request, request)
            self.assertEquals(len(selected_policy), 1)

            # Effective principals also triggers an event when groupfinder
            # is provided.
            policy_with_group = MultiAuthenticationPolicy(policies,
                                                          lambda u, r: ['foo'])
            policy_with_group.effective_principals(request)
            self.assertEquals(len(selected_policy), 2)
コード例 #29
0
ファイル: test_pyramid.py プロジェクト: pumazi/cnx-db
def test_includeme_with_usage(db_settings, db_wipe):
    # Initialize a table to ensure table reflection is working.
    conn_str = db_settings['db.common.url']
    with psycopg2.connect(conn_str) as conn:
        with conn.cursor() as cur:
            cur.execute("CREATE TABLE smurfs ("
                        "  name TEXT PRIMARY KEY,"
                        "  role TEXT,"
                        "  tastiness INTEGER);")
        conn.commit()

    # Call the target function
    request = testing.DummyRequest()
    with testing.testConfig(request=request, settings=db_settings) as config:
        includeme(config)

        # The request doesn't yet have the added methods and I'm not sure
        # how to make the test request have those, so we'll call them
        # directly instead. We aren't testing the framework's
        # add_request_method anyhow.

        # Check the engines definitions
        # ... looking for the unnamed util lookup
        assert str(get_db_engine(request).url) == db_settings['db.common.url']
        # ... looking for the named util lookup
        expected_url = db_settings['db.readonly.url']
        assert str(get_db_engine(request, 'readonly').url) == expected_url

        with pytest.raises(ComponentLookupError):
            get_db_engine(request, 'foobar')

        # Check the tables definition
        assert hasattr(db_tables(request), 'smurfs')
コード例 #30
0
ファイル: test_login.py プロジェクト: Adniel/substanced
 def test_form_submitted_success_w_locator_adapter(self):
     from pyramid.testing import testConfig
     from zope.interface import Interface
     from ....interfaces import IUserLocator
     from ....testing import make_site
     request = testing.DummyRequest()
     request.params['form.submitted'] = True
     request.params['login'] = '******'
     request.params['password'] = '******'
     request.sdiapi = DummySDIAPI()
     request.params['csrf_token'] = request.session.get_csrf_token()
     context = make_site()
     user = DummyUser(1)
     user.__oid__ = 2
     locator = DummyLocator(user)
     def _locator(context, request):
         return locator
     with testConfig() as config:
         config.testing_add_renderer(
                 'substanced.sdi.views:templates/login.pt')
         config.registry.registerAdapter(_locator, (Interface, Interface),
                                         IUserLocator)
         result = self._callFUT(context, request)
     self.assertEqual(result.location, 'http://example.com')
     self.assertTrue(result.headers)
     self.assertTrue('sdi.came_from' not in request.session)
コード例 #31
0
def test_it():
    from pyramid.testing import testConfig

    with testConfig() as config:
        config.include("stringexchange")
        config.add_route("hello", "/")

        def hello_view(context, request):
            from pyramid.response import Response
            js = request.string_exchange.publisher("js")
            response = Response("""
            <html><head>{}</head><body></body></html>
            """.format(request.string_exchange.subscribe("js")))

            js.publish('<script src="my.js></script>"')
            assert "my.js" not in response.text
            return response

        config.add_view(hello_view, route_name="hello")

        # request time
        router = _makeRouter(config)

        request = _makeRequest(config, path="/")
        response = router.handle_request(request)

        assert "my.js" in response.text
コード例 #32
0
    def test_form_submitted_success_w_locator_adapter(self):
        from pyramid.testing import testConfig
        from zope.interface import Interface
        from ....interfaces import IUserLocator
        from ....testing import make_site
        request = testing.DummyRequest()
        request.params['form.submitted'] = True
        request.params['login'] = '******'
        request.params['password'] = '******'
        request.sdiapi = DummySDIAPI()
        request.params['csrf_token'] = request.session.get_csrf_token()
        context = make_site()
        user = DummyUser(1)
        user.__oid__ = 2
        locator = DummyLocator(user)

        def _locator(context, request):
            return locator

        with testConfig() as config:
            config.testing_add_renderer(
                'substanced.sdi.views:templates/login.pt')
            config.registry.registerAdapter(_locator, (Interface, Interface),
                                            IUserLocator)
            result = self._callFUT(context, request)
        self.assertEqual(result.location, 'http://example.com')
        self.assertTrue(result.headers)
        self.assertTrue('sdi.came_from' not in request.session)
コード例 #33
0
ファイル: test_views.py プロジェクト: crankycoder/ichnaea
 def test_alternate_homepage(self, config):
     request = DummyRequest()
     with testing.testConfig(request=request) as config:
         assert not configure_content(config, enable=False)
         res = empty_homepage_view(request)
         assert res.content_type == 'text/html'
         assert b'It works' in res.body
コード例 #34
0
ファイル: test_viewobject.py プロジェクト: podhmo/mokehehe
    def test_it(self):
        from pyramid.testing import testConfig
        from mokehehe.viewobject import Mapper, parse_get, viewobject_method

        def todict(v):
            return {"value": v}

        with testConfig() as config:
            class Ob(object):
                def __call__(self, message):
                    return message * 2

                @viewobject_method
                def nihongo(self):
                    return "hai"

            config.include("mokehehe.viewobject")
            config.add_route("hello", "/")
            MOb = config.add_mapped_viewobject(Mapper(parse_get, todict), Ob)
            self.assertIsNotNone(MOb)
            config.add_view(MOb, route_name="hello", renderer="json")
            config.add_view(MOb, route_name="hello", request_type=INihongoRequest, attr="nihongo", renderer="json")
            config.commit()

            result = self.callView(config, "/hello", GET={"message": "hello"})
            self.assertEqual(result.body.decode("utf-8"), u'{"value": "hellohello"}')

            result = self.callView(config, "/hello", iface=INihongoRequest, GET={})
            self.assertEqual(result.body.decode("utf-8"), u'{"value": "hai"}')
コード例 #35
0
ファイル: tests.py プロジェクト: Connexions/pyramid_sawing
    def test_logging(self):
        """Test that the includeme function loads the logging config."""
        from .main import includeme
        with testing.testConfig(settings=self.settings) as config:
            includeme(config)

        # Set up the loggers
        root = logging.getLogger()
        local = logging.getLogger('pyramid_sawing.tests')

        # Try logging...
        root_log_msg = 'O⋮o'
        root.error(root_log_msg)
        local_log_msg = '>,<'
        local.info(local_log_msg)

        global logio
        logio.seek(self.logio_position)
        log_lines = logio.readlines()
        self.assertEqual(len(log_lines), 2)
        log_lines = [l.rstrip('\n') for l in log_lines]

        # Check the root message...
        parsed_root_msg = log_lines[0].split(';.;')
        self.assertEqual(parsed_root_msg, ['ERROR', root_log_msg])
        parsed_local_msg = log_lines[1].split(';.;')
        self.assertEqual(parsed_local_msg,
                         ['INFO ', socket.gethostname(), local_log_msg])
コード例 #36
0
def test_includeme_with_usage(db_settings, db_wipe):
    # Initialize a table to ensure table reflection is working.
    conn_str = db_settings['db.common.url']
    with psycopg2.connect(conn_str) as conn:
        with conn.cursor() as cur:
            cur.execute("CREATE TABLE smurfs ("
                        "  name TEXT PRIMARY KEY,"
                        "  role TEXT,"
                        "  tastiness INTEGER);")
        conn.commit()

    # Call the target function
    request = testing.DummyRequest()
    with testing.testConfig(request=request, settings=db_settings) as config:
        includeme(config)

        # The request doesn't yet have the added methods and I'm not sure
        # how to make the test request have those, so we'll call them
        # directly instead. We aren't testing the framework's
        # add_request_method anyhow.

        # Check the engines definitions
        # ... looking for the unnamed util lookup
        assert str(get_db_engine(request).url) == db_settings['db.common.url']
        # ... looking for the named util lookup
        expected_url = db_settings['db.readonly.url']
        assert str(get_db_engine(request, 'readonly').url) == expected_url

        with pytest.raises(ComponentLookupError):
            get_db_engine(request, 'foobar')

        # Check the tables definition
        assert hasattr(db_tables(request), 'smurfs')
コード例 #37
0
ファイル: test_sdi.py プロジェクト: ramalho/substanced
 def test_main_template(self):
     self.config.testing_securitypolicy(permissive=False)
     request = testing.DummyRequest()
     inst = self._makeOne(request)
     with testing.testConfig() as config:
         config.include("pyramid_chameleon")
         self.assertTrue(inst.main_template)
コード例 #38
0
ファイル: test_sdi.py プロジェクト: ramalho/substanced
 def test_get_macro_with_name(self):
     request = testing.DummyRequest()
     inst = self._makeOne(request)
     with testing.testConfig() as config:
         config.include("pyramid_chameleon")
         macro = inst.get_macro("substanced.sdi.views:templates/master.pt", "main")
     self.assertTrue(macro.include)
コード例 #39
0
def test_add_spec_view_directory_already_defined() -> None:
    """Test that creating a spec more than once raises an Exception."""
    with testConfig() as config:
        config.include("pyramid_openapi3")

        with tempfile.NamedTemporaryFile() as document:
            document.write(MINIMAL_DOCUMENT)
            document.seek(0)

            config.pyramid_openapi3_spec(document.name,
                                         route="/foo",
                                         route_name="foo_api_spec")

            with tempfile.TemporaryDirectory() as directory:
                spec_name = os.path.join(directory, "openapi.yaml")
                spec_paths_name = os.path.join(directory, "paths.yaml")
                with open(spec_name, "wb") as f:
                    f.write(SPLIT_DOCUMENT)
                with open(spec_paths_name, "wb") as f:
                    f.write(SPLIT_DOCUMENT_PATHS)

                with pytest.raises(
                        ConfigurationError,
                        match=
                    ("Spec has already been configured. You may only call "
                     "pyramid_openapi3_spec or pyramid_openapi3_spec_directory once"
                     ),
                ):
                    config.pyramid_openapi3_spec_directory(
                        spec_name,
                        route="/foo.yaml",
                        route_name="foo_api_spec")
コード例 #40
0
ファイル: test_registering.py プロジェクト: podhmo/mokehehe
    def test_multiple(self):
        from pyramid.testing import testConfig

        class model:
            name = "model"
        class model2:
            name = "model2"

        def resource_factory(target):
            return target

        def create_route_name(target, fullname):
            return "{}.{}".format(fullname, target.name)

        def create_path(target, fullname):
            return "/{}/{}".format(fullname.replace(".", "/"), target.name)

        def myview(context, request):
            return "ok"

        with testConfig() as config:
            config.include("mokehehe.registering")
            builder = config.registering_builder("foo", resource_factory=resource_factory)
            with builder.sub("bar", route_name_craete=create_route_name, path_create=create_path) as view_builder:
                view_builder.build(view=myview).update(renderer="json")

            ## call
            builder(model)
            builder(model2)

            self.assertEqual(len(config.get_routes_mapper().get_routes()), 2)
コード例 #41
0
    def test_route_with_all(self):
        from c2cgeoportal_geoportal.views.dynamic import DynamicView
        with testConfig(settings=self._get_settings({
                'test': {
                    'routes': {
                        'XTest': {
                            'name': 'route_with_all',
                            'kw': {
                                'key1': 'v1',
                                'key2': 'v2',
                            },
                            'elements': ['s1', 's2'],
                            'params': {
                                'test': 'value'
                            }
                        }
                    }
                }
        })) as config:
            config.add_static_view(name='static',
                                   path='/etc/geomapfish/static')
            config.add_route('test', '/test')
            config.add_route('route_with_all', '/test/{key1}/{key2}')
            request = DummyRequest({'interface': 'test'})
            dynamic = DynamicView(request).dynamic()

        assert 'XTest' in dynamic['constants'], dynamic
        assert dynamic['constants'][
            'XTest'] == 'http://example.com/test/v1/v2/s1/s2?test=value'
コード例 #42
0
def test_openapi_view_validate_HTTPExceptions():
    """Test that raised HTTPExceptions are validated against the spec.

    I.e. create a dummy view that raises 403 Forbidden. The openapi integration
    should re-raise it as InvalidResponse because 403 is not on the list of
    responses in MINIMAL_DOCUMENT.
    """
    with testConfig() as config:
        config.include("pyramid_openapi3")

        with tempfile.NamedTemporaryFile() as document:
            document.write(MINIMAL_DOCUMENT)
            document.seek(0)

            config.pyramid_openapi3_spec(
                document.name, route="/foo.yaml", route_name="foo_api_spec"
            )

        config.add_route("foo", "/foo")
        view = lambda *arg: (_ for _ in ()).throw(  # noqa: E731
            exception_response(403, json_body="Forbidden")
        )
        config.add_view(openapi=True, renderer="json", view=view, route_name="foo")

        request_interface = config.registry.queryUtility(IRouteRequest, name="foo")
        view = config.registry.adapters.registered(
            (IViewClassifier, request_interface, Interface), IView, name=""
        )
        request = DummyRequest(config=config)
        request.matched_route = DummyRoute(name="foo", pattern="/foo")

        with pytest.raises(InvalidResponse) as exc:
            view(request=request, context=None)

        assert str(exc.value) == "Unknown response http status: 403"
コード例 #43
0
ファイル: test_users.py プロジェクト: zennsocial/fishtest
 def test_stop_run(self):
     with testing.testConfig() as config:
         config.add_route('api_stop_run', '/api/stop_run')
         self.assertEqual(stop_run(self.request), '{}')
         self.assertEqual(
             self.request.rundb.get_run(
                 self.request.json_body['run_id'])['stop_reason'], 'travis')
コード例 #44
0
ファイル: tests.py プロジェクト: Connexions/pyramid_sawing
    def test_logging_a_request(self):
        request = Request.blank('/foo')
        request.environ.update({
            'HTTP_VERSION': '1.1',
            'REMOTE_ADDR': '127.0.0.1',
            })
        response = mock.Mock()
        response.status = '404 Not Found'
        response.headers = {'content-length': 0}
        handler = mock.Mock(return_value=response)
        config_kwargs = {'request': request, 'settings': self.settings}
        with testing.testConfig(**config_kwargs) as config:
            request.registry = config.registry
            tween = self.make_one(handler=handler, registry=config.registry)
            tween(request)

        global logio
        logio.seek(self.logio_position)
        log_lines = logio.readlines()
        self.assertEqual(len(log_lines), 1)
        log_lines = [l.rstrip('\n') for l in log_lines]

        log_line = log_lines[0]
        self.assertEqual(
            log_line,
            '127.0.0.1 - - [asctime] "GET http://localhost:80/foo 1.1" 404 Not Found 0 "-" "-"')
コード例 #45
0
ファイル: test_notifier.py プロジェクト: RichardLitt/h
def test_reply_notification_content():
    """
    The reply notification should have a subject, and both plain and
    html bodies.
    """
    with testConfig() as config:
        config.include('pyramid_chameleon')

        annotation = create_annotation()
        request = DummyRequest()

        with patch('h.auth.local.models.User') as mock_user:
            user = Mock(email='acct:parent@testdomain')
            mock_user.get_by_username.return_value = user

            notification = notifier.ReplyTemplate.generate_notification(
                request, annotation, {})

            assert notification['status']
            assert notification['recipients'] == ['acct:parent@testdomain']
            assert 'testuser has just left a reply to your annotation on' in \
                notification['text']
            assert '<a href="http://example.com/u/testuser">testuser</a> '\
                'has just left a reply to your annotation on' \
                in notification['html']
            assert notification['subject'] == \
                'testuser has replied to your annotation\n'
コード例 #46
0
ファイル: test_views.py プロジェクト: riotousliving/rlfarm
def test_csa_founder_signup(customer_mock, charge_mock, post):
    with testing.testConfig() as config:
        config.add_route('signup_success', '/success')
        request = testing.DummyRequest(post=post)
        request.registry.settings['stripe.api_key'] = 'api_key'

        with pytest.raises(HTTPFound):
            csa_founder_signup(request)
コード例 #47
0
ファイル: tests.py プロジェクト: Pylons/pyramid_exclog
 def test_integer_user_id(self):
     # userids can apparently be integers as well
     from pyramid.request import Request
     with testing.testConfig() as config:
         config.testing_securitypolicy(userid=42)
         request = Request.blank('/')
         msg = self._callFUT(request)
     self.assertTrue('42' in msg)
コード例 #48
0
ファイル: tests.py プロジェクト: Pylons/pyramid_exclog
 def test_non_ascii_bytes_in_userid(self):
     from pyramid.request import Request
     byte_str = b'\xe6\xbc\xa2'
     with testing.testConfig() as config:
         config.testing_securitypolicy(userid=byte_str)
         request = Request.blank('/')
         msg = self._callFUT(request)
     self.assertTrue(repr(byte_str) in msg, msg)
コード例 #49
0
ファイル: test_pyramid.py プロジェクト: pumazi/cnx-db
def pyramid_config(db_settings):
    """Preset the discoverable settings, where the pyramid
    application may want to define these itself, rather than
    have cnx-db discover them.

    """
    with testing.testConfig(settings=db_settings) as config:
        yield config
コード例 #50
0
ファイル: lib_test.py プロジェクト: Treora/h
def test_get_client_not_ok():
    mock_factory = MagicMock()
    mock_factory.return_value = None
    settings = {'h.client_id': '1234'}
    with testing.testConfig(settings=settings) as config:
        registry = config.registry
        registry.registerUtility(mock_factory, interfaces.IClientFactory)
        request = testing.DummyRequest(registry=config.registry)
        assert lib.get_client(request, '9876') is None
コード例 #51
0
ファイル: conftest.py プロジェクト: pombredanne/h
def pyramid_config(pyramid_settings, pyramid_request):
    """Pyramid configurator object."""
    with testing.testConfig(request=pyramid_request,
                            settings=pyramid_settings) as config:
        # Include pyramid_services so it's easy to set up fake services in tests
        config.include('pyramid_services')
        apply_request_extensions(pyramid_request)

        yield config
コード例 #52
0
ファイル: lib_test.py プロジェクト: Treora/h
def test_get_client_ok():
    mock_factory = MagicMock()
    settings = {'h.client_id': '1234'}
    with testing.testConfig(settings=settings) as config:
        registry = config.registry
        registry.registerUtility(mock_factory, interfaces.IClientFactory)
        request = testing.DummyRequest(registry=config.registry)
        lib.get_client(request, '4321')
        mock_factory.assert_called_with('4321')
コード例 #53
0
ファイル: test_users.py プロジェクト: glinscott/fishtest
 def test_create_users(self):
   with testing.testConfig() as config:
     config.add_route('login', '/login')
     config.add_route('signup', '/signup')
     print(signup(self.request))
     userc= {}
     userc['cpu_hours'] = 12345
     userc['username'] = '******'
     self.request.userdb.user_cache.insert(userc)
コード例 #54
0
ファイル: test_traversal.py プロジェクト: sakal/aiopyramid
 def test_async_traversed_length(self):
     with testing.testConfig() as config:
         config.add_traverser(AsyncioTraverser)
         resource = DummyResource('root', None)
         resource.add_child('cat', DummyResource)
         out = self.loop.run_until_complete(
             spawn_greenlet(traverse, resource, ['cat']),
         )
         self.assertEqual(len(out['traversed']), 1)
コード例 #55
0
ファイル: test_traversal.py プロジェクト: sakal/aiopyramid
 def test_async_root(self):
     with testing.testConfig() as config:
         config.add_traverser(AsyncioTraverser)
         resource = DummyResource('root', None)
         resource.add_child('cat', DummyResource)
         out = self.loop.run_until_complete(
             spawn_greenlet(traverse, resource, ['']),
         )
         self.assertTrue(out.get('root') == out.get('context'))
コード例 #56
0
ファイル: test_registering.py プロジェクト: podhmo/mokehehe
    def test_call_directive_manytimes(self):
        from pyramid.testing import testConfig

        with testConfig() as config:
            config.include("mokehehe.registering")

            builder = config.registering_builder("foo", resource_factory=object())
            builder2 = config.registering_builder("foo", resource_factory=object())
            self.assertEqual(builder2, builder)
コード例 #57
0
ファイル: test_workflow.py プロジェクト: podhmo/mokehehe
    def test_missing_both__exception(self):
        from pyramid.testing import testConfig
        from pyramid.exceptions import ConfigurationError

        with testConfig(autocommit=False) as config:
            config.include("mokehehe.workflow")
            config.get_workflow().register(IAfterModelCreate, "foo.create", "foo.list")
            with self.assertRaisesRegex(ConfigurationError, "route name"):
                config.commit()
コード例 #58
0
ファイル: test_it.py プロジェクト: podhmo/stringexchange
def test_reify_it():
    from pyramid.testing import testConfig

    with testConfig() as config:
        config.include("stringexchange")

        # request time
        request = _makeRequest(config, path="/")
        assert request.string_exchange == request.string_exchange