def _create_child_routes(self, definition, parent_route):
children = definition.get('children', ())
for child in children:
if isinstance(child, str):
name, child = child, children[child]
else:
name = child['name']
child['requires'] = dict_deep_update(child.get('requires', {}), parent_route.requires)
child['defaults'] = dict_deep_update(child.get('defaults', {}), parent_route.requires)
name = '{0}/{1}'.format(parent_route.name, name)
if 'path' not in child:
child['path'] = '/{}'.format(name)
child['path'] = '{0}{1}'.format(parent_route.path, child['path'])
child['name'] = name
self.add_definition(child)
def test_complex_deep(self):
d1 = {
'a': {
'b': {
'key': [
'a',
'b',
'c',
'd',
]
}
}
}
d2 = {
'a': {
'b': {
'key': [
'e',
'f',
'g',
]
}
}
}
merged = dict_deep_update(d1, d2)
assert 'c' in merged['a']['b']['key']
def register_components(self):
"""Register any components specified with the application.
Components can include the following modules:
- dependencies
- events
- models
- routes
- views
Registering a component will merge any configuration settings within
the above modules prior to the application booting.
An example component might look like:
/component
/views
/index.html
/routes.py
/views.py
"""
types = ('dependencies', 'events', 'routes', 'models', 'views')
for component in self.config['components']:
for type_ in types:
with contextmanagers.suppress(Exception):
type_component = imports.load_definition_from_string(
'{}.{}.{}'.format(component, type_, type_))
if type_ == 'dependencies':
self.container.update(type_component)
if not isinstance(type_component, ModuleType):
self._config[type_] = dict_deep_update(
self._config.get(type_, {}), type_component)
self._config['views'][
'renderers']['jinja2']['config']['packages'].append(
(component, 'views'))
def __init__(self, config=None, argv=None):
super(Console, self).__init__(config)
self.config = dict_deep_update({
'commands': find_commands_in_module(DefaultConsoleCommands)
}, self.config)
self.runner = Runner(argv, commands=self.config.get('commands'))
self.runner.get_command = self.get_command
def test_complex_deep(self):
d1 = {
'a': {
'b': {
'key': [
'a',
'b',
'c',
'd',
]
}
}
}
d2 = {
'a': {
'b': {
'key': [
'e',
'f',
'g',
]
}
}
}
merged = dict_deep_update(d1, d2)
assert 'c' in merged['a']['b']['key']
def __init__(self, config=None, argv=None):
super(Console, self).__init__(config)
self.config = dict_deep_update(
{'commands': find_commands_in_module(DefaultConsoleCommands)},
self.config)
self.runner = Runner(argv, commands=self.config.get('commands'))
self.runner.get_command = self.get_command
def update_config(self, app):
app.config['auth'] = datastructures.dict_deep_update(
config.defaults, app.config.get('auth', {}))
app.container.get('app_exception_listener').templates.update(
config.templates)
self.container.get('jinja2_renderer').add_package_loader(
'watson.auth', 'views')
def _setup_provider(self, app, provider, config_):
auth_config = app.config['auth']
provider_ = imports.load_definition_from_string(provider)
provider_config = datastructures.dict_deep_update(
auth_config['common'], provider_.defaults)
provider_config = datastructures.dict_deep_update(
provider_config, config_)
config_.update(provider_config)
dependency_config = {
'init': {
'config': lambda container: container.get('application.config')['auth']['providers'][provider],
'session': lambda container: container.get('sqlalchemy_session_{0}'.format(container.get('application.config')['auth']['providers'][provider]['session'])),
}
}
dependency_config.update(app.config['dependencies'][
'definitions'].get(provider, {}))
app.container.add_definition(provider, dependency_config)
def __init__(self, config=None):
"""Initializes the container and set some default configuration options.
Args:
dict config: A dict containing the params, definitions and processors.
"""
self.config = dict_deep_update(DEFAULTS, config or {})
self.__instantiated = {}
for event, listeners in self.config['processors'].items():
for processor in listeners:
self.attach_processor(event, load_definition_from_string(processor)())
def __init__(self, config=None):
"""Initializes the container and set some default configuration options.
Args:
dict config: A dict containing the params, definitions and processors.
"""
self.config = dict_deep_update(DEFAULTS, config or {})
self.__instantiated = {}
for event, listeners in self.config['processors'].items():
for processor in listeners:
self.attach_processor(event,
load_definition_from_string(processor)())
def __init__(self, config=None):
"""Initializes the container and set some default configuration options.
Args:
config (dict): The params, definitions and processors.
"""
self.__instantiated__ = {}
self.config = dict_deep_update(DEFAULTS, config or {})
self.__instantiated__ = {}
self._pre_process_event = types.Event(name=PRE_EVENT)
self._post_process_event = types.Event(name=POST_EVENT)
for event, listeners in self.config['processors'].items():
for processor in listeners:
self.attach_processor(
event,
imports.load_definition_from_string(processor)())
def config(self, config):
"""Sets the configuration for the application.
Usage:
app = Base()
app.config = {'some': 'settings'}
Args:
mixed config: The configuration to use.
"""
if isinstance(config, ModuleType):
conf = module_to_dict(config, '__')
else:
conf = config or {}
self._config = dict_deep_update(module_to_dict(DefaultConfig, '__'), conf)
self.container.add('application.config', self.config)
def config(self, config):
"""Sets the configuration for the application.
Usage:
app = Base()
app.config = {'some': 'settings'}
Args:
mixed config: The configuration to use.
"""
if isinstance(config, ModuleType):
conf = module_to_dict(config, '__')
else:
conf = config or {}
self._config = dict_deep_update(module_to_dict(DefaultConfig, '__'),
conf)
self.container.add('application.config', self.config)
def test_deepcopy_invalid_copy(self):
pattern = re.compile('test')
d = {'re': pattern}
new_dict = dict_deep_update(d, {'test': 'testing'})
assert 'test' in new_dict
assert new_dict['re'] is pattern
def test_dict_deep_update(self):
d1 = {'a': {'b': 3}}
d2 = {'a': {'b': 4}}
merged = dict_deep_update(d1, d2)
assert merged['a']['b'] == 4
def test_dict_deep_update_not_dict(self):
d1 = {'a': {'b': 3}}
d2 = 'b'
merged = dict_deep_update(d1, d2)
assert merged == 'b'
def test_dict_deep_update_not_dict(self):
d1 = {'a': {'b': 3}}
d2 = 'b'
merged = dict_deep_update(d1, d2)
assert merged == 'b'
def test_deepcopy_invalid_copy(self):
pattern = re.compile('test')
d = {'re': pattern}
new_dict = dict_deep_update(d, {'test': 'testing'})
assert 'test' in new_dict
assert new_dict['re'] is pattern
def setup_config(self):
auth_config = datastructures.dict_deep_update(
config.defaults, self.app_config.get('auth', {}))
self.app_config['auth'] = auth_config
def test_dict_deep_update(self):
d1 = {'a': {'b': 3}}
d2 = {'a': {'b': 4}}
merged = dict_deep_update(d1, d2)
assert merged['a']['b'] == 4
def setup_authenticator(self):
dependency_config = datastructures.dict_deep_update(
config.definitions['auth_authenticator'], self.app_config['dependencies']['definitions'].get('auth_authenticator', {}))
self.app_config['dependencies']['definitions']['auth_authenticator'] = dependency_config
self.container.definitions['auth_authenticator'] = dependency_config
'class': 'tests.watson.auth.support.MockMailBackend'
}
},
}
# Initialize a sample application
app = applications.Http(app_config)
request = Request.from_environ(
sample_environ(), session_class='watson.http.sessions.Memory')
default_provider_settings = dict_deep_update(
config.defaults['common'],
{
'model': {
'class': 'tests.watson.auth.support.TestUser'
},
'secret': 'APP_SECRET',
'algorithm': 'HS256',
'system_email_from_address': '*****@*****.**',
'reset_password_route': 'auth/reset-password',
'forgotten_password_route': 'auth/forgotten-password'
})
class MockMailBackend(object):
def send(self, message, **kwargs):
pass
class TestSampleForm(object):
field_one = None
field_two = None
