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)
def setUp(self):
input_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer',
'default', 'input')
self.input_data_handler = DataHandler(input_data)
self.types_generator = VariableTypesGenerator()
self.renderer = HtmlRenderer()
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)
def setUp(self):
input_data = join('curate', 'tests', 'data', 'renderer', 'html',
'input')
self.input_data_handler = DataHandler(input_data)
self.types_generator = VariableTypesGenerator()
self.renderer = HtmlRenderer()
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))
def setUp(self):
extension_data = join('utils', 'XSDParser', '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
from utils.XSDParser import parser
from curate.ajax import load_config
parser.load_config(self.request, load_config())
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
}
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))
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 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]
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)
def setUp(self):
ul_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer',
'default', 'ul')
self.ul_data_handler = DataHandler(ul_data)
self.types_generator = VariableTypesGenerator()
self.content = '<li>lorem ipsum</li>'
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 setUp(self):
subnodes_data = join('curate', 'tests', 'data', 'parser', 'utils', 'xpath')
self.subnodes_data_handler = DataHandler(subnodes_data)
self.namespace = {
'xs': SCHEMA_NAMESPACE
}
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 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 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
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)
def setUp(self):
buttons_data = join('curate', 'tests', 'data', 'parser', 'utils', 'buttons')
self.buttons_data_handler = DataHandler(buttons_data)
self.types_generator = VariableTypesGenerator()
self.default_tag_id = 'string'
self.renderer = HtmlRenderer()
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 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)
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)
def setUp(self):
select_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer', 'default', 'select')
self.select_data_handler = DataHandler(select_data)
self.types_generator = VariableTypesGenerator()
self.select_id = 'select'
self.select_class = 'select'
self.renderer = HtmlRenderer()
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)
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 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]
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 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)
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 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 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 setUp(self):
choice_data = join("utils", "XSDParser", "tests", "data", "parser", "choice")
self.choice_data_handler = DataHandler(choice_data)
self.maxDiff = None
self.request = HttpRequest()
engine = import_module("django.contrib.sessions.backends.db")
session_key = None
self.request.session = engine.SessionStore(session_key)
self.request.session["curate_edit"] = False # Data edition
self.request.session["nb_html_tags"] = 0
self.request.session["mapTagID"] = {}
self.request.session["nbChoicesID"] = 0
# set default namespace
namespace = "http://www.w3.org/2001/XMLSchema"
self.namespace = "{" + namespace + "}"
self.request.session["defaultPrefix"] = "xs"
self.request.session["namespaces"] = {"xs": namespace}
from utils.XSDParser import parser
from curate.ajax import load_config
parser.load_config(self.request, load_config())
def 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 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 setUp(self):
extension_data = join('utils', 'XSDParser', '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
from utils.XSDParser import parser
from curate.ajax import load_config
parser.load_config(self.request, load_config())
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 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 setUp(self):
li_data = join('curate', 'tests', 'data', 'renderer', 'default', 'li')
self.li_data_handler = DataHandler(li_data)
self.types_generator = VariableTypesGenerator()
self.content = 'lorem ipsum'
self.tag_id = '0'
self.element_tag = 'element'
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 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)
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
form_data = FormData()
form_data.name = ''
form_data.user = ''
form_data.template = ''
form_data.save()
self.request.session['curateFormData'] = form_data.pk
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 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 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'] = 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
