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'])