class ParserRemoveAnnotationTestSuite(TestCase): """ """ def setUp(self): annotation_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "annotation") self.annotation_data_handler = DataHandler(annotation_data) self.namespaces = {"xs": SCHEMA_NAMESPACE} xsd_etree = self.annotation_data_handler.get_xsd("not_annot") self.xsd_xpath = "/xs:schema/xs:complexType/xs:sequence" self.expected_xsd = xsd_etree.xpath(self.xsd_xpath, namespaces=self.namespaces)[0] def test_annotation_is_removed(self): annotated_etree = self.annotation_data_handler.get_xsd("annot") # annotated_etree = etree.ElementTree(annotated_schema) annotated_element = annotated_etree.xpath(self.xsd_xpath, namespaces=self.namespaces)[0] remove_annotations(annotated_element) self.assertTrue(are_equals(annotated_element, self.expected_xsd)) def test_no_annotation_no_change(self): not_annotated_etree = self.annotation_data_handler.get_xsd("not_annot") not_annotated_element = not_annotated_etree.xpath(self.xsd_xpath, namespaces=self.namespaces)[0] remove_annotations(not_annotated_element) self.assertTrue(are_equals(not_annotated_element, self.expected_xsd))
class ParserHasModuleTestSuite(TestCase): """ """ def _save_module_to_db(self): # FIXME module is not saved in the right database module = Module() module.name = "registered_module" module.url = "registered_module" module.view = "registered_module" module.save() def setUp(self): # connect to test database # self.db_name = "mgi_test" # disconnect() # connect(self.db_name, port=27018) module_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "modules") self.module_data_handler = DataHandler(module_data) self.request = HttpRequest() engine = import_module("django.contrib.sessions.backends.db") session_key = None self.request.session = engine.SessionStore(session_key) from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_element_is_module_registered(self): # expect true self._save_module_to_db() xsd_tree = self.module_data_handler.get_xsd("registered_module") xsd_element = xsd_tree.getroot() has_module_result = has_module(self.request, xsd_element) self.assertTrue(has_module_result) def test_element_is_module_not_registered(self): # expect false xsd_tree = self.module_data_handler.get_xsd("unregistered_module") xsd_element = xsd_tree.getroot() has_module_result = has_module(self.request, xsd_element) self.assertFalse(has_module_result) def test_element_is_not_module(self): # expect false xsd_tree = self.module_data_handler.get_xsd("no_module") xsd_element = xsd_tree.getroot() has_module_result = has_module(self.request, xsd_element) self.assertFalse(has_module_result)
class ParserRemoveAnnotationTestSuite(TestCase): """ """ def setUp(self): annotation_data = join('curate', 'tests', 'data', 'parser', 'utils', 'annotation') self.annotation_data_handler = DataHandler(annotation_data) self.namespaces = { 'xs': SCHEMA_NAMESPACE } xsd_etree = self.annotation_data_handler.get_xsd('not_annot') self.xsd_xpath = '/xs:schema/xs:complexType/xs:sequence' self.expected_xsd = xsd_etree.xpath(self.xsd_xpath, namespaces=self.namespaces)[0] def test_annotation_is_removed(self): annotated_etree = self.annotation_data_handler.get_xsd('annot') # annotated_etree = etree.ElementTree(annotated_schema) annotated_element = annotated_etree.xpath(self.xsd_xpath, namespaces=self.namespaces)[0] remove_annotations(annotated_element) self.assertTrue(are_equals(annotated_element, self.expected_xsd)) def test_no_annotation_no_change(self): not_annotated_etree = self.annotation_data_handler.get_xsd('not_annot') not_annotated_element = not_annotated_etree.xpath(self.xsd_xpath, namespaces=self.namespaces)[0] remove_annotations(not_annotated_element) self.assertTrue(are_equals(not_annotated_element, self.expected_xsd))
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 ParserManageOccurencesTestSuite(TestCase): """ """ def setUp(self): occurs_data = join('curate', 'tests', 'data', 'parser', 'utils', 'manage_occurs') self.occurs_data_handler = DataHandler(occurs_data) def test_element_with_min_occurs_parsable(self): xsd_tree = self.occurs_data_handler.get_xsd('min_occurs_parsable') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(min_occ, 1) def test_element_with_max_occurs_unbounded(self): xsd_tree = self.occurs_data_handler.get_xsd('max_occurs_unbounded') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(max_occ, -1) def test_element_with_max_occurs_parsable(self): xsd_tree = self.occurs_data_handler.get_xsd('max_occurs_parsable') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(max_occ, 5)
class ParserManageOccurencesTestSuite(TestCase): """ """ def setUp(self): occurs_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'utils', 'manage_occurs') self.occurs_data_handler = DataHandler(occurs_data) def test_element_with_min_occurs_parsable(self): xsd_tree = self.occurs_data_handler.get_xsd('min_occurs_parsable') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(min_occ, 1) def test_element_with_max_occurs_unbounded(self): xsd_tree = self.occurs_data_handler.get_xsd('max_occurs_unbounded') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(max_occ, -1) def test_element_with_max_occurs_parsable(self): xsd_tree = self.occurs_data_handler.get_xsd('max_occurs_parsable') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(max_occ, 5)
class ParserManageOccurencesTestSuite(TestCase): """ """ def setUp(self): occurs_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "manage_occurs") self.occurs_data_handler = DataHandler(occurs_data) def test_element_with_min_occurs_parsable(self): xsd_tree = self.occurs_data_handler.get_xsd("min_occurs_parsable") xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(min_occ, 1) def test_element_with_max_occurs_unbounded(self): xsd_tree = self.occurs_data_handler.get_xsd("max_occurs_unbounded") xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(max_occ, -1) def test_element_with_max_occurs_parsable(self): xsd_tree = self.occurs_data_handler.get_xsd("max_occurs_parsable") xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_occurences(xsd_element) self.assertEqual(max_occ, 5)
class ParserHasModuleTestSuite(TestCase): """ """ def _save_module_to_db(self): # FIXME module is not saved in the right database module = Module(name="mock_module", url="/mock/url", view="mock.view", multiple=False) module.save() def setUp(self): # connect to test database # self.db_name = "mgi_test" # disconnect() # connect(self.db_name, port=27018) module_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'utils', 'modules') self.module_data_handler = DataHandler(module_data) self.request = HttpRequest() engine = import_module('django.contrib.sessions.backends.db') session_key = None self.request.session = engine.SessionStore(session_key) from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_element_is_module_registered(self): # expect true self._save_module_to_db() xsd_tree = self.module_data_handler.get_xsd('registered_module') xsd_element = xsd_tree.getroot() has_module_result = has_module(self.request, xsd_element) self.assertTrue(has_module_result) def test_element_is_module_not_registered(self): # expect false xsd_tree = self.module_data_handler.get_xsd('unregistered_module') xsd_element = xsd_tree.getroot() has_module_result = has_module(self.request, xsd_element) self.assertFalse(has_module_result) def test_element_is_not_module(self): # expect false xsd_tree = self.module_data_handler.get_xsd('no_module') xsd_element = xsd_tree.getroot() has_module_result = has_module(self.request, xsd_element) self.assertFalse(has_module_result)
class ParserCreateComplexContentTestSuite(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_create_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] result_string = generate_complex_content(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_dict = self.extension_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_complex_content(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_dict = self.extension_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_dict)
class ParserCreateSimpleTypeTestSuite(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_create_restriction(self): 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] result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_dict = self.simple_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_dict) # result_html = etree.fromstring(result_string[0]) # expected_html = self.simple_type_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_list(self): 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] result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='') expected_dict = self.simple_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_dict)
class ParserCreateRestrictionTestSuite(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'] = False # 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 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] result_string = generate_restriction(self.request, xsd_element, xsd_tree) # print result_string expected_element = self.restriction_data_handler.get_json(xsd_files) 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] result_string = generate_restriction(self.request, xsd_element, xsd_tree) # print result_string expected_element = self.restriction_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element)
class ParserCreateRestrictionTestSuite(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'] = False # 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 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] result_string = generate_restriction(self.request, xsd_element, xsd_tree) # print result_string expected_element = self.restriction_data_handler.get_json(xsd_files) 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] result_string = generate_restriction(self.request, xsd_element, xsd_tree) # print result_string expected_element = self.restriction_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element)
class ParserHasModuleTestSuite(TestCase): """ """ def _save_module_to_db(self): # FIXME module is not saved in the right database module = Module() module.name = 'registered_module' module.url = 'registered_module' module.view = 'registered_module' module.save() def setUp(self): # connect to test database # self.db_name = "mgi_test" # disconnect() # connect(self.db_name, port=27018) module_data = join('curate', 'tests', 'data', 'parser', 'utils', 'modules') self.module_data_handler = DataHandler(module_data) def test_element_is_module_registered(self): # expect true self._save_module_to_db() xsd_tree = self.module_data_handler.get_xsd('registered_module') xsd_element = xsd_tree.getroot() has_module_result = has_module(xsd_element) self.assertTrue(has_module_result) def test_element_is_module_not_registered(self): # expect false xsd_tree = self.module_data_handler.get_xsd('unregistered_module') xsd_element = xsd_tree.getroot() has_module_result = has_module(xsd_element) self.assertFalse(has_module_result) def test_element_is_not_module(self): # expect false xsd_tree = self.module_data_handler.get_xsd('no_module') xsd_element = xsd_tree.getroot() has_module_result = has_module(xsd_element) self.assertFalse(has_module_result)
class ParserCreateSimpleContentTestSuite(TestCase): """ """ def setUp(self): simple_content_data = join('curate', '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'] = False # 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 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] result_string = generate_simple_content(self.request, xsd_element, xsd_tree) expected_element = self.simple_content_data_handler.get_json(xsd_files) 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] result_string = generate_simple_content(self.request, xsd_element, xsd_tree) expected_element = self.simple_content_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element)
class ParserManageAttrOccurencesTestSuite(TestCase): """ """ def setUp(self): occurs_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "manage_occurs") self.occurs_data_handler = DataHandler(occurs_data) def test_use_optional(self): xsd_tree = self.occurs_data_handler.get_xsd("attr_use_optional") xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 1) def test_use_prohibited(self): xsd_tree = self.occurs_data_handler.get_xsd("attr_use_prohibited") xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 0) def test_use_required(self): xsd_tree = self.occurs_data_handler.get_xsd("attr_use_required") xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 1) self.assertEqual(max_occ, 1) def test_use_not_present(self): xsd_tree = self.occurs_data_handler.get_xsd("attr_use_undefined") xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) # FIXME test broken with current parser # self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 1)
class ParserManageAttrOccurencesTestSuite(TestCase): """ """ def setUp(self): occurs_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'utils', 'manage_occurs') self.occurs_data_handler = DataHandler(occurs_data) def test_use_optional(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_optional') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 1) def test_use_prohibited(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_prohibited') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 0) def test_use_required(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_required') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 1) self.assertEqual(max_occ, 1) def test_use_not_present(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_undefined') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) # FIXME test broken with current parser # self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 1)
class ParserManageAttrOccurencesTestSuite(TestCase): """ """ def setUp(self): occurs_data = join('curate', 'tests', 'data', 'parser', 'utils', 'manage_occurs') self.occurs_data_handler = DataHandler(occurs_data) def test_use_optional(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_optional') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 1) def test_use_prohibited(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_prohibited') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 0) def test_use_required(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_required') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) self.assertEqual(min_occ, 1) self.assertEqual(max_occ, 1) def test_use_not_present(self): xsd_tree = self.occurs_data_handler.get_xsd('attr_use_undefined') xsd_element = xsd_tree.getroot() (min_occ, max_occ) = manage_attr_occurrences(xsd_element) # FIXME test broken with current parser # self.assertEqual(min_occ, 0) self.assertEqual(max_occ, 1)
class ChoiceCreateSchemaTestSuite(SimpleTestCase): """ """ def setUp(self): xsd_files_path = join(XSD_FILES_PATH, 'choice') self.xsd_handler = DataHandler(xsd_files_path) html_files_path = join(HTML_FILES_PATH, 'choice') self.html_handler = DataHandler(html_files_path) engine = import_module('django.contrib.sessions.backends.db') session = engine.SessionStore() session.save() self.client.cookies['sessionid'] = session.session_key session['curate_edit'] = False form_data = FormData() form_data.name = '' form_data.user = '' form_data.template = '' form_data.save() session['curateFormData'] = str(form_data.pk) session['nb_html_tags'] = 0 session['implicit_extension'] = True session['mapTagID'] = {} session['nbChoicesID'] = 0 session.save() # def test_any_basic(self): # pass # # def test_any_unbounded(self): # pass def test_choice_basic(self): file_path = join('choice', 'basic') xsd_data = self.xsd_handler.get_xsd(file_path) session = self.client.session session['xmlDocTree'] = etree.tostring(xsd_data) session.save() result = retrieve_rendered_form(self.client) expected_result = self.html_handler.get_html(file_path) self.assertTrue(are_equals(result[1], expected_result))
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 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 ParserGetNodesXPathTestSuite(TestCase): """ """ # FIXME One of the test is not returning a proper output # FIXME 1 test not implemented def setUp(self): subnodes_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "xpath") self.subnodes_data_handler = DataHandler(subnodes_data) self.namespace = {"xs": SCHEMA_NAMESPACE} def test_not_element(self): document_schema = self.subnodes_data_handler.get_xsd("no_element") complex_type_xpath = "/xs:schema/xs:complexType" complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xpath_result = get_nodes_xpath(complex_type, document_schema) self.assertEqual(xpath_result, []) def test_imbricated_elements(self): document_schema = self.subnodes_data_handler.get_xsd("imbricated") complex_type_xpath = "/xs:schema/xs:complexType" complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] sequence_xpath = complex_type_xpath + "/xs:sequence" element_xpath = sequence_xpath + "/xs:element" element_a = document_schema.xpath(element_xpath, namespaces=self.namespace)[0] choice_element_xpath = sequence_xpath + "/xs:choice/xs:element" choice_elements = document_schema.xpath(choice_element_xpath, namespaces=self.namespace) element_b = choice_elements[0] element_c = choice_elements[1] xpath_result = get_nodes_xpath(complex_type, document_schema) expected_result = [ {"name": "a", "element": element_a}, {"name": "b", "element": element_b}, {"name": "c", "element": element_c}, ] self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath["element"] expected_elem_list = [expect["element"] for expect in expected_result if expect["name"] == xpath["name"]] expect_elem = expected_elem_list[0] if len(expected_elem_list) == 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem)) def test_element_has_name(self): document_schema = self.subnodes_data_handler.get_xsd("name") # Retrieving the needed elements sequence_xpath = "/xs:schema/xs:complexType/xs:sequence" sequence = document_schema.xpath(sequence_xpath, namespaces=self.namespace)[0] element_xpath = sequence_xpath + "/xs:element" elements = document_schema.xpath(element_xpath, namespaces=self.namespace) element_a = elements[0] element_b = elements[1] # Building resulting and expected structures xpath_result = get_nodes_xpath(sequence, document_schema) expected_result = [{"name": "a", "element": element_a}, {"name": "b", "element": element_b}] # Testing equality self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath["element"] expected_elem_list = [expect["element"] for expect in expected_result if expect["name"] == xpath["name"]] expect_elem = expected_elem_list[0] if len(expected_elem_list) == 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem)) def test_element_ref_local(self): document_schema = self.subnodes_data_handler.get_xsd("ref_local") complex_type_xpath = "/xs:schema/xs:complexType" complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] element_a_xpath = complex_type_xpath + "/xs:sequence/xs:element" element_a = document_schema.xpath(element_a_xpath, namespaces=self.namespace)[0] element_r0_xpath = "/xs:schema/xs:element" element_r0 = document_schema.xpath(element_r0_xpath, namespaces=self.namespace)[0] xpath_result = get_nodes_xpath(complex_type, document_schema) expected_result = [ {"name": "a", "element": element_a}, {"name": "r0", "element": element_r0}, {"name": "r0", "element": element_r0}, # FIXME the 2nd element shouldn't be here (not needed) ] self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath["element"] expected_elem_list = [expect["element"] for expect in expected_result if expect["name"] == xpath["name"]] # FIXME Having 2 element with the same content is not useful (>= 1 should be replaced by == 1) expect_elem = expected_elem_list[0] if len(expected_elem_list) >= 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem))
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 ParserCreateSimpleTypeTestSuite(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_create_restriction(self): 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] result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_dict = self.simple_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_dict) # result_html = etree.fromstring(result_string[0]) # expected_html = self.simple_type_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_list(self): 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] result_string = generate_simple_type(self.request, xsd_element, xsd_tree, full_path='') expected_dict = self.simple_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_dict)
class ParserGetElementTypeTestSuite(TestCase): """ """ def setUp(self): self.defaultPrefix = 'xsd' xml_element_data = join('curate', 'tests', 'data', 'parser', 'utils', 'element_type') self.xml_element_data_handler = DataHandler(xml_element_data) self.namespace = { 'xs': SCHEMA_NAMESPACE } def test_no_type_one_child_no_annot(self): xml_schema = self.xml_element_data_handler.get_xsd(join('no_type', 'one_child_no_annot')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (list(element_root)[0], xml_schema, None)) def test_no_type_one_child_annot(self): xml_schema = self.xml_element_data_handler.get_xsd(join('no_type', 'one_child_annot')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (None, xml_schema, None)) def test_no_type_two_children_annot(self): xml_schema = self.xml_element_data_handler.get_xsd(join('no_type', 'two_children_annot')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (list(element_root)[1], xml_schema, None)) def test_no_type_more_children(self): xml_schema = self.xml_element_data_handler.get_xsd(join('no_type', 'more_children')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (None, xml_schema, None)) def test_type_is_common_type(self): xml_schema = self.xml_element_data_handler.get_xsd('common_type') element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, 'xsd', '', None) self.assertEqual(element_type, (None, xml_schema, None)) def test_type_is_complex_type(self): xml_schema = self.xml_element_data_handler.get_xsd(join('complex_type')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] complex_type_xpath = '/xs:schema/xs:complexType' complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (complex_type, xml_schema, None)) def test_type_is_simple_type(self): xml_schema = self.xml_element_data_handler.get_xsd(join('simple_type')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] simple_type_xpath = '/xs:schema/xs:simpleType' simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (simple_type, xml_schema, None))
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 ParserCreateSequenceTestSuite(TestCase): """ """ def setUp(self): sequence_data = join('utils', 'XSDParser', '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} from utils.XSDParser import parser from curate.ajax import load_config parser.load_config(self.request, load_config()) def test_create_element_basic(self): xsd_files = join('element', 'basic') xsd_xpath = '/xs:schema/xs:complexType/xs:sequence' # self.parser_test_datastructures(xsd_files, self.sequence_data_handler, xsd_xpath, # self.request.session['namespaces'], # generate_sequence, self.request) xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath(xsd_xpath, namespaces=self.request.session['namespaces'])[0] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('element', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_element_unbounded(self): 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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('element', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) # def test_create_group_basic(self): # # FIXME change test and implement group support on the parser # xsd_tree = self.sequence_data_handler.get_xsd(join('group', 'basic')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # self.assertEqual(result_string, "") # # # result_html = etree.fromstring(result_string) # # expected_html = self.sequence_data_handler.get_html(join('element', 'element')) # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_create_group_unbounded(self): # xsd_tree = self.sequence_data_handler.get_xsd(join('group', 'unbounded')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # # result_html = etree.fromstring(result_string) # expected_html = self.sequence_data_handler.get_html(join('group', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('choice', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('choice', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('sequence', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('sequence', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) # def test_create_any_basic(self): # # FIXME How do we want to handle any's? # xsd_tree = self.sequence_data_handler.get_xsd(join('any', 'basic')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # self.assertEqual(result_string, '') # # def test_create_any_unbounded(self): # # FIXME How do we want to handle any's? # xsd_tree = self.sequence_data_handler.get_xsd(join('any', 'unbounded')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # # result_html = etree.fromstring(result_string) # expected_html = self.sequence_data_handler.get_html(join('any', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_multiple_basic(self): xsd_files = join('multiple', 'basic') xsd_tree = self.sequence_data_handler.get_xsd(join('multiple', 'basic')) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.sequence_data_handler.get_json(xsd_files) 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(join('multiple', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) 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 ParserGenerateFormTestSuite(TestCase): """ """ @classmethod def setUpClass(cls): super(ParserGenerateFormTestSuite, cls).setUpClass() form_data = FormData() form_data.name = 'generate_form_test' form_data.user = '******' form_data.template = 'none' form_data.save() cls.form_id = form_data.pk @classmethod def tearDownClass(cls): form_data = FormData.objects.get(pk=cls.form_id) form_data.delete() super(ParserGenerateFormTestSuite, cls).tearDownClass() def setUp(self): schema_data = join('utils', 'XSDParser', 'tests', 'data', 'parser') self.schema_data_handler = DataHandler(schema_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['curateFormData'] = self.form_id def tearDown(self): pass def test_schema_generation(self): main_directory = self.schema_data_handler.dirname main_dir_len = len(main_directory) + 1 filepath_list = [] for root, dirs, files in walk(main_directory): for filename in files: file_ext = splitext(filename) if file_ext[1] == '.xsd': full_path = join(root, file_ext[0]) filepath_list.append(full_path[main_dir_len:]) report_content = [] errors_number = 0 for filepath in filepath_list: report_line = filepath try: xsd_data = self.schema_data_handler.get_xsd(filepath) self.request.session['xmlDocTree'] = etree.tostring(xsd_data) root_pk = generate_form(self.request) if root_pk != -1: report_line += ',OK\n' else: errors_number += 1 report_line += ',NOK\n' except Exception as e: errors_number += 1 report_line += ',EXC,' + e.message + '\n' report_content.append(report_line) with open(join(SITE_ROOT, 'full_tests_report.csv'), 'w') as report_file: report_file.writelines(report_content) if errors_number != 0: self.fail(str(errors_number) + " errors detected")
class ParserGetElementTypeTestSuite(TestCase): """ """ def setUp(self): self.defaultPrefix = "xsd" xml_element_data = join("utils", "XSDParser", "tests", "data", "parser", "utils", "element_type") self.xml_element_data_handler = DataHandler(xml_element_data) self.namespace = {"xs": SCHEMA_NAMESPACE} def test_no_type_one_child_no_annot(self): xml_schema = self.xml_element_data_handler.get_xsd(join("no_type", "one_child_no_annot")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, "xs", None) self.assertEqual(element_type, (list(element_root)[0], xml_schema, None)) def test_no_type_one_child_annot(self): xml_schema = self.xml_element_data_handler.get_xsd(join("no_type", "one_child_annot")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, "xs", None) self.assertEqual(element_type, (None, xml_schema, None)) def test_no_type_two_children_annot(self): xml_schema = self.xml_element_data_handler.get_xsd(join("no_type", "two_children_annot")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, "xs", None) self.assertEqual(element_type, (list(element_root)[1], xml_schema, None)) def test_no_type_more_children(self): xml_schema = self.xml_element_data_handler.get_xsd(join("no_type", "more_children")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, "xs", None) self.assertEqual(element_type, (None, xml_schema, None)) def test_type_is_common_type(self): xml_schema = self.xml_element_data_handler.get_xsd("common_type") element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, "xsd", "", None) self.assertEqual(element_type, (None, xml_schema, None)) def test_type_is_complex_type(self): xml_schema = self.xml_element_data_handler.get_xsd(join("complex_type")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] complex_type_xpath = "/xs:schema/xs:complexType" complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, "xs", None) self.assertEqual(element_type, (complex_type, xml_schema, None)) def test_type_is_simple_type(self): xml_schema = self.xml_element_data_handler.get_xsd(join("simple_type")) element_root_xpath = "/xs:schema/xs:element" element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] simple_type_xpath = "/xs:schema/xs:simpleType" simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, "xs", None) self.assertEqual(element_type, (simple_type, xml_schema, None))
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 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 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 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 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 ParserCreateChoiceTestSuite(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_create_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] result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.choice_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_element_unbounded(self): 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] result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.choice_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME group test are not good since it is not supported by the parser # def test_create_group_basic(self): # xsd_files = join('group', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # # result_html = etree.fromstring(result_string) # expected_html = self.choice_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_create_group_unbounded(self): # xsd_files = join('group', 'unbounded') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # # result_html = etree.fromstring(result_string) # expected_html = self.choice_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME choice test are not good since it is not supported by the parser # def test_create_choice_basic(self): # xsd_files = join('choice', 'basic') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # # result_html = etree.fromstring(result_string) # expected_html = self.choice_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_create_choice_unbounded(self): # xsd_files = join('choice', 'unbounded') # xsd_tree = self.choice_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType/choice')[0] # # result_string = generate_choice(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # # result_html = etree.fromstring(result_string) # expected_html = self.choice_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_sequence_basic(self): # FIXME Not working 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] result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.choice_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.choice_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_sequence_unbounded(self): # FIXME Not working 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] result_string = generate_choice(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.choice_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element)
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 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 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 ParserGenerateFormTestSuite(TestCase): """ """ @classmethod def setUpClass(cls): super(ParserGenerateFormTestSuite, cls).setUpClass() form_data = FormData() form_data.name = 'generate_form_test' form_data.user = '******' form_data.template = 'none' form_data.save() cls.form_id = form_data.pk @classmethod def tearDownClass(cls): form_data = FormData.objects.get(pk=cls.form_id) form_data.delete() super(ParserGenerateFormTestSuite, cls).tearDownClass() def setUp(self): schema_data = join('curate', 'tests', 'data', 'parser') self.schema_data_handler = DataHandler(schema_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['curateFormData'] = self.form_id def tearDown(self): pass def test_schema_generation(self): main_directory = self.schema_data_handler.dirname main_dir_len = len(main_directory) + 1 filepath_list = [] for root, dirs, files in walk(main_directory): for filename in files: file_ext = splitext(filename) if file_ext[1] == '.xsd': full_path = join(root, file_ext[0]) filepath_list.append(full_path[main_dir_len:]) report_content = [] errors_number = 0 for filepath in filepath_list: report_line = filepath try: xsd_data = self.schema_data_handler.get_xsd(filepath) self.request.session['xmlDocTree'] = etree.tostring(xsd_data) root_pk = generate_form(self.request) if root_pk != -1: report_line += ',OK\n' else: errors_number += 1 report_line += ',NOK\n' except Exception as e: errors_number += 1 report_line += ',EXC,' + e.message + '\n' report_content.append(report_line) with open(join(SITE_ROOT, 'full_tests_report.csv'), 'w') as report_file: report_file.writelines(report_content) if errors_number != 0: self.fail(str(errors_number) + " errors detected")
class ParserCreateComplexTypeTestSuite(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_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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[1]', namespaces=self.request.session['namespaces'])[0] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # self.assertEqual(result_string[0], '') # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME group not supported # def test_create_group(self): # xsd_files = join('group', '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] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # print result_string # self.assertEqual(result_string[0], '') # # expected_element = { # 'tag': 'complex_type', # 'occurs': (1, 1, 1), # 'module': None, # 'value': None, # 'children': [] # } # # self.assertDictEqual(result_string[1], expected_element) # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME all is not suported # def test_create_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] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME attributeGroup not supported # def test_create_attribute_group(self): # xsd_files = join('attribute_group', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # self.assertEqual(result_string, '') # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME anyAttribute not supported # def test_create_any_attribute(self): # xsd_files = join('any_attribute', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # self.assertEqual(result_string, '') # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_multiple(self): 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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.complex_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element)
class ParserCreateComplexTypeTestSuite(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_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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[1]', namespaces=self.request.session['namespaces'])[0] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # self.assertEqual(result_string[0], '') # result_string = '<div>' + result_string[0] + '</div>' # result_html = etree.fromstring(result_string) # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME group not supported # def test_create_group(self): # xsd_files = join('group', '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] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # print result_string # self.assertEqual(result_string[0], '') # # expected_element = { # 'tag': 'complex_type', # 'occurs': (1, 1, 1), # 'module': None, # 'value': None, # 'children': [] # } # # self.assertDictEqual(result_string[1], expected_element) # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME all is not suported # def test_create_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] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.complex_type_data_handler.get_json(xsd_files) 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) # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME attributeGroup not supported # def test_create_attribute_group(self): # xsd_files = join('attribute_group', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # self.assertEqual(result_string, '') # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # # # self.assertTrue(are_equals(result_html, expected_html)) # FIXME anyAttribute not supported # def test_create_any_attribute(self): # xsd_files = join('any_attribute', 'basic') # xsd_tree = self.complex_type_data_handler.get_xsd(xsd_files) # xsd_element = xsd_tree.xpath('/schema/complexType')[0] # # result_string = generate_complex_type(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # self.assertEqual(result_string, '') # # # result_html = etree.fromstring(result_string) # # expected_html = self.complex_type_data_handler.get_html(xsd_files) # # # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_multiple(self): 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] result_string = generate_complex_type(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.complex_type_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element)
class ParserCreateSequenceTestSuite(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_create_element_basic(self): xsd_files = join('element', 'basic') xsd_xpath = '/xs:schema/xs:complexType/xs:sequence' # self.parser_test_datastructures(xsd_files, self.sequence_data_handler, xsd_xpath, # self.request.session['namespaces'], # generate_sequence, self.request) xsd_tree = self.sequence_data_handler.get_xsd(xsd_files) xsd_element = xsd_tree.xpath(xsd_xpath, namespaces=self.request.session['namespaces'])[0] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('element', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_element_unbounded(self): 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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('element', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) # def test_create_group_basic(self): # # FIXME change test and implement group support on the parser # xsd_tree = self.sequence_data_handler.get_xsd(join('group', 'basic')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # self.assertEqual(result_string, "") # # # result_html = etree.fromstring(result_string) # # expected_html = self.sequence_data_handler.get_html(join('element', 'element')) # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_create_group_unbounded(self): # xsd_tree = self.sequence_data_handler.get_xsd(join('group', 'unbounded')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # # result_html = etree.fromstring(result_string) # expected_html = self.sequence_data_handler.get_html(join('group', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('choice', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('choice', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('sequence', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element) # result_html = etree.fromstring(result_string[0]) # expected_html = self.sequence_data_handler.get_html(join('sequence', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) # def test_create_any_basic(self): # # FIXME How do we want to handle any's? # xsd_tree = self.sequence_data_handler.get_xsd(join('any', 'basic')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # self.assertEqual(result_string, '') # # def test_create_any_unbounded(self): # # FIXME How do we want to handle any's? # xsd_tree = self.sequence_data_handler.get_xsd(join('any', 'unbounded')) # xsd_element = xsd_tree.xpath('/schema/complexType/sequence')[0] # # result_string = generate_sequence(self.request, xsd_element, xsd_tree, '', full_path='') # # print result_string # # result_html = etree.fromstring(result_string) # expected_html = self.sequence_data_handler.get_html(join('any', 'unbounded')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_multiple_basic(self): xsd_files = join('multiple', 'basic') xsd_tree = self.sequence_data_handler.get_xsd(join('multiple', 'basic')) xsd_element = xsd_tree.xpath('/xs:schema/xs:complexType/xs:sequence', namespaces=self.request.session['namespaces'])[0] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') expected_element = self.sequence_data_handler.get_json(xsd_files) 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(join('multiple', 'basic')) # # self.assertTrue(are_equals(result_html, expected_html)) def test_create_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] result_string = generate_sequence(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_element = self.sequence_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_element)
class ParserGetNodesXPathTestSuite(TestCase): """ """ # FIXME One of the test is not returning a proper output # FIXME 1 test not implemented def setUp(self): subnodes_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'utils', 'xpath') self.subnodes_data_handler = DataHandler(subnodes_data) self.namespace = {'xs': SCHEMA_NAMESPACE} def test_not_element(self): document_schema = self.subnodes_data_handler.get_xsd('no_element') complex_type_xpath = '/xs:schema/xs:complexType' complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xpath_result = get_nodes_xpath(complex_type, document_schema) self.assertEqual(xpath_result, []) def test_imbricated_elements(self): document_schema = self.subnodes_data_handler.get_xsd('imbricated') complex_type_xpath = '/xs:schema/xs:complexType' complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] sequence_xpath = complex_type_xpath + '/xs:sequence' element_xpath = sequence_xpath + '/xs:element' element_a = document_schema.xpath(element_xpath, namespaces=self.namespace)[0] choice_element_xpath = sequence_xpath + '/xs:choice/xs:element' choice_elements = document_schema.xpath(choice_element_xpath, namespaces=self.namespace) element_b = choice_elements[0] element_c = choice_elements[1] xpath_result = get_nodes_xpath(complex_type, document_schema) expected_result = [ { 'name': 'a', 'element': element_a }, { 'name': 'b', 'element': element_b }, { 'name': 'c', 'element': element_c }, ] self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath['element'] expected_elem_list = [ expect['element'] for expect in expected_result if expect['name'] == xpath['name'] ] expect_elem = expected_elem_list[0] if len( expected_elem_list) == 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem)) def test_element_has_name(self): document_schema = self.subnodes_data_handler.get_xsd('name') # Retrieving the needed elements sequence_xpath = '/xs:schema/xs:complexType/xs:sequence' sequence = document_schema.xpath(sequence_xpath, namespaces=self.namespace)[0] element_xpath = sequence_xpath + '/xs:element' elements = document_schema.xpath(element_xpath, namespaces=self.namespace) element_a = elements[0] element_b = elements[1] # Building resulting and expected structures xpath_result = get_nodes_xpath(sequence, document_schema) expected_result = [{ 'name': 'a', 'element': element_a }, { 'name': 'b', 'element': element_b }] # Testing equality self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath['element'] expected_elem_list = [ expect['element'] for expect in expected_result if expect['name'] == xpath['name'] ] expect_elem = expected_elem_list[0] if len( expected_elem_list) == 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem)) def test_element_ref_local(self): document_schema = self.subnodes_data_handler.get_xsd('ref_local') complex_type_xpath = '/xs:schema/xs:complexType' complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] element_a_xpath = complex_type_xpath + '/xs:sequence/xs:element' element_a = document_schema.xpath(element_a_xpath, namespaces=self.namespace)[0] element_r0_xpath = '/xs:schema/xs:element' element_r0 = document_schema.xpath(element_r0_xpath, namespaces=self.namespace)[0] xpath_result = get_nodes_xpath(complex_type, document_schema) expected_result = [ { 'name': 'a', 'element': element_a }, { 'name': 'r0', 'element': element_r0 }, { # FIXME the 2nd element shouldn't be here (not needed) 'name': 'r0', 'element': element_r0 } ] self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath['element'] expected_elem_list = [ expect['element'] for expect in expected_result if expect['name'] == xpath['name'] ] # FIXME Having 2 element with the same content is not useful (>= 1 should be replaced by == 1) expect_elem = expected_elem_list[0] if len( expected_elem_list) >= 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem))
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 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 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 ParserGetNodesXPathTestSuite(TestCase): """ """ # FIXME One of the test is not returning a proper output # FIXME 1 test not implemented def setUp(self): subnodes_data = join('curate', 'tests', 'data', 'parser', 'utils', 'xpath') self.subnodes_data_handler = DataHandler(subnodes_data) self.namespace = { 'xs': SCHEMA_NAMESPACE } def test_not_element(self): document_schema = self.subnodes_data_handler.get_xsd('no_element') complex_type_xpath = '/xs:schema/xs:complexType' complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] xpath_result = get_nodes_xpath(complex_type, document_schema) self.assertEqual(xpath_result, []) def test_imbricated_elements(self): document_schema = self.subnodes_data_handler.get_xsd('imbricated') complex_type_xpath = '/xs:schema/xs:complexType' complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] sequence_xpath = complex_type_xpath + '/xs:sequence' element_xpath = sequence_xpath + '/xs:element' element_a = document_schema.xpath(element_xpath, namespaces=self.namespace)[0] choice_element_xpath = sequence_xpath + '/xs:choice/xs:element' choice_elements = document_schema.xpath(choice_element_xpath, namespaces=self.namespace) element_b = choice_elements[0] element_c = choice_elements[1] xpath_result = get_nodes_xpath(complex_type, document_schema) expected_result = [ { 'name': 'a', 'element': element_a }, { 'name': 'b', 'element': element_b }, { 'name': 'c', 'element': element_c }, ] self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath['element'] expected_elem_list = [expect['element'] for expect in expected_result if expect['name'] == xpath['name']] expect_elem = expected_elem_list[0] if len(expected_elem_list) == 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem)) def test_element_has_name(self): document_schema = self.subnodes_data_handler.get_xsd('name') # Retrieving the needed elements sequence_xpath = '/xs:schema/xs:complexType/xs:sequence' sequence = document_schema.xpath(sequence_xpath, namespaces=self.namespace)[0] element_xpath = sequence_xpath + '/xs:element' elements = document_schema.xpath(element_xpath, namespaces=self.namespace) element_a = elements[0] element_b = elements[1] # Building resulting and expected structures xpath_result = get_nodes_xpath(sequence, document_schema) expected_result = [ { 'name': 'a', 'element': element_a }, { 'name': 'b', 'element': element_b } ] # Testing equality self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath['element'] expected_elem_list = [expect['element'] for expect in expected_result if expect['name'] == xpath['name']] expect_elem = expected_elem_list[0] if len(expected_elem_list) == 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem)) def test_element_ref_local(self): document_schema = self.subnodes_data_handler.get_xsd('ref_local') complex_type_xpath = '/xs:schema/xs:complexType' complex_type = document_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] element_a_xpath = complex_type_xpath + '/xs:sequence/xs:element' element_a = document_schema.xpath(element_a_xpath, namespaces=self.namespace)[0] element_r0_xpath = '/xs:schema/xs:element' element_r0 = document_schema.xpath(element_r0_xpath, namespaces=self.namespace)[0] xpath_result = get_nodes_xpath(complex_type, document_schema) expected_result = [ { 'name': 'a', 'element': element_a }, { 'name': 'r0', 'element': element_r0 }, { # FIXME the 2nd element shouldn't be here (not needed) 'name': 'r0', 'element': element_r0 } ] self.assertEqual(len(xpath_result), len(expected_result)) for xpath in xpath_result: xpath_elem = xpath['element'] expected_elem_list = [expect['element'] for expect in expected_result if expect['name'] == xpath['name']] # FIXME Having 2 element with the same content is not useful (>= 1 should be replaced by == 1) expect_elem = expected_elem_list[0] if len(expected_elem_list) >= 1 else None self.assertTrue(are_equals(xpath_elem, expect_elem))
class ParserCreateExtensionTestSuite(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() store['curate_edit'] = False # 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.client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key self.request = HttpRequest() self.request.session = self.session # def test_create_group(self): # xsd_files = join('group', '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] # # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # print result_string # # 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) # # self.assertTrue(are_equals(result_html, expected_html)) # def test_create_all(self): # xsd_files = join('all', '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] # # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # print result_string # # expected_dict = self.extension_data_handler.get_json(xsd_files) # # 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) # # 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] result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='') expected_dict = self.extension_data_handler.get_json(xsd_files) 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] self.session['keys'] = {} self.session.save() self.request.session = self.session result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_dict = self.extension_data_handler.get_json(xsd_files) 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] self.session['keys'] = {} self.session['keyrefs'] = {} self.session.save() self.request.session = self.session result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='') # print result_string expected_dict = self.extension_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_dict) # def test_create_attribute_group(self): # xsd_files = join('attribute_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:simpleContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # print result_string # # 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) # # # # self.assertTrue(are_equals(result_html, expected_html)) # # def test_create_any_attribute(self): # xsd_files = join('any_attribute', '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:simpleContent/xs:extension', # namespaces=self.request.session['namespaces'])[0] # # result_string = generate_extension(self.request, xsd_element, xsd_tree, self.namespace, full_path='') # # print result_string # # 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) # # # # 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.session['namespaces'])[0] result_string = generate_extension(self.request, xsd_element, xsd_tree, full_path='') expected_dict = self.extension_data_handler.get_json(xsd_files) self.assertDictEqual(result_string[1], expected_dict)
class ParserGetElementTypeTestSuite(TestCase): """ """ def setUp(self): self.defaultPrefix = 'xsd' xml_element_data = join('utils', 'XSDParser', 'tests', 'data', 'parser', 'utils', 'element_type') self.xml_element_data_handler = DataHandler(xml_element_data) self.namespace = {'xs': SCHEMA_NAMESPACE} def test_no_type_one_child_no_annot(self): xml_schema = self.xml_element_data_handler.get_xsd( join('no_type', 'one_child_no_annot')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (list(element_root)[0], xml_schema, None)) def test_no_type_one_child_annot(self): xml_schema = self.xml_element_data_handler.get_xsd( join('no_type', 'one_child_annot')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (None, xml_schema, None)) def test_no_type_two_children_annot(self): xml_schema = self.xml_element_data_handler.get_xsd( join('no_type', 'two_children_annot')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (list(element_root)[1], xml_schema, None)) def test_no_type_more_children(self): xml_schema = self.xml_element_data_handler.get_xsd( join('no_type', 'more_children')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (list(element_root)[1], xml_schema, None)) def test_type_is_common_type(self): xml_schema = self.xml_element_data_handler.get_xsd('common_type') element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, 'xsd', '', None) self.assertEqual(element_type, (None, xml_schema, None)) def test_type_is_complex_type(self): xml_schema = self.xml_element_data_handler.get_xsd( join('complex_type')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] complex_type_xpath = '/xs:schema/xs:complexType' complex_type = xml_schema.xpath(complex_type_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (complex_type, xml_schema, None)) def test_type_is_simple_type(self): xml_schema = self.xml_element_data_handler.get_xsd(join('simple_type')) element_root_xpath = '/xs:schema/xs:element' element_root = xml_schema.xpath(element_root_xpath, namespaces=self.namespace)[0] simple_type_xpath = '/xs:schema/xs:simpleType' simple_type = xml_schema.xpath(simple_type_xpath, namespaces=self.namespace)[0] element_type = get_element_type(element_root, xml_schema, self.namespace, 'xs', None) self.assertEqual(element_type, (simple_type, xml_schema, None))
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)