class ParserReloadSimpleContentTestSuite(TestCase): """ """ def setUp(self): simple_content_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'simple_content') self.simple_content_data_handler = DataHandler(simple_content_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = True # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 self.request.session['keys'] = {} self.request.session['keyrefs'] = {} # set default namespace self.namespace = { 'xs': SCHEMA_NAMESPACE } self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = self.namespace from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_restriction(self): xsd_files = join('restriction', 'basic') xsd_tree = self.simple_content_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:simpleContent', namespaces=self.namespace)[0] xml_tree = self.simple_content_data_handler.get_xml(xsd_files) result_string = generate_simple_content(self.request, xsd_element, xsd_tree, full_path='/root', default_value='child0', edit_data_tree=xml_tree) expected_element = self.simple_content_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) def test_extension(self): xsd_files = join('extension', 'basic') xsd_tree = self.simple_content_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:simpleContent', namespaces=self.namespace)[0] xml_tree = self.simple_content_data_handler.get_xml(xsd_files) xml_value = xml_tree.xpath("/root", namespaces=self.namespace)[0].text result_string = generate_simple_content(self.request, xsd_element, xsd_tree, full_path='/root', default_value=xml_value, edit_data_tree=xml_tree) expected_element = self.simple_content_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element)
class ParserReloadChoiceTestSuite(TestCase): """ """ def setUp(self): choice_data = join('curate', 'tests', 'data', 'parser', 'choice') self.choice_data_handler = DataHandler(choice_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} def test_reload_element_basic(self): xsd_files = join('element', 'basic') xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType/xs:choice', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_element_unbounded(self): # FIXME correct the bug here xsd_files = join('element', 'unbounded') xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType/xs:choice', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # TODO implement later # def test_reload_group_basic(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # def test_reload_group_unbounded(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_choice_basic(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_choice_unbounded(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence_basic(self): xsd_files = join('sequence', 'basic') xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType/xs:choice', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence_unbounded(self): # fixme reload sequence unbounded has a bug # fixme choice iter and inner element repeated xsd_files = join('sequence', 'unbounded') xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType/xs:choice', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element)
class ParserReloadSimpleTypeTestSuite(TestCase): """ """ def setUp(self): simple_type_data = join('curate', 'tests', 'data', 'parser', 'simple_type') self.simple_type_data_handler = DataHandler(simple_type_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 self.request.session['implicit_extension'] = True # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} def test_reload_restriction(self): # FIXME relaod restriction doesn't work xsd_files = join('restriction', 'basic') xsd_tree = self.simple_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:simpleType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.simple_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = xml_tree.xpath("/root", namespaces=self.request.session['namespaces'])[0].text clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='/root', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string expected_dict = self.simple_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict) def test_reload_list(self): # FIXME list reload is not working xsd_files = join('list', 'basic') xsd_tree = self.simple_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:simpleType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.simple_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_dict = self.simple_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict)
class ParserReloadExtensionTestSuite(TestCase): """ """ def setUp(self): extension_data = join('curate', 'tests', 'data', 'parser', 'extension') self.extension_data_handler = DataHandler(extension_data) self.maxDiff = None engine = import_module(settings.SESSION_ENGINE) store = engine.SessionStore() # Session dictionary update store['curate_edit'] = True # Data edition store['nb_html_tags'] = 0 store['mapTagID'] = {} store['nbChoicesID'] = 0 store['keys'] = {} store['keyrefs'] = {} # set default namespace self.namespace = "{" + SCHEMA_NAMESPACE + "}" store['defaultPrefix'] = 'xs' store['namespaces'] = {'xs': SCHEMA_NAMESPACE} store.save() self.session = store self.request = HttpRequest() self.request.session = self.session # def test_reload_group(self): # xsd_files = join('group', 'basic') # xsd_tree = etree.ElementTree(self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test0', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = { # } # # self.assertDictEqual(result_string[1], expected_dict) # # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string) # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # def test_reload_all(self): # # fixme bugs # xsd_files = join('all', 'basic') # xsd_tree = etree.ElementTree(self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test1', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = {} # # self.assertDictEqual(result_string[1], expected_dict) # # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string) # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_choice(self): xsd_files = join('choice', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', namespaces=self.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = xml_tree.xpath( '/test2', namespaces=self.session['namespaces'])[0].text clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/test2', default_value=xml_value, edit_data_tree=edit_data_tree) expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict) def test_sequence(self): xsd_files = join('sequence', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', namespaces=self.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = '' clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/root[1]', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict) def test_attribute(self): xsd_files = join('attribute', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:element/xs:complexType/xs:simpleContent/xs:extension', namespaces=self.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) xml_value = xml_tree.xpath( '/root[1]', namespaces=self.session['namespaces'])[0].text # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/root[1]', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict) # def test_reload_attribute_group(self): # xsd_files = join('attribute_group', 'basic') # xsd_tree = self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:simpleContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test5', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = {'value': None, 'tag': 'extension', 'occurs': (1, 1, 1), 'module': None, 'children': []} # # self.assertDictEqual(result_string[1], expected_dict) # self.assertEqual(result_string[0], '') # # # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_any_attribute(self): # xsd_files = join('any_attribute', 'basic') # xsd_tree = self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:simpleContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test6', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = {'value': None, 'tag': 'extension', 'occurs': (1, 1, 1), 'module': None, 'children': []} # # self.assertDictEqual(result_string[1], expected_dict) # # self.assertEqual(result_string[0], '') # # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_multiple(self): xsd_files = join('multiple', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', namespaces=self.request.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # default_value = edit_data_tree.xpath('/root[1]', namespaces=self.request.session['namespaces']) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/root[1]', default_value=edit_data_tree, edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict)
class ParserReloadComplexContentTestSuite(TestCase): """ """ # FIXME restriction for complexContent are not working def setUp(self): extension_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'complex_content') self.extension_data_handler = DataHandler(extension_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_reload_restriction(self): xsd_files = join('restriction', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:element/xs:complexType/xs:complexContent', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_content(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict) # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string[0]) # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_extension(self): xsd_files = join('extension', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:element/xs:complexType/xs:complexContent', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_content(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict)
class ParserReloadExtensionTestSuite(TestCase): """ """ def setUp(self): extension_data = join('curate', 'tests', 'data', 'parser', 'extension') self.extension_data_handler = DataHandler(extension_data) self.maxDiff = None engine = import_module(settings.SESSION_ENGINE) store = engine.SessionStore() # Session dictionary update store['curate_edit'] = True # Data edition store['nb_html_tags'] = 0 store['mapTagID'] = {} store['nbChoicesID'] = 0 store['keys'] = {} store['keyrefs'] = {} # set default namespace self.namespace = "{" + SCHEMA_NAMESPACE + "}" store['defaultPrefix'] = 'xs' store['namespaces'] = {'xs': SCHEMA_NAMESPACE} store.save() self.session = store self.request = HttpRequest() self.request.session = self.session # def test_reload_group(self): # xsd_files = join('group', 'basic') # xsd_tree = etree.ElementTree(self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test0', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = { # } # # self.assertDictEqual(result_string[1], expected_dict) # # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string) # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # def test_reload_all(self): # # fixme bugs # xsd_files = join('all', 'basic') # xsd_tree = etree.ElementTree(self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test1', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = {} # # self.assertDictEqual(result_string[1], expected_dict) # # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string) # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_choice(self): xsd_files = join('choice', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', namespaces=self.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = xml_tree.xpath('/test2', namespaces=self.session['namespaces'])[0].text clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/test2', default_value=xml_value, edit_data_tree=edit_data_tree) expected_dict = self.extension_data_handler.get_json(xsd_files+'.reload') self.assertDictEqual(result_string[1], expected_dict) def test_sequence(self): xsd_files = join('sequence', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', namespaces=self.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = '' clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/root[1]', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files+'.reload') self.assertDictEqual(result_string[1], expected_dict) def test_attribute(self): xsd_files = join('attribute', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:simpleContent/xs:extension', namespaces=self.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) xml_value = xml_tree.xpath('/root[1]', namespaces=self.session['namespaces'])[0].text # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/root[1]', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files+'.reload') self.assertDictEqual(result_string[1], expected_dict) # def test_reload_attribute_group(self): # xsd_files = join('attribute_group', 'basic') # xsd_tree = self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:simpleContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test5', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = {'value': None, 'tag': 'extension', 'occurs': (1, 1, 1), 'module': None, 'children': []} # # self.assertDictEqual(result_string[1], expected_dict) # self.assertEqual(result_string[0], '') # # # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_any_attribute(self): # xsd_files = join('any_attribute', 'basic') # xsd_tree = self.extension_data_handler.get_xsd(xsd_files)) # xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:simpleContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.extension_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='/test6', # edit_data_tree=edit_data_tree) # # print result_string # # result_string = '<div>' + result_string + '</div>' # # expected_dict = {'value': None, 'tag': 'extension', 'occurs': (1, 1, 1), 'module': None, 'children': []} # # self.assertDictEqual(result_string[1], expected_dict) # # self.assertEqual(result_string[0], '') # # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_multiple(self): xsd_files = join('multiple', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent/xs:extension', namespaces=self.request.session['namespaces'])[0] xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # default_value = edit_data_tree.xpath('/root[1]', namespaces=self.request.session['namespaces']) result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='/root[1]', default_value=edit_data_tree, edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files+'.reload') self.assertDictEqual(result_string[1], expected_dict)
class ParserLookupOccursTestSuite(TestCase): """ """ def setUp(self): occurs_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'utils', 'occurs') self.occurs_data_handler = DataHandler(occurs_data) self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} self.xml_xpath = '/root' self.document_schema = self.occurs_data_handler.get_xsd('document') # self.document_schema = etree.ElementTree(document_schema) sequence_xpath = '/xs:schema/xs:element/xs:complexType/xs:sequence' self.sequence = self.document_schema.xpath( sequence_xpath, namespaces=self.request.session['namespaces'])[0] def test_reload_compliant_element(self): compliant_xml = self.occurs_data_handler.get_xml('compliant') occurences = lookup_occurs(self.sequence, self.document_schema, self.xml_xpath, compliant_xml) self.assertEqual(len(occurences), 3) occ0_expected_xml = self.occurs_data_handler.get_xml('item0') occ1_expected_xml = self.occurs_data_handler.get_xml('item1') occ2_expected_xml = self.occurs_data_handler.get_xml('item2') self.assertTrue(are_equals(occurences[0], occ0_expected_xml)) self.assertTrue(are_equals(occurences[1], occ1_expected_xml)) self.assertTrue(are_equals(occurences[2], occ2_expected_xml)) def test_reload_noncompliant_element(self): noncompliant_xml = self.occurs_data_handler.get_xml('noncompliant') occurences = lookup_occurs(self.sequence, self.document_schema, self.xml_xpath, noncompliant_xml) self.assertEqual(len(occurences), 6) occ0_expected_xml = self.occurs_data_handler.get_xml('item0') occ1_expected_xml = self.occurs_data_handler.get_xml('item1') occ2_expected_xml = self.occurs_data_handler.get_xml('item2') occ3_expected_xml = self.occurs_data_handler.get_xml('item3') occ4_expected_xml = self.occurs_data_handler.get_xml('item4') occ5_expected_xml = self.occurs_data_handler.get_xml('item5') self.assertTrue(are_equals(occurences[0], occ0_expected_xml)) self.assertTrue(are_equals(occurences[1], occ1_expected_xml)) self.assertTrue(are_equals(occurences[2], occ2_expected_xml)) self.assertTrue(are_equals(occurences[3], occ3_expected_xml)) self.assertTrue(are_equals(occurences[4], occ4_expected_xml)) self.assertTrue(are_equals(occurences[5], occ5_expected_xml))
class ParserReloadRestrictionTestSuite(TestCase): """ """ def setUp(self): restriction_data = join('curate', 'tests', 'data', 'parser', 'restriction') self.restriction_data_handler = DataHandler(restriction_data) self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.maxDiff = None self.request.session['curate_edit'] = True # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace self.namespace = {'xs': SCHEMA_NAMESPACE} self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = self.namespace self.xml_xpath = '/root' def test_enumeration(self): xsd_files = join('enumeration', 'basic') xsd_tree = self.restriction_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:simpleType/xs:restriction', namespaces=self.namespace)[0] xml_tree = self.restriction_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) xml_data_value = xml_tree.xpath(self.xml_xpath)[0].text # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_restriction(self.request, xsd_element, xsd_tree, full_path=self.xml_xpath, edit_data_tree=xml_tree, default_value=xml_data_value) expected_element = self.restriction_data_handler.get_json( join('enumeration', 'reload')) self.assertDictEqual(result_string[1], expected_element) def test_simple_type(self): xsd_files = join('simple_type', 'basic') xsd_tree = self.restriction_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:simpleType/xs:restriction', namespaces=self.namespace)[0] xml_tree = self.restriction_data_handler.get_xml(xsd_files) xml_data_value = xml_tree.xpath(self.xml_xpath)[0].text result_string = generate_restriction(self.request, xsd_element, xsd_tree, full_path=self.xml_xpath, edit_data_tree=xml_tree, default_value=xml_data_value) expected_element = self.restriction_data_handler.get_json( join('simple_type', 'reload')) self.assertDictEqual(result_string[1], expected_element)
class ParserReloadRestrictionTestSuite(TestCase): """ """ def setUp(self): restriction_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'restriction') self.restriction_data_handler = DataHandler(restriction_data) self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.maxDiff = None self.request.session['curate_edit'] = True # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace self.namespace = { 'xs': SCHEMA_NAMESPACE } self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = self.namespace self.xml_xpath = '/root' from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_enumeration(self): xsd_files = join('enumeration', 'basic') xsd_tree = self.restriction_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:simpleType/xs:restriction', namespaces=self.namespace)[0] xml_tree = self.restriction_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) xml_data_value = xml_tree.xpath(self.xml_xpath)[0].text # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_restriction(self.request, xsd_element, xsd_tree, full_path=self.xml_xpath, edit_data_tree=xml_tree, default_value=xml_data_value) expected_element = self.restriction_data_handler.get_json(join('enumeration', 'reload')) self.assertDictEqual(result_string[1], expected_element) def test_simple_type(self): xsd_files = join('simple_type', 'basic') xsd_tree = self.restriction_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:simpleType/xs:restriction', namespaces=self.namespace)[0] xml_tree = self.restriction_data_handler.get_xml(xsd_files) xml_data_value = xml_tree.xpath(self.xml_xpath)[0].text result_string = generate_restriction(self.request, xsd_element, xsd_tree, full_path=self.xml_xpath, edit_data_tree=xml_tree, default_value=xml_data_value) expected_element = self.restriction_data_handler.get_json(join('simple_type', 'reload')) self.assertDictEqual(result_string[1], expected_element)
class ParserGetXmlElementDataTestSuite(TestCase): """ """ def setUp(self): xml_element_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "xml_data") self.xml_element_data_handler = DataHandler(xml_element_data) self.namespace = {"xs": SCHEMA_NAMESPACE} def test_element_xml_text(self): xml_schema = self.xml_element_data_handler.get_xsd(join("element", "simple")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join("element", "simple")) reload_data = get_xml_element_data(element_root, xml_element) self.assertEqual(reload_data, "string") def test_element_xml_branch(self): xml_schema = self.xml_element_data_handler.get_xsd(join("element", "complex")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join("element", "complex")) reload_data = get_xml_element_data(element_root, xml_element) self.assertEqual(reload_data, etree.tostring(xml_element)) def test_attribute(self): xml_schema = self.xml_element_data_handler.get_xsd(join("attribute", "schema")) attribute_xpath = "/xs:schema/xs:element/xs:complexType/xs:attribute" attribute = xml_schema.xpath(attribute_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join("attribute", "instance")) xml_element_attrib = xml_element.attrib["id"] reload_data = get_xml_element_data(attribute, xml_element_attrib) self.assertEqual(reload_data, "attr0") def test_complex_type_xml_empty(self): xml_schema = self.xml_element_data_handler.get_xsd(join("complex_type", "schema")) complex_type_xpath = "/xs:schema/xs:complexType" complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join("complex_type", "empty")) reload_data = get_xml_element_data(complex_type, xml_element) self.assertEqual(reload_data, "") def test_complex_type_xml_branch(self): xml_schema = self.xml_element_data_handler.get_xsd(join("complex_type", "schema")) complex_type_xpath = "/xs:schema/xs:complexType" complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join("complex_type", "filled")) reload_data = get_xml_element_data(complex_type, xml_element) self.assertEqual(reload_data, etree.tostring(xml_element)) def test_simple_type_xml_text(self): xml_schema = self.xml_element_data_handler.get_xsd(join("simple_type", "schema")) simple_type_xpath = "/xs:schema/xs:simpleType" simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join("simple_type", "filled")) reload_data = get_xml_element_data(simple_type, xml_element) self.assertEqual(reload_data, "child0") def test_simple_type_empty(self): xml_schema = self.xml_element_data_handler.get_xsd(join("simple_type", "schema")) simple_type_xpath = "/xs:schema/xs:simpleType" simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join("simple_type", "empty")) reload_data = get_xml_element_data(simple_type, xml_element) self.assertEqual(reload_data, "")
class ParserLookupOccursTestSuite(TestCase): """ """ def setUp(self): occurs_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "occurs") self.occurs_data_handler = DataHandler(occurs_data) self.request = HttpRequest() engine = import_module("django.contrib.sessions.backends.db") session_key = None self.request.session = engine.SessionStore(session_key) self.request.session["curate_edit"] = False # Data edition self.request.session["nb_html_tags"] = 0 self.request.session["mapTagID"] = {} self.request.session["nbChoicesID"] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.request.session["defaultPrefix"] = "xs" self.request.session["namespaces"] = {"xs": namespace} self.xml_xpath = "/root" self.document_schema = self.occurs_data_handler.get_xsd("document") # self.document_schema = etree.ElementTree(document_schema) sequence_xpath = "/xs:schema/xs:element/xs:complexType/xs:sequence" self.sequence = self.document_schema.xpath(sequence_xpath, namespaces=self.request.session["namespaces"])[0] def test_reload_compliant_element(self): compliant_xml = self.occurs_data_handler.get_xml("compliant") occurences = lookup_occurs(self.sequence, self.document_schema, self.xml_xpath, compliant_xml) self.assertEqual(len(occurences), 3) occ0_expected_xml = self.occurs_data_handler.get_xml("item0") occ1_expected_xml = self.occurs_data_handler.get_xml("item1") occ2_expected_xml = self.occurs_data_handler.get_xml("item2") self.assertTrue(are_equals(occurences[0], occ0_expected_xml)) self.assertTrue(are_equals(occurences[1], occ1_expected_xml)) self.assertTrue(are_equals(occurences[2], occ2_expected_xml)) def test_reload_noncompliant_element(self): noncompliant_xml = self.occurs_data_handler.get_xml("noncompliant") occurences = lookup_occurs(self.sequence, self.document_schema, self.xml_xpath, noncompliant_xml) self.assertEqual(len(occurences), 6) occ0_expected_xml = self.occurs_data_handler.get_xml("item0") occ1_expected_xml = self.occurs_data_handler.get_xml("item1") occ2_expected_xml = self.occurs_data_handler.get_xml("item2") occ3_expected_xml = self.occurs_data_handler.get_xml("item3") occ4_expected_xml = self.occurs_data_handler.get_xml("item4") occ5_expected_xml = self.occurs_data_handler.get_xml("item5") self.assertTrue(are_equals(occurences[0], occ0_expected_xml)) self.assertTrue(are_equals(occurences[1], occ1_expected_xml)) self.assertTrue(are_equals(occurences[2], occ2_expected_xml)) self.assertTrue(are_equals(occurences[3], occ3_expected_xml)) self.assertTrue(are_equals(occurences[4], occ4_expected_xml)) self.assertTrue(are_equals(occurences[5], occ5_expected_xml))
class ParserReloadComplexTypeTestSuite(TestCase): """ """ def setUp(self): complex_type_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'complex_type') self.complex_type_data_handler = DataHandler(complex_type_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 self.request.session['implicit_extension'] = True self.request.session['keys'] = {} self.request.session['keyrefs'] = {} # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_reload_simple_content(self): xsd_files = join('simple_content', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = xml_tree.xpath("/root", namespaces=self.request.session['namespaces'])[0].text clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_complex_content(self): xsd_files = join('complex_content', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # print result_string # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # # FIXME group not implemented # def test_reload_group(self): # xsd_files = join('simple_content', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # def test_reload_all(self): # xsd_files = join('all', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, self.namespace, full_path='/root', # edit_data_tree=edit_data_tree) # # print result_string # # expected_element = { # } # # self.assertDictEqual(result_string[1], expected_element) # # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_choice(self): xsd_files = join('choice', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence(self): xsd_files = join('sequence', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_attribute(self): xsd_files = join('attribute', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME implement attributeGroup # def test_reload_attribute_group(self): # xsd_files = join('simple_content', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # FIXME implement anyAttribute # def test_reload_any_attribute(self): # xsd_files = join('simple_content', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_multiple(self): # fixme test broken xsd_files = join('multiple', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element)
class ParserGetXmlElementDataTestSuite(TestCase): """ """ def setUp(self): xml_element_data = join('curate', 'tests', 'data', 'parser', 'utils', 'xml_data') self.xml_element_data_handler = DataHandler(xml_element_data) self.namespace = { 'xs': SCHEMA_NAMESPACE } def test_element_xml_text(self): xml_schema = self.xml_element_data_handler.get_xsd(join('element', 'simple')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join('element', 'simple')) reload_data = get_xml_element_data(element_root, xml_element) self.assertEqual(reload_data, 'string') def test_element_xml_branch(self): xml_schema = self.xml_element_data_handler.get_xsd(join('element', 'complex')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join('element', 'complex')) reload_data = get_xml_element_data(element_root, xml_element) self.assertEqual(reload_data, etree.tostring(xml_element)) def test_attribute(self): xml_schema = self.xml_element_data_handler.get_xsd(join('attribute', 'schema')) attribute_xpath = '/xs:schema/xs:element/xs:complexType/xs:attribute' attribute = xml_schema.xpath(attribute_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join('attribute', 'instance')) xml_element_attrib = xml_element.attrib['id'] reload_data = get_xml_element_data(attribute, xml_element_attrib) self.assertEqual(reload_data, 'attr0') def test_complex_type_xml_empty(self): xml_schema = self.xml_element_data_handler.get_xsd(join('complex_type', 'schema')) complex_type_xpath = '/xs:schema/xs:complexType' complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join('complex_type', 'empty')) reload_data = get_xml_element_data(complex_type, xml_element) self.assertEqual(reload_data, "") def test_complex_type_xml_branch(self): xml_schema = self.xml_element_data_handler.get_xsd(join('complex_type', 'schema')) complex_type_xpath = '/xs:schema/xs:complexType' complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join('complex_type', 'filled')) reload_data = get_xml_element_data(complex_type, xml_element) self.assertEqual(reload_data, etree.tostring(xml_element)) def test_simple_type_xml_text(self): xml_schema = self.xml_element_data_handler.get_xsd(join('simple_type', 'schema')) simple_type_xpath = '/xs:schema/xs:simpleType' simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join('simple_type', 'filled')) reload_data = get_xml_element_data(simple_type, xml_element) self.assertEqual(reload_data, "child0") def test_simple_type_empty(self): xml_schema = self.xml_element_data_handler.get_xsd(join('simple_type', 'schema')) simple_type_xpath = '/xs:schema/xs:simpleType' simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml(join('simple_type', 'empty')) reload_data = get_xml_element_data(simple_type, xml_element) self.assertEqual(reload_data, "")
class ParserLookupOccursTestSuite(TestCase): """ """ def setUp(self): occurs_data = join('curate', 'tests', 'data', 'parser', 'utils', 'occurs') self.occurs_data_handler = DataHandler(occurs_data) self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} self.xml_xpath = '/root' self.document_schema = self.occurs_data_handler.get_xsd('document') # self.document_schema = etree.ElementTree(document_schema) sequence_xpath = '/xs:schema/xs:element/xs:complexType/xs:sequence' self.sequence = self.document_schema.xpath(sequence_xpath, namespaces=self.request.session['namespaces'])[0] def test_reload_compliant_element(self): compliant_xml = self.occurs_data_handler.get_xml('compliant') occurences = lookup_occurs(self.sequence, self.document_schema, self.xml_xpath, compliant_xml) self.assertEqual(len(occurences), 3) occ0_expected_xml = self.occurs_data_handler.get_xml('item0') occ1_expected_xml = self.occurs_data_handler.get_xml('item1') occ2_expected_xml = self.occurs_data_handler.get_xml('item2') self.assertTrue(are_equals(occurences[0], occ0_expected_xml)) self.assertTrue(are_equals(occurences[1], occ1_expected_xml)) self.assertTrue(are_equals(occurences[2], occ2_expected_xml)) def test_reload_noncompliant_element(self): noncompliant_xml = self.occurs_data_handler.get_xml('noncompliant') occurences = lookup_occurs(self.sequence, self.document_schema, self.xml_xpath, noncompliant_xml) self.assertEqual(len(occurences), 6) occ0_expected_xml = self.occurs_data_handler.get_xml('item0') occ1_expected_xml = self.occurs_data_handler.get_xml('item1') occ2_expected_xml = self.occurs_data_handler.get_xml('item2') occ3_expected_xml = self.occurs_data_handler.get_xml('item3') occ4_expected_xml = self.occurs_data_handler.get_xml('item4') occ5_expected_xml = self.occurs_data_handler.get_xml('item5') self.assertTrue(are_equals(occurences[0], occ0_expected_xml)) self.assertTrue(are_equals(occurences[1], occ1_expected_xml)) self.assertTrue(are_equals(occurences[2], occ2_expected_xml)) self.assertTrue(are_equals(occurences[3], occ3_expected_xml)) self.assertTrue(are_equals(occurences[4], occ4_expected_xml)) self.assertTrue(are_equals(occurences[5], occ5_expected_xml))
class ParserReloadElementTestSuite(TestCase): """ """ def setUp(self): element_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'element') self.element_data_handler = DataHandler(element_data) self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.maxDiff = None self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_reload_simple_type_basic(self): xsd_files = join('simple_type', 'basic') xsd_tree = self.element_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.element_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_element(self.request, xsd_element, xsd_tree, full_path='', edit_data_tree=edit_data_tree) expected_element = self.element_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.element_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_simple_type_unbounded(self): xsd_files = join('simple_type', 'unbounded') xsd_tree = self.element_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence/xs:element', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.element_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_element(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) expected_element = self.element_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.element_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_complex_type_basic(self): xsd_files = join('complex_type', 'basic') xsd_tree = self.element_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.element_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_element(self.request, xsd_element, xsd_tree, full_path='', edit_data_tree=edit_data_tree) expected_element = self.element_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.element_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_complex_type_unbounded(self): xsd_files = join('complex_type', 'unbounded') xsd_tree = self.element_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence/xs:element', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.element_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_element(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) expected_element = self.element_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element)
class ParserReloadSimpleTypeTestSuite(TestCase): """ """ def setUp(self): simple_type_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'simple_type') self.simple_type_data_handler = DataHandler(simple_type_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 self.request.session['implicit_extension'] = True # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_reload_restriction(self): # FIXME relaod restriction doesn't work xsd_files = join('restriction', 'basic') xsd_tree = self.simple_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:simpleType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.simple_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = xml_tree.xpath( "/root", namespaces=self.request.session['namespaces'])[0].text clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='/root', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string expected_dict = self.simple_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict) def test_reload_list(self): # FIXME list reload is not working xsd_files = join('list', 'basic') xsd_tree = self.simple_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:simpleType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.simple_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_dict = self.simple_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict)
class ParserReloadComplexContentTestSuite(TestCase): """ """ # FIXME restriction for complexContent are not working def setUp(self): extension_data = join('curate', 'tests', 'data', 'parser', 'complex_content') self.extension_data_handler = DataHandler(extension_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} def test_reload_restriction(self): xsd_files = join('restriction', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_content(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict) # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string[0]) # expected_html = self.extension_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_extension(self): xsd_files = join('extension', 'basic') xsd_tree = self.extension_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:element/xs:complexType/xs:complexContent', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.extension_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_content(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string # result_string = '<div>' + result_string + '</div>' expected_dict = self.extension_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_dict)
class ParserReloadComplexTypeTestSuite(TestCase): """ """ def setUp(self): complex_type_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'complex_type') self.complex_type_data_handler = DataHandler(complex_type_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 self.request.session['implicit_extension'] = True self.request.session['keys'] = {} self.request.session['keyrefs'] = {} # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_reload_simple_content(self): xsd_files = join('simple_content', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) xml_value = xml_tree.xpath( "/root", namespaces=self.request.session['namespaces'])[0].text clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', default_value=xml_value, edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_complex_content(self): xsd_files = join('complex_content', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # print result_string # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # # FIXME group not implemented # def test_reload_group(self): # xsd_files = join('simple_content', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # def test_reload_all(self): # xsd_files = join('all', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, self.namespace, full_path='/root', # edit_data_tree=edit_data_tree) # # print result_string # # expected_element = { # } # # self.assertDictEqual(result_string[1], expected_element) # # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_choice(self): xsd_files = join('choice', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence(self): xsd_files = join('sequence', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_attribute(self): xsd_files = join('attribute', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME implement attributeGroup # def test_reload_attribute_group(self): # xsd_files = join('simple_content', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # FIXME implement anyAttribute # def test_reload_any_attribute(self): # xsd_files = join('simple_content', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.complex_type_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_multiple(self): # fixme test broken xsd_files = join('multiple', 'basic') xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( '/xs:schema/xs:complexType', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.complex_type_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element)
class ParserReloadSequenceTestSuite(TestCase): """ """ def setUp(self): sequence_data = join('curate', 'tests', 'data', 'parser', 'sequence') self.sequence_data_handler = DataHandler(sequence_data) self.maxDiff = None self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) self.request.session['curate_edit'] = False # Data edition self.request.session['nb_html_tags'] = 0 self.request.session['mapTagID'] = {} self.request.session['nbChoicesID'] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session['defaultPrefix'] = 'xs' self.request.session['namespaces'] = {'xs': namespace} def test_reload_element_basic(self): xsd_files = join('element', 'basic') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_element_unbounded(self): # fixme correct bug xsd_files = join('element', 'unbounded') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # fixme implement groups # def test_reload_group_basic(self): # xsd_files = join('element', 'basic') # xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.sequence_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_group_unbounded(self): # xsd_files = join('element', 'basic') # xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.sequence_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_choice_basic(self): xsd_files = join('choice', 'basic') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_choice_unbounded(self): xsd_files = join('choice', 'unbounded') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence_basic(self): xsd_files = join('sequence', 'basic') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence_unbounded(self): xsd_files = join('sequence', 'unbounded') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # TODO implement tests # def test_reload_any_basic(self): # xsd_files = join('element', 'basic') # xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.sequence_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_any_unbounded(self): # xsd_files = join('element', 'basic') # xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.sequence_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_multiple_basic(self): xsd_files = join('multiple', 'basic') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element) # result_string = '<div>' + result_string[0] + '</div>' # # result_html = etree.fromstring(result_string) # expected_html = self.sequence_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_multiple_unbounded(self): xsd_files = join('multiple', 'unbounded') xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] self.request.session['curate_edit'] = True xml_tree = self.sequence_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='/root', edit_data_tree=edit_data_tree) expected_element = self.sequence_data_handler.get_json(xsd_files + '.reload') self.assertDictEqual(result_string[1], expected_element)
class ParserGetXmlElementDataTestSuite(TestCase): """ """ def setUp(self): xml_element_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'utils', 'xml_data') self.xml_element_data_handler = DataHandler(xml_element_data) self.namespace = {'xs': SCHEMA_NAMESPACE} def test_element_xml_text(self): xml_schema = self.xml_element_data_handler.get_xsd( join('element', 'simple')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml( join('element', 'simple')) reload_data = get_xml_element_data(element_root, xml_element) self.assertEqual(reload_data, 'string') def test_element_xml_branch(self): xml_schema = self.xml_element_data_handler.get_xsd( join('element', 'complex')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml( join('element', 'complex')) reload_data = get_xml_element_data(element_root, xml_element) self.assertEqual(reload_data, etree.tostring(xml_element)) def test_attribute(self): xml_schema = self.xml_element_data_handler.get_xsd( join('attribute', 'schema')) attribute_xpath = '/xs:schema/xs:element/xs:complexType/xs:attribute' attribute = xml_schema.xpath(attribute_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml( join('attribute', 'instance')) xml_element_attrib = xml_element.attrib['id'] reload_data = get_xml_element_data(attribute, xml_element_attrib) self.assertEqual(reload_data, 'attr0') def test_complex_type_xml_empty(self): xml_schema = self.xml_element_data_handler.get_xsd( join('complex_type', 'schema')) complex_type_xpath = '/xs:schema/xs:complexType' complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml( join('complex_type', 'empty')) reload_data = get_xml_element_data(complex_type, xml_element) self.assertEqual(reload_data, "") def test_complex_type_xml_branch(self): xml_schema = self.xml_element_data_handler.get_xsd( join('complex_type', 'schema')) complex_type_xpath = '/xs:schema/xs:complexType' complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml( join('complex_type', 'filled')) reload_data = get_xml_element_data(complex_type, xml_element) reload_data = "<root>" + reload_data + "</root>" self.assertEqual(reload_data, etree.tostring(xml_element)) def test_simple_type_xml_text(self): xml_schema = self.xml_element_data_handler.get_xsd( join('simple_type', 'schema')) simple_type_xpath = '/xs:schema/xs:simpleType' simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml( join('simple_type', 'filled')) reload_data = get_xml_element_data(simple_type, xml_element) self.assertEqual(reload_data, "child0") def test_simple_type_empty(self): xml_schema = self.xml_element_data_handler.get_xsd( join('simple_type', 'schema')) simple_type_xpath = '/xs:schema/xs:simpleType' simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] xml_element = self.xml_element_data_handler.get_xml( join('simple_type', 'empty')) reload_data = get_xml_element_data(simple_type, xml_element) self.assertEqual(reload_data, "")
class ParserReloadChoiceTestSuite(TestCase): """ """ def setUp(self): choice_data = join("utils", "XSDParser", "tests", "data", "parser", "choice") self.choice_data_handler = DataHandler(choice_data) self.maxDiff = None self.request = HttpRequest() engine = import_module("django.contrib.sessions.backends.db") session_key = None self.request.session = engine.SessionStore(session_key) self.request.session["curate_edit"] = False # Data edition self.request.session["nb_html_tags"] = 0 self.request.session["mapTagID"] = {} self.request.session["nbChoicesID"] = 0 # set default namespace namespace = "http://www.w3.org/2001/XMLSchema" self.namespace = "{" + namespace + "}" self.request.session["defaultPrefix"] = "xs" self.request.session["namespaces"] = {"xs": namespace} from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_reload_element_basic(self): xsd_files = join("element", "basic") xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( "/xs:schema/xs:complexType/xs:choice", namespaces=self.request.session["namespaces"] )[0] self.request.session["curate_edit"] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode("utf-8"))) result_string = generate_choice( self.request, xsd_element, xsd_tree, full_path="/root", edit_data_tree=edit_data_tree ) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + ".reload") self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_element_unbounded(self): # FIXME correct the bug here xsd_files = join("element", "unbounded") xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( "/xs:schema/xs:complexType/xs:choice", namespaces=self.request.session["namespaces"] )[0] self.request.session["curate_edit"] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode("utf-8"))) result_string = generate_choice( self.request, xsd_element, xsd_tree, full_path="/root", edit_data_tree=edit_data_tree ) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + ".reload") self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) # TODO implement later # def test_reload_group_basic(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # def test_reload_group_unbounded(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_choice_basic(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_reload_choice_unbounded(self): # xsd_files = join('element', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # self.request.session['curate_edit'] = True # # xml_tree = self.choice_data_handler.get_xml(xsd_files) # xml_data = etree.tostring(xml_tree) # # clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) # etree.set_default_parser(parser=clean_parser) # # load the XML tree from the text # edit_data_tree = etree.XML(str(xml_data.encode('utf-8'))) # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='/root', # edit_data_tree=edit_data_tree) # print result_string # # # result_html = etree.fromstring(result_string) # # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence_basic(self): xsd_files = join("sequence", "basic") xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( "/xs:schema/xs:complexType/xs:choice", namespaces=self.request.session["namespaces"] )[0] self.request.session["curate_edit"] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode("utf-8"))) result_string = generate_choice( self.request, xsd_element, xsd_tree, full_path="/root", edit_data_tree=edit_data_tree ) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + ".reload") self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files + '.reload') # # self.assertTrue(are_equals(result_html, expected_html)) def test_reload_sequence_unbounded(self): # fixme reload sequence unbounded has a bug # fixme choice iter and inner element repeated xsd_files = join("sequence", "unbounded") xsd_tree = self.choice_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath( "/xs:schema/xs:complexType/xs:choice", namespaces=self.request.session["namespaces"] )[0] self.request.session["curate_edit"] = True xml_tree = self.choice_data_handler.get_xml(xsd_files) xml_data = etree.tostring(xml_tree) clean_parser = etree.XMLParser(remove_blank_text=True, remove_comments=True, remove_pis=True) etree.set_default_parser(parser=clean_parser) # load the XML tree from the text edit_data_tree = etree.XML(str(xml_data.encode("utf-8"))) result_string = generate_choice( self.request, xsd_element, xsd_tree, full_path="/root", edit_data_tree=edit_data_tree ) # print result_string expected_element = self.choice_data_handler.get_json(xsd_files + ".reload") self.assertDictEqual(result_string[1], expected_element)