Exemple #1
0
 def test_only_one_execution(self):
     dispatcher = EventDispatcher()
     func = lambda x: x.name
     dispatcher.add('SampleEvent', func, only_once=True)
     result = dispatcher.trigger(Event('SampleEvent'))
     assert len(result) == 1
     result2 = dispatcher.trigger(Event('SampleEvent'))
     assert len(result2) == 0
Exemple #2
0
 def __create_instance(self, name, definition):
     params = {'definition': definition, 'dependency': name}
     pre_process_event = Event(name=PRE_EVENT,
                               target=definition,
                               params=params)
     result = self.dispatcher.trigger(pre_process_event)
     dependency = result.last()
     post_process_event = Event(name=POST_EVENT,
                                target=dependency,
                                params=params)
     self.dispatcher.trigger(post_process_event)
     return dependency
Exemple #3
0
 def run(self, environ, start_response):
     request = create_request_from_environ(
         environ, self.config['session']['class'],
         self.config['session'].get('options'))
     try:
         route_result = self.dispatcher.trigger(
             Event(events.ROUTE_MATCH,
                   target=self,
                   params={
                       'request': request,
                       'router': self.container.get('router')
                   }))
         route_match = route_result.first()
     except ApplicationError as exc:
         route_match = None
         response, view_model = self.__raise_exception_event(
             exception=exc, request=request)
     if route_match:
         try:
             dispatch_event = Event(events.DISPATCH_EXECUTE,
                                    target=self,
                                    params={
                                        'route_match': route_match,
                                        'request': request,
                                        'container': self.container
                                    })
             dispatch_result = self.dispatcher.trigger(dispatch_event)
             response = dispatch_event.params['controller_class'].response
             view_model = dispatch_result.first()
         except ApplicationError as exc:
             response, view_model = self.__raise_exception_event(
                 exception=exc, request=request, route_match=route_match)
     if not isinstance(view_model, Response):
         try:
             self.__render(request=request,
                           response=response,
                           view_model=view_model)
         except ApplicationError as exc:
             response, view_model = self.__raise_exception_event(
                 exception=exc, request=request, route_match=route_match)
             self.__render(request=request,
                           response=response,
                           view_model=view_model)
     start_response(*response.start())
     self.dispatcher.trigger(
         Event(events.COMPLETE,
               target=self,
               params={'container': self.container}))
     return [response()]
Exemple #4
0
 def run(self, environ, start_response):
     request = Request.from_environ(
         environ,
         session_class=self.config['session'].get('class', None),
         session_options=self.config['session'].get('options', None))
     context = {'request': request}
     self.context = context
     # Retrieve the required route match for the request.
     try:
         route_result = self.dispatcher.trigger(
             Event(events.ROUTE_MATCH,
                   target=self,
                   params={
                       'context': context,
                       'router': self.container.get('router')
                   }))
         route_match = route_result.first()
     except ApplicationError as exc:
         route_match = None
         response, view_model = self.exception(exception=exc,
                                               context=context)
     # Execute the relevant controller for the route
     if route_match:
         try:
             dispatch_result = self.dispatcher.trigger(
                 Event(events.DISPATCH_EXECUTE,
                       target=self,
                       params={
                           'container': self.container,
                           'context': context
                       }))
             response, view_model = dispatch_result.first()
         except ApplicationError as exc:
             response, view_model = self.exception(exception=exc,
                                                   context=context)
     # Render the view model or response
     if not hasattr(view_model, 'status_code'):
         try:
             self.render(context=context, view_model=view_model)
         except Exception as exc:
             response, view_model = self.exception(exception=exc,
                                                   context=context)
     # Do any cleanup required after the request has ended
     self.dispatcher.trigger(
         Event(events.COMPLETE,
               target=self,
               params={'container': self.container}))
     return response(start_response)
Exemple #5
0
    def __init__(self, config=None):
        """Initializes the application.

        Registers any events that are within the application configuration.

        Usage:
            app = Base()

        Events:
            Dispatches the INIT.

        Args:
            mixed config: See the Base.config properties.
        """
        self.config = config or {}
        self.dispatcher = self.container.get('shared_event_dispatcher')
        for event, listeners in self.config['events'].items():
            for callback_priority_pair in listeners:
                try:
                    priority = callback_priority_pair.priority
                except:
                    priority = 1
                try:
                    once_only = callback_priority_pair.once_only
                except:
                    once_only = False
                self.dispatcher.add(
                    event, self.container.get(callback_priority_pair[0]),
                    priority, once_only)
        self.dispatcher.trigger(Event(events.INIT, target=self))
        super(Base, self).__init__()
 def test_execute(self):
     with raises(InternalServerError):
         route = LiteralRoute('test', path='/')
         match = RouteMatch(route, {})
         event = Event('something', params={'context': {'route_match': match}})
         listener = listeners.DispatchExecute({'404': 'page/404'})
         listener(event)
Exemple #7
0
 def render(self, with_dispatcher=True, **kwargs):
     kwargs['container'] = self.container
     render_event = Event(events.RENDER_VIEW, target=self, params=kwargs)
     if with_dispatcher:
         self.dispatcher.trigger(render_event)
     else:
         listener = self.container.get('app_render_listener')
         listener(render_event)
Exemple #8
0
def sample_event(target):
    definition = {
        'item': target,
    }
    return Event('Sample',
                 params={
                     'definition': definition
                 },
                 target=definition)
 def __run_inner(self, request):
     context = {
         'request': request
     }
     self.context = context
     # Retrieve the required route match for the request.
     try:
         route_result = self.dispatcher.trigger(
             Event(
                 events.ROUTE_MATCH,
                 target=self,
                 params={'context': context,
                         'router': self.container.get('router')}))
         route_match = route_result.first()
     except self.exception_class as exc:
         route_match = None
         response, view_model = self.exception(exception=exc,
                                               context=context)
     # Execute the relevant controller for the route
     if route_match:
         try:
             dispatch_result = self.dispatcher.trigger(
                 Event(
                     events.DISPATCH_EXECUTE,
                     target=self,
                     params={'container': self.container,
                             'context': context}))
             response, view_model = dispatch_result.first()
         except self.exception_class as exc:
             response, view_model = self.exception(
                 exception=exc, context=context)
     # Render the view model or response
     if not hasattr(view_model, 'status_code'):
         try:
             self.render(context=context, view_model=view_model)
         except Exception as exc:
             response, view_model = self.exception(exception=exc,
                                                   context=context)
     # Do any cleanup required after the request has ended
     self.dispatcher.trigger(Event(events.COMPLETE,
                                   target=self,
                                   params={'container': self.container}))
     return response
 def create_event(self, **kwargs):
     router = DictRouter({'home': {'path': '/'}})
     environ = {}
     util.setup_testing_defaults(environ)
     environ.update(**kwargs)
     context = {'request': Request.from_environ(environ)}
     event = Event(
         'TestEvent',
         params={'router': router,
                 'context': context})
     return event
Exemple #11
0
 def create_event(self, **kwargs):
     router = Router({'home': {'path': '/'}})
     environ = {}
     util.setup_testing_defaults(environ)
     environ.update(**kwargs)
     event = Event('TestEvent',
                   params={
                       'router': router,
                       'request': create_request_from_environ(environ)
                   })
     return event
Exemple #12
0
    def test_stopped_propagation(self):
        dispatcher = EventDispatcher()

        def func(event):
            event.stop_propagation()
            return event.name
        func2 = lambda x: x.name
        dispatcher.add('SampleEvent', func)
        dispatcher.add('SampleEvent', func2)
        result = dispatcher.trigger(Event('SampleEvent'))
        assert len(result) == 1
 def test_short_circuit(self):
     environ = sample_environ()
     route = LiteralRoute(
         'test',
         path='/',
         options={'controller': 'tests.watson.framework.support.ShortCircuitedController'})
     match = RouteMatch(route, {})
     context = {'request': Request.from_environ(environ), 'route_match': match}
     event = Event(
         'something',
         params={'container': IocContainer(), 'context': context})
     listener = listeners.DispatchExecute({'404': 'page/404'})
     response, view_model = listener(event)
     assert isinstance(response, Response)
 def test_overriden_template(self):
     environ = sample_environ()
     route = LiteralRoute(
         'test',
         path='/',
         options={'controller': 'tests.watson.framework.support.SampleActionController'})
     match = RouteMatch(route, {'action': 'view_model_template'})
     context = {'request': Request.from_environ(environ), 'route_match': match}
     event = Event(
         'something',
         params={'container': IocContainer(), 'context': context})
     listener = listeners.DispatchExecute({'404': 'page/500'})
     response, view_model = listener(event)
     assert isinstance(view_model, views.Model)
     assert view_model.template == 'sampleactioncontroller/404'
Exemple #15
0
 def exception(self, last_exception=None, **kwargs):
     event = Event(events.EXCEPTION, target=self, params=kwargs)
     result = self.dispatcher.trigger(event)
     view_model = result.first()
     response = Response(kwargs['exception'].status_code)
     context = kwargs['context']
     context['response'] = response
     if last_exception:
         self.render(with_dispatcher=False,
                     view_model=view_model,
                     context=context)
     try:
         self.render(view_model=view_model, context=context)
     except Exception as exc:
         kwargs['exception'] = exc
         self.exception(last_exception=exc, **kwargs)
     return response, view_model
 def test_execute(self):
     app = applications.Http()
     listener = listeners.Render(config.views)
     context = {
         'response': Response(200),
     }
     vm = views.Model(format='text/plain', data={'content': 'test'})
     params = {'context': context, 'view_model': vm, 'container': app.container}
     event = Event('render', params=params)
     # error raised as no template exists
     with raises(InternalServerError):
         listener(event)
     with raises(InternalServerError):
         vm.format = 'exe'
         listener(event)
     vm.format = 'json'
     response = listener(event)
     assert response.status_code == 200
     assert response.headers['Content-Type'] == 'application/json'
Exemple #17
0
 def test_short_circuit(self):
     environ = sample_environ()
     route = Route('test',
                   path='/',
                   options={
                       'controller':
                       'tests.watson.mvc.support.ShortCircuitedController'
                   })
     match = RouteMatch(route, {
         'controller':
         'tests.watson.mvc.support.ShortCircuitedController'
     })
     event = Event('something',
                   params={
                       'route_match': match,
                       'container': IocContainer(),
                       'request': create_request_from_environ(environ)
                   })
     listener = listeners.DispatchExecute({'404': 'page/404'})
     response = listener(event)
     assert isinstance(response, Response)
 def exception(self, last_exception=None, **kwargs):
     event = Event(events.EXCEPTION, target=self, params=kwargs)
     result = self.dispatcher.trigger(event)
     view_model = result.first()
     response = Response(kwargs['exception'].status_code)
     context = kwargs['context']
     accept = context['request'].headers.get('accept')
     if accept:
         accept_parts = accept.split('/')
         if len(accept_parts) > 1:
             view_model.format = accept_parts[1]
     context['response'] = response
     if last_exception:
         self.render(with_dispatcher=False,
                     view_model=view_model, context=context)
     try:
         self.render(view_model=view_model, context=context)
     except Exception as exc:
         # Triggered when an exception occurs rendering the exception
         kwargs['exception'] = exc
         self.exception(last_exception=exc, **kwargs)
     return response, view_model
Exemple #19
0
 def test_stop_propagation(self):
     event = Event('SampleEvent')
     assert event.stopped == False
     event.stop_propagation()
     assert event.stopped == True
Exemple #20
0
 def __render(self, **kwargs):
     kwargs['container'] = self.container
     render_event = Event(events.RENDER_VIEW, target=self, params=kwargs)
     self.container.add('render_event_params', kwargs)
     self.dispatcher.trigger(render_event)
Exemple #21
0
 def __raise_exception_event(self, **kwargs):
     exception_event = Event(events.EXCEPTION, target=self, params=kwargs)
     exception_result = self.dispatcher.trigger(exception_event)
     return Response(
         kwargs['exception'].status_code), exception_result.first()
Exemple #22
0
 def test_trigger(self):
     dispatcher = EventDispatcher()
     func = lambda x: x.name
     dispatcher.add('SampleEvent', func)
     result = dispatcher.trigger(Event('SampleEvent'))
     assert result.first() == 'SampleEvent'
Exemple #23
0
 def test_add_remove_params(self):
     event = Event('SampleEvent')
     event.params['test'] = 'test'
     assert event.params['test'] == 'test'
     del event.params['test']
     assert 'test' not in event.params
Exemple #24
0
 def test_set_valid_params(self):
     event = Event('SampleEvent', params={'test': 'test'})
     assert event.params['test'] == 'test'
Exemple #25
0
 def test_set_invalid_params(self):
     Event('SampleEvent', params='test')
Exemple #26
0
 def test_event_target(self):
     event = Event('SamplEvent', target=self)
     assert event.target == self
Exemple #27
0
 def test_stop_propagation(self):
     event = Event('SampleEvent')
     assert event.stopped is False
     event.stop_propagation()
     assert event.stopped
Exemple #28
0
 def test_execute(self):
     route = Route('test', path='/')
     match = RouteMatch(route, {})
     event = Event('something', params={'route_match': match})
     listener = listeners.DispatchExecute({'404': 'page/404'})
     listener(event)
Exemple #29
0
 def test_create_event(self):
     assert repr(Event(name='SampleEvent')
                 ) == '<watson.events.types.Event name:SampleEvent>'
Exemple #30
0
 def test_add_remove_params(self):
     event = Event('SampleEvent')
     event.params['test'] = 'test'
     assert event.params['test'] == 'test'
     del event.params['test']
     assert 'test' not in event.params
Exemple #31
0
 def trigger_init_event(self):
     """Execute any event listeners for the INIT event.
     """
     self.dispatcher.trigger(Event(events.INIT, target=self))