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