def create_multi_context():
def f():
pass
def f_():
pass
def f__():
pass
def f___():
pass
context = contexts.Context()
context2 = context.create_child_context()
context3 = context2.create_child_context()
context4 = contexts.Context()
context5 = context4.create_child_context()
mc = contexts.MultiContext([context3, context5])
context.register_function(f)
context2.register_function(f___)
context4.register_function(f_)
context5.register_function(f__)
context3['key'] = 'context3'
context5['key'] = 'context5'
context4['key2'] = 'context4'
context['key3'] = 'context1'
mc['key4'] = 'mc'
return mc
def create_linked_context():
def f():
pass
def g():
pass
def g_():
pass
def g__():
pass
context1 = contexts.Context()
context2 = contexts.Context()
context1.register_function(f)
context1.register_function(g)
context2.register_function(g_)
context1['key'] = 'context1'
context1['key1'] = 'context1'
context2['key'] = 'context2'
context2['key2'] = 'context2'
context3 = context2.create_child_context()
context3.register_function(g__)
context3['key'] = 'context3'
context2['key3'] = 'context3'
return contexts.LinkedContext(parent_context=context1,
linked_context=context3)
def test_get_functions(self):
def f():
pass
def f_():
pass
def f__():
pass
def g():
pass
context = contexts.Context()
context2 = context.create_child_context()
context.register_function(f)
context.register_function(f_)
context.register_function(g, exclusive=True)
context2.register_function(f__)
functions, is_exclusive = context.get_functions('f')
self.assertFalse(is_exclusive)
self.assertIsInstance(functions, set)
self.assertThat(functions, testtools.matchers.HasLength(2))
self.assertThat(
functions,
matchers.AllMatch(matchers.IsInstance(specs.FunctionDefinition)))
functions, is_exclusive = context2.get_functions('g')
self.assertFalse(is_exclusive)
functions, is_exclusive = context2.get_functions('f')
self.assertFalse(is_exclusive)
self.assertThat(functions, testtools.matchers.HasLength(1))
def _setup_context(data, context, finalizer, convention):
if context is None:
context = contexts.Context(
convention=convention or conventions.CamelCaseConvention())
if finalizer is None:
@specs.parameter('iterator', yaqltypes.Iterable())
@specs.name('#iter')
def limit(iterator):
return iterator
@specs.inject('limiter', yaqltypes.Delegate('#iter'))
@specs.inject('engine', yaqltypes.Engine())
@specs.name('#finalize')
def finalize(obj, limiter, engine):
if engine.options.get('yaql.convertOutputData', True):
return utils.convert_output_data(obj, limiter, engine)
return obj
context.register_function(limit)
context.register_function(finalize)
else:
context.register_function(finalizer)
if data is not utils.NO_VALUE:
context['$'] = utils.convert_input_data(data)
return context
def test_keys(self):
context = contexts.Context()
context2 = context.create_child_context()
context['key'] = 123
context2['key2'] = 321
keys = list(context2.keys())
self.assertThat(keys, testtools.matchers.HasLength(1))
self.assertEqual(keys[0], '$key2')
def test_child_contexts(self):
context = contexts.Context()
context2 = context.create_child_context()
context['key'] = 123
self.assertEqual(123, context2['key'])
context2['key'] = 345
self.assertEqual(345, context2['key'])
del context2['key']
self.assertEqual(123, context2['key'])
def test_data(self):
context = contexts.Context()
context2 = context.create_child_context()
context['key'] = 123
context2['key2'] = 321
self.assertIn('key', context)
self.assertIn('key2', context2)
self.assertIn('$key', context)
self.assertNotIn('key2', context)
self.assertNotIn('key', context2)
def test_delete_function(self):
def f():
pass
def f_():
pass
context = contexts.Context()
context.register_function(f)
context2 = context.create_child_context()
context2.register_function(f_)
functions, is_exclusive = context2.get_functions('f')
spec = functions.pop()
self.assertIn(spec, context2)
context2.delete_function(spec)
self.assertNotIn(spec, context2)
functions, is_exclusive = context.get_functions('f')
self.assertThat(functions, matchers.HasLength(1))
def test_collect_functions(self):
def f():
pass
def f_():
pass
def f__():
pass
context = contexts.Context()
context2 = context.create_child_context()
context3 = context2.create_child_context()
context.register_function(f)
context.register_function(f_)
context3.register_function(f__)
functions = context3.collect_functions('f')
self.assertThat(functions, testtools.matchers.HasLength(2))
self.assertThat(functions[0], testtools.matchers.HasLength(1))
self.assertThat(functions[1], testtools.matchers.HasLength(2))
def test_function_in(self):
def f():
pass
def f_():
pass
def f__():
pass
context = contexts.Context()
context2 = context.create_child_context()
context3 = context2.create_child_context()
context.register_function(f)
context.register_function(f_)
context3.register_function(f__)
functions = context3.collect_functions('f')
self.assertNotIn(specs.get_function_definition(f__), context3)
self.assertIn(functions[0].pop(), context3)
self.assertNotIn(functions[1].pop(), context3)
def create_empty_context():
context = contexts.Context(convention=CONVENTION)
context.register_function(_finalize)
return context
def test_key_deletion(self):
context = contexts.Context()
context['key'] = 123
del context['key']
self.assertIsNone(context['key'])
def test_missing_key_access(self):
context = contexts.Context()
self.assertIsNone(context['key'])
def test_empty_name(self):
context = contexts.Context()
context[''] = 123
self.assertEqual(123, context['$'])
self.assertEqual(123, context[''])
self.assertEqual(123, context['$1'])
def test_name_normalization(self):
context = contexts.Context()
context['key'] = 123
self.assertEqual(123, context['$key'])
def test_store_data(self):
context = contexts.Context()
context['key'] = 123
self.assertEqual(123, context['key'])
