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