diff -r 87cfa131b535 -r e7e0ae78773e configurationengine/source/cone/public/tests/unittest_plugin_api.py --- a/configurationengine/source/cone/public/tests/unittest_plugin_api.py Fri Mar 12 08:30:17 2010 +0200 +++ b/configurationengine/source/cone/public/tests/unittest_plugin_api.py Tue Aug 10 14:29:28 2010 +0300 @@ -16,8 +16,7 @@ import unittest import os -import logging -import __init__ + from cone.public import * from cone.public import _plugin_reader ROOT_PATH = os.path.dirname(os.path.abspath(__file__)) @@ -128,7 +127,7 @@ """.encode('utf-8') SINGLE_IMPL_2 = """ - + """.encode('utf-8') SINGLE_IMPL_3 = """ @@ -137,25 +136,6 @@ """.encode('utf-8') -IGNORED_NAMESPACE_IMPL_1 = """ - - - - - - - - - -""".encode('utf-8') - -IGNORED_NAMESPACE_IMPL_2 = """ - - - - -""".encode('utf-8') - NO_IMPL = """ @@ -195,12 +175,37 @@ def get_default_view(self): return MockView(self.features) + + def layered_implml(self): + result = container.DataContainer() + for res in self.resources.iterkeys(): + result.add_value(res, res) + return result + +class SimpleImpl(plugin.ImplBase): + def __init__(self, ref, configuration): + super(SimpleImpl, self).__init__(ref, configuration) + self.generate_invoked = False + self.outputfile = '' + + def generate(self, context=None): + if context: + if self.outputfile: + f = context.create_file(self.outputfile, implementation=self) + f.close() + + self.generate_invoked = True class MockImpl(plugin.ImplBase): + IMPL_TYPE_ID = 'mock' + def __init__(self, data): self.data = data self.generate_invoked = False - + self.outputfile = '' + self.refs = None + self.ref = '' + @classmethod def create(cls, resource_ref, configuration, data): impl = cls(data) @@ -230,6 +235,14 @@ else: return False + def get_refs(self): + """ + Return a list of all ConfML setting references that affect this + implementation. May also return None if references are not relevant + for the implementation. + """ + return self.refs + class MockReaderBase(plugin.ReaderBase): @classmethod def read_impl(cls, resource_ref, configuration, root_elem): @@ -240,12 +253,18 @@ class MockReader1(MockReaderBase): NAMESPACE = "http://www.test.com/xml/1" + NAMESPACE_ID = "mock1" + ROOT_ELEMENT_NAME = "impl" FILE_EXTENSIONS = ['mock1ml'] class MockReader2(MockReaderBase): NAMESPACE = "http://www.test.com/xml/2" + NAMESPACE_ID = "mock2" + ROOT_ELEMENT_NAME = "impl" FILE_EXTENSIONS = ['mock2ml'] class MockReader3(MockReaderBase): NAMESPACE = "http://www.test.com/xml/3" + NAMESPACE_ID = "mock3" + ROOT_ELEMENT_NAME = "impl" IGNORED_NAMESPACES = ["http://www.test.com/xml/ignored/3"] FILE_EXTENSIONS = ['mock3ml', 'test3ml'] @@ -266,12 +285,209 @@ 'layer1/implml/single2.mock2ml' : SINGLE_IMPL_2, 'layer1/implml/single3.mock3ml' : SINGLE_IMPL_3, 'layer1/implml/single3.test3ml' : SINGLE_IMPL_3, - 'layer1/implml/ignored_ns_1.mock3ml' : IGNORED_NAMESPACE_IMPL_1, - 'layer1/implml/ignored_ns_2.mock3ml' : IGNORED_NAMESPACE_IMPL_2, 'layer1/implml/multi1.dummyml' : MULTI_IMPL_1, 'layer1/implml/dummy' : MULTI_IMPL_1, }) + +class TestPluginGenerationContext(unittest.TestCase): + def test_generation_context_handle_terminal(self): + config = api.Configuration() + context = plugin.GenerationContext(configuration=config) + self.assertRaises(exceptions.NotFound, context.handle_terminal, 'feature') + config.create_feature('feature') + # rebuild default view + config._remove('?default_view') + self.assertEquals(context.handle_terminal('feature'), None) + + + def test_generation_create_file(self): + config = api.Configuration() + context = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + mi = MockImpl({}) + outfile = context.create_file('foobar/test.txt', implementation=mi) + outfile.write("Test output file creation") + outfile.close() + expected = utils.resourceref.norm(os.path.join(context.output, 'foobar/test.txt')) + self.assertEquals(len(context.generation_output), 1) + self.assertEquals(context.generation_output[0].name, expected) + self.assertEquals(context.generation_output[0].implementation, mi) + self.assertEquals(context.generation_output[0].phase, "normal") + self.assertTrue(os.path.exists(expected)) + os.unlink(expected) + + absfile = utils.resourceref.norm(os.path.join(ROOT_PATH, 'temp/foobar/abspath.txt')) + outfile = context.create_file(absfile, implementation=mi) + outfile.write("Test output file creation") + outfile.close() + self.assertEquals(len(context.generation_output), 2) + self.assertEquals(context.generation_output[1].name, absfile) + self.assertEquals(context.generation_output[1].implementation, mi) + self.assertEquals(context.generation_output[1].phase, "normal") + self.assertTrue(os.path.exists(absfile)) + os.unlink(absfile) + + def test_generation_add_output(self): + config = api.Configuration() + context = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + mi = MockImpl({}) + context.add_file('add.txt', implementation=mi) + + self.assertEquals(len(context.generation_output), 1) + self.assertEquals(context.generation_output[0].name, utils.resourceref.norm(os.path.join(context.output, 'add.txt'))) + self.assertEquals(context.generation_output[0].implementation, mi) + self.assertEquals(context.generation_output[0].phase, "normal") + + external_output = utils.resourceref.norm(os.path.join(ROOT_PATH, 'temp', 'external/foobar.txt')) + context.add_file(external_output, implementation=mi) + self.assertEquals(len(context.generation_output), 2) + self.assertEquals(context.generation_output[1].name, external_output) + self.assertEquals(context.generation_output[1].implementation, mi) + self.assertEquals(context.generation_output[1].phase, "normal") + + def test_generation_get_output(self): + config = api.Configuration() + context = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + mi = MockImpl({}) + context.add_file('add1.txt', implementation=mi) + context.add_file('foo/add2.txt', implementation=None) + + self.assertEquals(len(context.get_output()), 2) + self.assertEquals(context.get_output()[1].filename, 'add2.txt') + self.assertEquals(context.get_output()[1].abspath, os.path.normpath(os.path.join(context.output,'foo/add2.txt'))) + self.assertEquals(context.get_output()[1].relpath, os.path.normpath('foo/add2.txt')) + self.assertEquals(len(context.get_output(implml_type='mock')), 1) + self.assertEquals(context.get_output(implml_type='mock')[0].filename, 'add1.txt') + + def test_generation_get_refs_no_output(self): + config = api.Configuration() + context = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + self.assertEquals(context.get_refs_with_no_output(),[]) + self.assertEquals(context.get_refs_with_no_output(['']),['']) + + context.changed_refs = ['foo.bar', + 'foo.two', + 'foo.three'] + + self.assertEquals(context.get_refs_with_no_output(),['foo.bar', + 'foo.three', + 'foo.two']) + mi = MockImpl({}) + mi.refs = ['foo.bar','nonno.noo','foo.three'] + context.add_file('add1.txt', implementation=mi) + context.add_file('foo/add2.txt', implementation=None) + + self.assertEquals(context.get_refs_with_no_output(),['foo.two']) + context.changed_refs = ['foo.bar', + 'foo.three'] + self.assertEquals(context.get_refs_with_no_output(),[]) + mi.refs = [] + self.assertEquals(context.get_refs_with_no_output(),['foo.bar', + 'foo.three']) + mi.refs = None + self.assertEquals(context.get_refs_with_no_output(),['foo.bar', + 'foo.three']) + + def test_merged_context_get_changed_refs_intersect(self): + config = api.Configuration() + context1 = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + context2 = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + + context1.changed_refs = ['foo.bar', + 'foo.two', + 'foo.three'] + context2.changed_refs = ['foo.bar', + 'foo.two1'] + outs = plugin.MergedContext([context1,context2]) + self.assertEquals(sorted(outs.get_changed_refs(operation='union')), + sorted(['foo.two1', + 'foo.bar', + 'foo.two', + 'foo.three'])) + self.assertEquals(outs.get_changed_refs(operation='intersection'), ['foo.bar']) + self.assertEquals(sorted(outs.get_changed_refs(operation='difference')), sorted(['foo.three', + 'foo.two'])) + self.assertEquals(sorted(outs.get_changed_refs(operation='symmetric_difference')), sorted(['foo.two1', + 'foo.three', + 'foo.two'])) + + def test_generation_get_refs_no_output_with_two_contexts(self): + config = api.Configuration() + context1 = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + context2 = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + + context1.changed_refs = ['foo.bar', + 'foo.two', + 'foo.three'] + context2.changed_refs = ['foo.bar1', + 'foo.two1'] + + + mi1 = MockImpl({}) + mi1.refs = ['foo.bar','nonno.noo','foo.three'] + mi2 = MockImpl({}) + mi2.refs = ['foo.bar1'] + context1.add_file('add1.txt', implementation=mi1) + context1.add_file('foo/add2.txt', implementation=None) + context2.add_file('add2.txt', implementation=mi2) + outs = plugin.MergedContext([context1,context2]) + self.assertEquals(outs.get_refs_with_no_output(), ['foo.two', 'foo.two1']) + self.assertEquals(outs.get_refs_with_no_output(['foo.two']), ['foo.two']) + self.assertEquals(outs.get_refs_with_no_output(['foo.bar']), []) + + def test_generation_get_refs_with_no_implementation(self): + config = api.Configuration() + context1 = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + context2 = plugin.GenerationContext(configuration=config, + output=os.path.join(ROOT_PATH, 'temp'), + phase="normal") + + context1.changed_refs = ['foo.bar', + 'foo.two', + 'foo.three'] + context2.changed_refs = ['foo.bar1', + 'foo.two1'] + + + mi1 = MockImpl({}) + mi1.ref = 'mi1' + mi1.refs = ['foo.bar','nonno.noo','foo.three'] + mi2 = MockImpl({}) + mi2.ref = 'mi2' + mi2.refs = ['foo.bar1'] + context1.impl_set.add(mi1) + context2.impl_set.add(mi2) + outs = plugin.MergedContext([context1,context2]) + self.assertEquals(outs.get_refs_with_no_implementation(), ['foo.two', 'foo.two1']) + self.assertEquals(outs.get_refs_with_no_implementation(['foo.bar']), []) + self.assertEquals(outs.get_refs_with_no_implementation(['foo.two', 'foo.bar1']), ['foo.two']) + + + def test_context_data_grep_log(self): + context = plugin.GenerationContext() + context.log = ['foo bar', + 'foo faa', + 'jee jee jehu'] + self.assertEquals(context.grep_log('jee'), [(2,'jee jee jehu')]) + class TestPluginImplBase(unittest.TestCase): def setUp(self): pass @@ -293,7 +509,24 @@ self.assertEquals(impl.has_tag({'foo': ['foo']}, policy='AND'), False) self.assertEquals(impl.has_tag({'target': ['foo'], 'foo':['bar']}, policy='AND'), False) self.assertEquals(impl.has_tag({'target': ['foo'], 'foo':['bar']}, policy='OR'), True) - + + def test_implbase_output(self): + str = api.Storage(utils.relpath(ROOT_PATH)) + config = api.Configuration('foo') + config.storage = str + impl = plugin.ImplBase('foo.implml', config) + self.assertEquals(impl.output, '') + impl.plugin_output = 'test' + self.assertEquals(impl.output, 'test') + impl.set_output_root('foobar') + self.assertEquals(impl.output, 'foobar/test') + impl.set_output_root('/foobar') + self.assertEquals(impl.output, '/foobar/test') + + self.assertEquals(impl.path, 'foo.implml') + self.assertEquals(impl.abspath, os.path.abspath(os.path.join(ROOT_PATH,'foo.implml'))) + + def test_implbase_tags_with_refs(self): config = MockConfiguration({}, features = { 'Foo.Bar' : 'foobar', @@ -353,106 +586,134 @@ self.assertTrue(impl.has_ref(['Yay', 'Foo.Bar.Baz', 'Fhtagn'])) self.assertTrue(impl.has_ref(['Yay', 'Xyz', 'Fhtagn'])) - def test_impl_container_eval_context_with_tags(self): - container = plugin.ImplBase("norm", None) - context = plugin.GenerationContext() - self.assertTrue(container._eval_context(context)) - container.set_tags({'target':['rofs2','core']}) - context.tags = {'target': ['rofs2'], 'foobar': ['test']} - self.assertTrue(container._eval_context(context)) - context.tags_policy = "AND" - self.assertFalse(container._eval_context(context)) - container.set_tags({}) - self.assertFalse(container._eval_context(context)) - context.tags = {'target': ['rofs2']} - self.assertFalse(container._eval_context(context)) - context.tags = {} - self.assertTrue(container._eval_context(context)) -class TestPluginImplSet(unittest.TestCase): +class TestPlugin(plugin.ImplBase): + def __init__(self, ref): + super(TestPlugin, self).__init__(ref, None) + self.refs = None + def get_refs(self): + return self.refs + +class TestPluginImplSet(unittest.TestCase): def test_add_implementation_and_list(self): - container = plugin.ImplSet() + iset= plugin.ImplSet() imp1 = plugin.ImplBase("implml/test.content",None) imp2a = plugin.ImplBase("implml/copy.content",None) imp2b = plugin.ImplBase("implml/copy.content",None) - container.add_implementation(imp1) - container.add_implementation(imp2a) - container.add_implementation(imp2b) - self.assertEquals(sorted(container.list_implementation()), + iset.add_implementation(imp1) + iset.add_implementation(imp2a) + iset.add_implementation(imp2b) + self.assertEquals(sorted(iset.list_implementation()), sorted(['implml/test.content', 'implml/copy.content'])) + def test_add_implementation_and_generate(self): + iset = plugin.ImplSet() + imp1 = SimpleImpl("implml/test1.content", None) + imp1.outputfile = 'test/foo.txt' + imp2a = SimpleImpl("implml/test2.content", None) + imp2b = SimpleImpl("implml/test3.content", None) + iset.add_implementation(imp1) + iset.add_implementation(imp2a) + iset.add_implementation(imp2b) + context = plugin.GenerationContext(output="temp") + iset.generate(context) + self.assertEquals(sorted(context.executed_impls), sorted([imp1, imp2a, imp2b])) + self.assertEquals(context.generation_output[0].name, 'temp/test/foo.txt') + self.assertTrue(os.path.exists(context.generation_output[0].name)) + self.assertEquals(context.generation_output[0].implementation,imp1) + + + def test__generate_with_exception(self): + def generate_exception(*args): + raise Exception("test exception %s" % args) + + iset = plugin.ImplSet() + imp1 = SimpleImpl("implml/test1.content", None) + imp1.outputfile = 'test/foo.txt' + imp2a = SimpleImpl("implml/test2.content", None) + imp2a.generate = generate_exception + iset.add_implementation(imp1) + iset.add_implementation(imp2a) + context = plugin.GenerationContext(output="temp") + iset.generate(context) + self.assertEquals(sorted(context.executed_impls), sorted([imp1, imp2a])) + self.assertEquals(context.generation_output[1].type, 'exception') + self.assertEquals(context.generation_output[1].name, 'exception from implml/test2.content') + self.assertEquals(context.generation_output[1].implementation, imp2a) + def test_add_implementation_and_get_implementations_by_file(self): - container = plugin.ImplSet() + iset = plugin.ImplSet() imp1 = plugin.ImplBase("implml/test.content",None) imp2a = plugin.ImplBase("implml/copy.content",None) imp2b = plugin.ImplBase("implml/copy.content",None) - container.add_implementation(imp1) - container.add_implementation(imp2a) - container.add_implementation(imp2b) - self.assertEquals(container.get_implementations_by_file("implml/test.content"), [imp1]) - self.assertEquals(sorted(container.get_implementations_by_file("implml/copy.content")), + iset.add_implementation(imp1) + iset.add_implementation(imp2a) + iset.add_implementation(imp2b) + self.assertEquals(iset.get_implementations_by_file("implml/test.content"), [imp1]) + self.assertEquals(sorted(iset.get_implementations_by_file("implml/copy.content")), sorted([imp2a, imp2b])) def test_add_implementation_and_remove_implementation(self): - container = plugin.ImplSet() + iset = plugin.ImplSet() imp1 = plugin.ImplBase("implml/test.content",None) imp2a = plugin.ImplBase("implml/copy.content",None) imp2b = plugin.ImplBase("implml/copy.content",None) - container.add_implementation(imp1) - container.add_implementation(imp2a) - container.add_implementation(imp2b) - container.remove_implementation("implml/test.content") - self.assertEquals(len(container.list_implementation()),1) - self.assertEquals(container.list_implementation()[0],"implml/copy.content") + iset.add_implementation(imp1) + iset.add_implementation(imp2a) + iset.add_implementation(imp2b) + iset.remove_implementation("implml/test.content") + self.assertEquals(len(iset.list_implementation()),1) + self.assertEquals(iset.list_implementation()[0],"implml/copy.content") def test_add_implementation_and_remove_all(self): - container = plugin.ImplSet() + iset = plugin.ImplSet() imp1 = plugin.ImplBase("implml/test.content",None) imp2a = plugin.ImplBase("implml/copy.content",None) imp2b = plugin.ImplBase("implml/copy.content",None) imp3 = plugin.ImplBase("implml/foo.content",None) - container.add_implementation(imp1) - container.add_implementation(imp2a) - container.add_implementation(imp2b) - container.add_implementation(imp3) - for implref in container.list_implementation(): - container.remove_implementation(implref) - self.assertEquals(len(container.list_implementation()),0) + iset.add_implementation(imp1) + iset.add_implementation(imp2a) + iset.add_implementation(imp2b) + iset.add_implementation(imp3) + for implref in iset.list_implementation(): + iset.remove_implementation(implref) + self.assertEquals(len(iset.list_implementation()),0) def test_create_impl_set(self): plugin.create_impl_set('',None); pass def test_add_implementation_find_with_tags(self): - class TestPlugin(plugin.ImplBase): - pass - container = plugin.ImplSet() - imp1 = TestPlugin("implml/test.content",None) - imp2 = TestPlugin("implml/copy.content",None) - imp3 = TestPlugin("implml/foo.content",None) + def impl_list(impl_iterable): + return sorted(list(impl_iterable), key=lambda impl: impl.ref) + + iset = plugin.ImplSet() + imp1 = TestPlugin("implml/test.content") + imp2 = TestPlugin("implml/copy.content") + imp3 = TestPlugin("implml/foo.content") imp1.set_tags({'target': ['core','rofs2','rofs3']}) imp2.set_tags({'target': ['rofs3','uda']}) imp3.set_tags({'target': ['mmc','uda']}) - container.add_implementation(imp1) - container.add_implementation(imp2) - container.add_implementation(imp3) - self.assertEquals(list(container.filter_implementations(tags={'target' : ['rofs3']})), - [imp1,imp2]) - self.assertEquals(list(container.filter_implementations(tags={'target' : ['uda']})), - [imp2,imp3]) - self.assertEquals(list(container.filter_implementations(tags={'target' : ['mmc','uda']}, policy='AND')), - [imp3]) - self.assertEquals(list(container.filter_implementations(tags={'target' : ['mmc','uda']}, policy='OR')), - [imp2, imp3]) - cont = container.filter_implementations(tags={'target' : ['core']}) | container.filter_implementations(tags={'target' : ['mmc']}) + iset.add_implementation(imp1) + iset.add_implementation(imp2) + iset.add_implementation(imp3) + self.assertEquals(impl_list(iset.filter_implementations(tags={'target' : ['rofs3']})), + impl_list([imp1,imp2])) + self.assertEquals(impl_list(iset.filter_implementations(tags={'target' : ['uda']})), + impl_list([imp2,imp3])) + self.assertEquals(impl_list(iset.filter_implementations(tags={'target' : ['mmc','uda']}, policy='AND')), + impl_list([imp3])) + self.assertEquals(impl_list(iset.filter_implementations(tags={'target' : ['mmc','uda']}, policy='OR')), + impl_list([imp2, imp3])) + cont = iset.filter_implementations(tags={'target' : ['core']}) | iset.filter_implementations(tags={'target' : ['mmc']}) self.assertEquals(len(cont),2) - self.assertEquals(list(cont), [imp1,imp3]) + self.assertEquals(impl_list(cont), impl_list([imp1,imp3])) - cont = container.filter_implementations(tags={'target' : ['rofs3']}) & container.filter_implementations(tags={'target' : ['uda']}) + cont = iset.filter_implementations(tags={'target' : ['rofs3']}) & iset.filter_implementations(tags={'target' : ['uda']}) self.assertEquals(len(cont),1) - self.assertEquals(list(cont), [imp2]) + self.assertEquals(impl_list(cont), impl_list([imp2])) def test_pre_impl_filter(self): resources = [ @@ -483,6 +744,40 @@ expected = map(lambda path: path.replace('/', '\\'), expected) self.assertEquals(expected, plugin.pre_filter_impls(resources)) + def test_get_implemented_refs(self): + + iset = plugin.ImplSet() + imp1 = TestPlugin('imp1') + imp2 = TestPlugin('imp2') + imp3 = TestPlugin('imp3') + iset.add_implementation(imp1) + iset.add_implementation(imp2) + iset.add_implementation(imp3) + imp1.refs = ['fea.child1', 'fea.child2'] + imp2.refs = ['fea.setting1'] + imp3.refs = ['foo.bar'] + self.assertEquals(sorted(iset.get_implemented_refs()), sorted(['fea.child1', + 'fea.child2', + 'fea.setting1', + 'foo.bar'])) + + def test_get_implementations_with_ref(self): + + iset = plugin.ImplSet() + imp1 = TestPlugin('implml1') + imp2 = TestPlugin('implml2') + imp3 = TestPlugin('implml3') + imp4 = TestPlugin('implml3') + iset.add_implementation(imp1) + iset.add_implementation(imp2) + iset.add_implementation(imp3) + iset.add_implementation(imp4) + imp1.refs = ['fea.child1', 'fea.child2'] + imp2.refs = ['foo.bar', 'fea.setting1'] + imp3.refs = ['foo.bar'] + self.assertEquals(iset.get_implementations_with_ref('fea.child1'), [imp1]) + self.assertEquals(iset.get_implementations_with_ref('fea.setting1'), [imp2]) + self.assertEquals(iset.get_implementations_with_ref('foo.bar'), [imp2, imp3]) class TestPluginImplSetCopy(unittest.TestCase): class TestImpl(plugin.ImplBase): @@ -509,12 +804,12 @@ return plugin.create_impl_set(impl_files, mock_config) - def test_get_test_impl_container(self): - container = self._get_impl_container() + def test_get_test_impl_iset(self): + iset = self._get_impl_container() # There are 5 ImplML files - self.assertEquals(len(container.list_implementation()), 5) + self.assertEquals(len(iset.list_implementation()), 5) # ...but two of them contain 3 implementations each - self.assertEquals(len(container), 5) + self.assertEquals(len(iset), 5) def _get_phase_test_impl_container(self): return plugin.ImplSet([ @@ -525,13 +820,13 @@ self.PostImpl('foo.post', None), ]) - def test_get_phase_test_impl_container(self): - container = self._get_phase_test_impl_container() - self.assertEquals(5, len(container)) - self.assertEquals(len(container.list_implementation()), 5) + def test_get_phase_test_impl_iset(self): + iset = self._get_phase_test_impl_container() + self.assertEquals(5, len(iset)) + self.assertEquals(len(iset.list_implementation()), 5) def check(filename, phase): - impls = container.get_implementations_by_file(filename) + impls = iset.get_implementations_by_file(filename) self.assertEquals(1, len(impls)) impl = impls[0] self.assertEquals(impl.ref, filename) @@ -542,31 +837,31 @@ check('test.post', 'post') check('foo.post', 'post') - return container + return iset def test_create_impl_set(self): - container = self._get_impl_container() + iset = self._get_impl_container() # There are 5 ImplML files - self.assertEquals(len(container.list_implementation()), 5) + self.assertEquals(len(iset.list_implementation()), 5) # ...but two of them contain 3 implementations each - self.assertEquals(len(container), 5) + self.assertEquals(len(iset), 5) def test_invocation_phases(self): - container = self._get_phase_test_impl_container() - phases = container.invocation_phases() + iset = self._get_phase_test_impl_container() + phases = iset.invocation_phases() self.assertEquals(phases,['pre','normal','post']) def test_copy(self): - container = self._get_impl_container() - newcontainer = container.copy() - self.assertTrue(newcontainer is not container) + iset = self._get_impl_container() + newcontainer = iset.copy() + self.assertTrue(newcontainer is not iset) self.assertEquals(len(newcontainer), 5) def test_execute_generate(self): - container = self._get_impl_container() - container.execute(container, 'generate') + iset = self._get_impl_container() + iset.execute(iset, 'generate') actual_impls = [] - for impl in container: + for impl in iset: if isinstance(impl, plugin.ImplContainer): actual_impls += impl.get_all_implementations() else: @@ -575,14 +870,14 @@ self.assertTrue(impl.generate_invoked) def test_impl_container_generate(self): - container = self._get_impl_container() + iset = self._get_impl_container() context = plugin.GenerationContext() context.history = "" context.objects = [] - container.generate(context) + iset.generate(context) self.assertEquals(len(context.objects), 9) actual_impls = [] - for impl in container: + for impl in iset: if isinstance(impl, plugin.ImplContainer): actual_impls += impl.get_all_implementations() else: @@ -591,27 +886,27 @@ self.assertTrue(impl.generate_invoked) def test_filter_all(self): - container = self._get_impl_container() - impl_list = container.filter_implementations() + iset = self._get_impl_container() + impl_list = iset.filter_implementations() self.assertEquals(len(impl_list), 5) def test_filter_for_pre_phase(self): - container = self._get_phase_test_impl_container() - impl_list = list(container.filter_implementations(phase='pre')) + iset = self._get_phase_test_impl_container() + impl_list = list(iset.filter_implementations(phase='pre')) self.assertEquals(len(impl_list), 1) self.assertEquals(impl_list[0].invocation_phase(), 'pre') self.assertEquals(impl_list[0].ref, 'foo.pre') def test_filter_for_normal_phase(self): - container = self._get_phase_test_impl_container() - impl_list = list(container.filter_implementations(phase='normal')) + iset = self._get_phase_test_impl_container() + impl_list = list(iset.filter_implementations(phase='normal')) self.assertEquals(len(impl_list), 2) self.assertEquals(impl_list[0].invocation_phase(), 'normal') self.assertEquals(impl_list[1].invocation_phase(), 'normal') def test_filter_for_post_phase(self): - container = self._get_phase_test_impl_container() - impl_list = list(container.filter_implementations(phase='post')) + iset = self._get_phase_test_impl_container() + impl_list = list(iset.filter_implementations(phase='post')) self.assertEquals(len(impl_list), 2) self.assertEquals(impl_list[0].invocation_phase(), 'post') self.assertEquals(impl_list[1].invocation_phase(), 'post') @@ -628,11 +923,11 @@ def test_plugin_settings(self): settings.SettingsFactory.cone_parser().read([os.path.join(ROOT_PATH,'test_defaults.cfg')]) impl = TestPluginImplSettings.Test1Impl("",None) - self.assertEquals(impl.output_root, 'output') + self.assertEquals(impl.output_root, '') self.assertEquals(impl.output_subdir, '') impl.output_subdir = 'foobar' self.assertEquals(impl.get_tags(), {}) - self.assertEquals(impl.output, 'output/foobar') + self.assertEquals(impl.output, 'foobar') impl = TestPluginImplSettings.Test2Impl("",None) self.assertEquals(impl.output_subdir, '') @@ -740,12 +1035,6 @@ MockImpl(['MockReader2', file, {'a': '1', 'b': '2'}]),], file) - file = 'layer1/implml/ignored_ns_1.mock3ml' - self.assert_read_impls_equal([MockImpl(['MockReader3', file, {'x': '1'}])], file) - - file = 'layer1/implml/ignored_ns_2.mock3ml' - self.assert_read_impls_equal([MockImpl(['MockReader3', file, {'x': '1'}])], file) - self.assert_read_impls_equal([], 'layer1/implml/unsupported1.implml') self.assert_read_impls_equal([], 'layer1/implml/unsupported2.implml') @@ -788,9 +1077,6 @@ MockImpl(['MockReader3', 'layer1/implml/single3.test3ml', {'x': '1'}]), - MockImpl(['MockReader3', 'layer1/implml/ignored_ns_1.mock3ml', {'x': '1'}]), - MockImpl(['MockReader3', 'layer1/implml/ignored_ns_2.mock3ml', {'x': '1'}]), - MockImpl(['MockReader1','layer1/implml/multi1.implml', {'y': '2', 'x': '1'}]), MockImpl(['MockReader2', 'layer1/implml/multi1.implml', {'y': '20', 'x': '10'}]), MockImpl(['MockReader3', 'layer1/implml/multi1.implml', {'y': '200', 'x': '100'}, {'z': '300'}]), @@ -878,8 +1164,8 @@ self.assert_contains_feature(config, 'TempFeature.Seq.DefaultType', 'string', []) fea = config.get_default_view().get_feature('TempFeature.Seq') - fea.set_value([['test', '1', '2.0', 'true', 'foo']]) - self.assertEquals(fea.get_value(), [['test', '1', '2.0', 'true', 'foo']]) + fea.set_value([['test', 1, 2.0, True, 'foo']]) + self.assertEquals(fea.get_value(), [['test', 1, 2.0, True, 'foo']]) def _create_mock_impl(self, temp_var_defs): impl = Mock() @@ -950,7 +1236,10 @@ config = api.Configuration("test.confml") config.add_feature(api.Feature("Int"), "TempFeature") - self.assertRaises(exceptions.AlreadyExists, impls.create_temp_features, config) + #self.assertRaises(exceptions.AlreadyExists, impls.create_temp_features, config) + temp_feature_refs = impls.create_temp_features(config) + self.assertEquals(temp_feature_refs, ['TempFeature.String', 'TempFeature.Real', 'TempFeature.Boolean']) + class TestCommonImplmlDataReader(unittest.TestCase):