def test_template_list_is_correct_dict(self): template_list = { "t1": Template('a'), "t2": Template('b'), "t3": Template('c') } base_renderer = HtmlRenderer() base_renderer.templates.update(template_list) base_keys = base_renderer.templates.keys() base_keys.sort() renderer = HtmlRenderer(template_list) renderer_keys = renderer.templates.keys() renderer_keys.sort() self.assertEqual(renderer_keys, base_keys) for key in base_keys: self.assertEqual( base_renderer._load_template(key), renderer._load_template(key) )
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()
def setUp(self): buttons_data = join('utils', 'XSDParser', '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): 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()
def test_template_list_is_incorrect_dict(self): template = None try: for template in self.type_generator.generate_types_excluding([]): template_list = {"wrong": template} with self.assertRaises(Exception): renderer = HtmlRenderer(template_list) renderer._load_template("wrong") except AssertionError as error: template_type = str(type(template)) error.message += ' (template type: ' + template_type + ')' raise AssertionError(error.message)
def test_template_list_is_incorrect_dict(self): template = None try: for template in self.type_generator.generate_types_excluding([]): template_list = { "wrong": template } with self.assertRaises(Exception): renderer = HtmlRenderer(template_list) renderer._load_template("wrong") except AssertionError as error: template_type = str(type(template)) error.message += ' (template type: ' + template_type + ')' raise AssertionError(error.message)
class RenderFormErrorTestSuite(TestCase): def setUp(self): form_error_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer', 'default') self.form_error_data_handler = DataHandler(form_error_data) self.types_generator = VariableTypesGenerator() self.renderer = HtmlRenderer() def test_message_str(self): form_error_message = 'Sample error message' result_string = self.renderer._render_form_error(form_error_message) self.assertEqual(result_string, self.renderer._render_form_error(unicode(form_error_message))) result_html = etree.fromstring(result_string) expected_html = self.form_error_data_handler.get_html('form_error') self.assertTrue(are_equals(result_html, expected_html))
def test_template_list_not_dict(self): template_list = None try: for template_list in self.type_generator.generate_types_excluding( ['dict', 'none']): with self.assertRaises(Exception): HtmlRenderer(template_list) except AssertionError as error: template_list_type = str(type(template_list)) error.message += ' (template_list type: ' + template_list_type + ')' raise AssertionError(error.message)
def test_template_list_not_set(self): renderer = HtmlRenderer() expected_template_keys = [ 'form_error', 'warning', 'input', 'select', 'btn_add', 'btn_del', 'btn_collapse', ] self.assertEqual(len(renderer.templates), len(expected_template_keys)) for key in renderer.templates.keys(): self.assertIn(key, expected_template_keys)
class RendererRenderCollapseButtonTestSuite(TestCase): """ """ def setUp(self): collapse_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer', 'default') self.collapse_data_handler = DataHandler(collapse_data) self.renderer = HtmlRenderer() def test_button(self): result_string = self.renderer._render_collapse_button() result_html = etree.fromstring(result_string) expected_html = self.collapse_data_handler.get_html('collapse') self.assertTrue(are_equals(result_html, expected_html))
def test_template_list_is_correct_dict(self): template_list = { "t1": Template('a'), "t2": Template('b'), "t3": Template('c') } base_renderer = HtmlRenderer() base_renderer.templates.update(template_list) base_keys = base_renderer.templates.keys() base_keys.sort() renderer = HtmlRenderer(template_list) renderer_keys = renderer.templates.keys() renderer_keys.sort() self.assertEqual(renderer_keys, base_keys) for key in base_keys: self.assertEqual(base_renderer._load_template(key), renderer._load_template(key))
class RendererRenderSelectTestSuite(TestCase): 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() def test_id_str_options_list(self): options = [('opt1', 'opt1', False), ('opt2', 'opt2', False), ('opt3', 'opt3', True)] result_string = self.renderer._render_select(self.select_id, self.select_class, options) self.assertEqual( result_string, self.renderer._render_select(unicode(self.select_id), self.select_class, options)) result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html( 'id_str_options_list') self.assertTrue(are_equals(result_html, expected_html)) def test_id_str_options_empty_list(self): options = [] result_string = self.renderer._render_select(self.select_id, self.select_class, options) self.assertEqual( result_string, self.renderer._render_select(unicode(self.select_id), self.select_class, options)) result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html( 'id_str_options_empty') self.assertTrue(are_equals(result_html, expected_html)) def test_id_none_options_list(self): options = [('opt1', 'opt1', False), ('opt2', 'opt2', False), ('opt3', 'opt3', True)] result_string = self.renderer._render_select(None, self.select_class, options) self.assertEqual( result_string, self.renderer._render_select(None, self.select_class, options)) # print result_string result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html( 'id_none_options_list') self.assertTrue(are_equals(result_html, expected_html)) def test_id_none_options_empty_list(self): options = [] result_string = self.renderer._render_select(None, self.select_class, options) self.assertEqual( result_string, self.renderer._render_select(None, self.select_class, options)) # print result_string result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html( 'id_none_options_empty') self.assertTrue(are_equals(result_html, expected_html)) # def test_id_not_str_not_none(self): # element_id = 'string' # # try: # for element_id in self.types_generator.generate_types_excluding(['str', 'unicode', 'none']): # with self.assertRaises(Exception): # self.renderer._render_select(element_id, self.select_class, []) # except AssertionError as error: # element_id_type = str(type(element_id)) # error.message += ' (element_id type: ' + element_id_type + ')' # raise AssertionError(error.message) # def test_options_not_list(self): # options = [] # # try: # for options in self.types_generator.generate_types_excluding(['list']): # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # except AssertionError as error: # options_type = str(type(options)) # error.message += ' (options type: ' + options_type + ')' # raise AssertionError(error.message) # def test_options_not_list_of_tuple(self): # options = [()] # # try: # for item in self.types_generator.generate_types_excluding(['tuple']): # options[0] = item # # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # except AssertionError as error: # item_type = str(type(options[0])) # error.message += ' (item type: ' + item_type + ')' # raise AssertionError(error.message) # def test_options_malformed_list(self): # options = [()] # # try: # for param in self.types_generator.generate_types_excluding(['str', 'unicode']): # options[0] = (param, '', False) # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # # options[0] = ('', param, False) # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # # for param in self.types_generator.generate_types_excluding(['bool']): # options[0] = ('', '', param) # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, [('elem0', 'elem1')]) # except AssertionError as error: # error.message += ' (option not considered as malformed: ' + str(options) + ')' # raise AssertionError(error.message) # FIXME New version (merge with up) def test_select_id_is_db_elem(self): pass def test_select_id_not_db_element(self): pass def test_select_id_not_str(self): pass def test_select_class_is_str(self): pass def test_select_class_is_not_str(self): pass def test_options_list_is_list_with_good_tuples(self): pass def test_options_list_is_list_with_bad_tuples(self): pass def test_options_list_is_list_without_tuples(self): pass def test_options_list_is_not_list(self): pass
def setUp(self): collapse_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer', 'default') self.collapse_data_handler = DataHandler(collapse_data) self.renderer = HtmlRenderer()
class RenderInputTestSuite(TestCase): 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() def test_input_placeholder_str(self): input_element = create_mock_db_input(placeholder='string') result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) # expected_html = self.input_data_handler.get_html('placeholder') expected_html = self.input_data_handler.get_html( 'val_empty_pl_str_tt_empty') self.assertTrue(are_equals(result_html, expected_html)) # def test_input_placeholder_not_str(self): # placeholder = None # # try: # for placeholder in self.types_generator.generate_types_excluding(['str', 'unicode']): # input_element = create_mock_db_input( # placeholder=placeholder # ) # # with self.assertRaises(Exception): # self.renderer._render_input(input_element) # except AssertionError as error: # placeholder_type = str(type(placeholder)) # error.message += ' (title type: ' + placeholder_type + ')' # raise AssertionError(error.message) def test_input_title_str(self): input_element = create_mock_db_input(title='string') result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) expected_html = self.input_data_handler.get_html( 'val_empty_pl_empty_tt_str') self.assertTrue(are_equals(result_html, expected_html)) # def test_input_title_not_str(self): # title = None # # try: # for title in self.types_generator.generate_types_excluding(['str', 'unicode']): # with self.assertRaises(Exception): # input_element = create_mock_db_input( # title=title # ) # # self.renderer._render_input(input_element) # except AssertionError as error: # title_type = str(type(title)) # error.message += ' (title type: ' + title_type + ')' # raise AssertionError(error.message) def test_input_value_str(self): input_element = create_mock_db_input(value="string") result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) expected_html = self.input_data_handler.get_html( 'val_str_pl_empty_tt_empty') self.assertTrue(are_equals(result_html, expected_html)) def test_input_value_none(self): input_element = create_mock_db_input(value=None) result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) expected_html = self.input_data_handler.get_html( 'val_empty_pl_empty_tt_empty') self.assertTrue(are_equals(result_html, expected_html)) def test_input_not_schema_element(self): input_element = SchemaElement() try: for input_element in self.types_generator.possible_types: with self.assertRaises(TypeError): self.renderer._render_input(input_element) except AssertionError as error: input_type = str(type(input_element)) error.message += ' (input type: ' + input_type + ')' raise AssertionError(error.message)
def setUp(self): form_error_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer', 'default') self.form_error_data_handler = DataHandler(form_error_data) self.types_generator = VariableTypesGenerator() self.renderer = HtmlRenderer()
class RendererRenderButtonsTestSuite(TestCase): """ render_buttons test suite """ def setUp(self): buttons_data = join('utils', 'XSDParser', '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 _expected_form(self, is_add_present, is_del_present): add_tpl_name = "add_shown" if is_add_present else "add_hidden" del_tpl_name = "remove_shown" if is_del_present else "remove_hidden" add_html = self.buttons_data_handler.get_html(add_tpl_name) del_html = self.buttons_data_handler.get_html(del_tpl_name) span = etree.Element('span') span.append(add_html) span.append(del_html) return span def test_add_del_false(self): is_add_present = False is_del_present = False form = self.renderer._render_buttons(is_add_present, is_del_present) self.assertEqual(form, "") def test_add_true_del_false(self): is_add_present = True is_del_present = False # form_string = self.renderer._render_buttons(is_add_present, is_del_present, self.default_tag_id) form_string = self.renderer._render_buttons(is_add_present, is_del_present) form = etree.fromstring('<span>' + form_string + '</span>') expected_form = self._expected_form(is_add_present, is_del_present) # expected_form_wrapped = '<span>' + self.addButtonPresent + self.delButtonHidden + '</span>' self.assertTrue( are_equals(form, expected_form) # self._xmlStringAreEquals(form_wrapped, expected_form_wrapped) ) def test_add_del_true(self): is_add_present = True is_del_present = True # form_string = render_buttons(is_add_present, is_del_present, self.default_tag_id) form_string = self.renderer._render_buttons(is_add_present, is_del_present) # form_wrapped = '<span>' + form + '</span>' form = etree.fromstring('<span>' + form_string + '</span>') expected_form = self._expected_form(is_add_present, is_del_present) # expected_form_wrapped = '<span>' + self.addButtonPresent + self.delButtonPresent + '</span>' self.assertTrue( are_equals(form, expected_form) ) def test_add_false_del_true(self): is_add_present = False is_del_present = True # form_string = render_buttons(is_add_present, is_del_present, self.default_tag_id) form_string = self.renderer._render_buttons(is_add_present, is_del_present) # form_wrapped = '<span>' + form + '</span>' form = etree.fromstring('<span>' + form_string + '</span>') expected_form = self._expected_form(is_add_present, is_del_present) # expected_form_wrapped = '<span>' + self.addButtonHidden + self.delButtonPresent + '</span>' self.assertTrue( are_equals(form, expected_form) # self._xmlStringAreEquals(form_wrapped, expected_form_wrapped) ) def test_add_button_not_bool(self): is_add_present = True try: for is_add_present in self.types_generator.generate_types_excluding(['bool']): with self.assertRaises(Exception): # render_buttons(is_add_present, True, self.default_tag_id) self.renderer._render_buttons(is_add_present, True) except AssertionError as error: is_add_present_type = str(type(is_add_present)) error.message += ' (is_add_present type: ' + is_add_present_type + ')' raise AssertionError(error.message) def test_del_button_not_bool(self): is_del_present = True try: for is_del_present in self.types_generator.generate_types_excluding(['bool']): with self.assertRaises(Exception): # render_buttons(True, is_del_present, self.default_tag_id) self.renderer._render_buttons(True, is_del_present) except AssertionError as error: is_del_present_type = str(type(is_del_present)) error.message += ' (is_del_present type: ' + is_del_present_type + ')' raise AssertionError(error.message) def test_tag_id_not_str(self): for tag_id in self.types_generator.generate_types_excluding(['str']): for is_add_present in [True, False]: for is_del_present in [True, False]: try: # render_buttons(is_add_present, is_del_present, tag_id) self.renderer._render_buttons(is_add_present, is_del_present) except Exception as exc: tag_id_type = str(type(tag_id)) self.fail('Unexpected exception raised with tag_id of type ' + tag_id_type + ':' + exc.message)
def create_mock_html_renderer(): element = SchemaElement() element.tag = "mock" return HtmlRenderer(element)
class RendererRenderButtonsTestSuite(TestCase): """ render_buttons test suite """ def setUp(self): buttons_data = join('utils', 'XSDParser', '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 _expected_form(self, is_add_present, is_del_present): add_tpl_name = "add_shown" if is_add_present else "add_hidden" del_tpl_name = "remove_shown" if is_del_present else "remove_hidden" add_html = self.buttons_data_handler.get_html(add_tpl_name) del_html = self.buttons_data_handler.get_html(del_tpl_name) span = etree.Element('span') span.append(add_html) span.append(del_html) return span def test_add_del_false(self): is_add_present = False is_del_present = False form = self.renderer._render_buttons(is_add_present, is_del_present) self.assertEqual(form, "") def test_add_true_del_false(self): is_add_present = True is_del_present = False # form_string = self.renderer._render_buttons(is_add_present, is_del_present, self.default_tag_id) form_string = self.renderer._render_buttons(is_add_present, is_del_present) form = etree.fromstring('<span>' + form_string + '</span>') expected_form = self._expected_form(is_add_present, is_del_present) # expected_form_wrapped = '<span>' + self.addButtonPresent + self.delButtonHidden + '</span>' self.assertTrue( are_equals(form, expected_form) # self._xmlStringAreEquals(form_wrapped, expected_form_wrapped) ) def test_add_del_true(self): is_add_present = True is_del_present = True # form_string = render_buttons(is_add_present, is_del_present, self.default_tag_id) form_string = self.renderer._render_buttons(is_add_present, is_del_present) # form_wrapped = '<span>' + form + '</span>' form = etree.fromstring('<span>' + form_string + '</span>') expected_form = self._expected_form(is_add_present, is_del_present) # expected_form_wrapped = '<span>' + self.addButtonPresent + self.delButtonPresent + '</span>' self.assertTrue(are_equals(form, expected_form)) def test_add_false_del_true(self): is_add_present = False is_del_present = True # form_string = render_buttons(is_add_present, is_del_present, self.default_tag_id) form_string = self.renderer._render_buttons(is_add_present, is_del_present) # form_wrapped = '<span>' + form + '</span>' form = etree.fromstring('<span>' + form_string + '</span>') expected_form = self._expected_form(is_add_present, is_del_present) # expected_form_wrapped = '<span>' + self.addButtonHidden + self.delButtonPresent + '</span>' self.assertTrue( are_equals(form, expected_form) # self._xmlStringAreEquals(form_wrapped, expected_form_wrapped) ) def test_add_button_not_bool(self): is_add_present = True try: for is_add_present in self.types_generator.generate_types_excluding( ['bool']): with self.assertRaises(Exception): # render_buttons(is_add_present, True, self.default_tag_id) self.renderer._render_buttons(is_add_present, True) except AssertionError as error: is_add_present_type = str(type(is_add_present)) error.message += ' (is_add_present type: ' + is_add_present_type + ')' raise AssertionError(error.message) def test_del_button_not_bool(self): is_del_present = True try: for is_del_present in self.types_generator.generate_types_excluding( ['bool']): with self.assertRaises(Exception): # render_buttons(True, is_del_present, self.default_tag_id) self.renderer._render_buttons(True, is_del_present) except AssertionError as error: is_del_present_type = str(type(is_del_present)) error.message += ' (is_del_present type: ' + is_del_present_type + ')' raise AssertionError(error.message) def test_tag_id_not_str(self): for tag_id in self.types_generator.generate_types_excluding(['str']): for is_add_present in [True, False]: for is_del_present in [True, False]: try: # render_buttons(is_add_present, is_del_present, tag_id) self.renderer._render_buttons(is_add_present, is_del_present) except Exception as exc: tag_id_type = str(type(tag_id)) self.fail( 'Unexpected exception raised with tag_id of type ' + tag_id_type + ':' + exc.message)
class RenderInputTestSuite(TestCase): def setUp(self): input_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer', 'html', 'input') self.input_data_handler = DataHandler(input_data) self.types_generator = VariableTypesGenerator() self.renderer = HtmlRenderer() def test_input_placeholder_str(self): input_element = create_mock_db_input( placeholder='string' ) result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) expected_html = self.input_data_handler.get_html('placeholder') self.assertTrue(are_equals(result_html, expected_html)) # def test_input_placeholder_not_str(self): # placeholder = None # # try: # for placeholder in self.types_generator.generate_types_excluding(['str', 'unicode']): # input_element = create_mock_db_input( # placeholder=placeholder # ) # # with self.assertRaises(Exception): # self.renderer._render_input(input_element) # except AssertionError as error: # placeholder_type = str(type(placeholder)) # error.message += ' (title type: ' + placeholder_type + ')' # raise AssertionError(error.message) def test_input_title_str(self): input_element = create_mock_db_input( title='string' ) result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) expected_html = self.input_data_handler.get_html('title') self.assertTrue(are_equals(result_html, expected_html)) # def test_input_title_not_str(self): # title = None # # try: # for title in self.types_generator.generate_types_excluding(['str', 'unicode']): # with self.assertRaises(Exception): # input_element = create_mock_db_input( # title=title # ) # # self.renderer._render_input(input_element) # except AssertionError as error: # title_type = str(type(title)) # error.message += ' (title type: ' + title_type + ')' # raise AssertionError(error.message) def test_input_value_str(self): input_element = create_mock_db_input( value="string" ) result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) expected_html = self.input_data_handler.get_html('input_str') self.assertTrue(are_equals(result_html, expected_html)) def test_input_value_none(self): input_element = create_mock_db_input( value=None ) result_string = self.renderer._render_input(input_element) result_html = etree.fromstring(result_string) expected_html = self.input_data_handler.get_html('input_none') self.assertTrue(are_equals(result_html, expected_html)) def test_input_not_schema_element(self): input_element = SchemaElement() try: for input_element in self.types_generator.possible_types: with self.assertRaises(TypeError): self.renderer._render_input(input_element) except AssertionError as error: input_type = str(type(input_element)) error.message += ' (input type: ' + input_type + ')' raise AssertionError(error.message)
def setUp(self): input_data = join('utils', 'XSDParser', 'tests', 'data', 'renderer', 'html', 'input') self.input_data_handler = DataHandler(input_data) self.types_generator = VariableTypesGenerator() self.renderer = HtmlRenderer()
class RendererRenderSelectTestSuite(TestCase): 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() def test_id_str_options_list(self): options = [ ('opt1', 'opt1', False), ('opt2', 'opt2', False), ('opt3', 'opt3', True) ] result_string = self.renderer._render_select(self.select_id, self.select_class, options) self.assertEqual( result_string, self.renderer._render_select(unicode(self.select_id), self.select_class, options) ) result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html('id_str_options_list') self.assertTrue(are_equals(result_html, expected_html)) def test_id_str_options_empty_list(self): options = [] result_string = self.renderer._render_select(self.select_id, self.select_class, options) self.assertEqual( result_string, self.renderer._render_select(unicode(self.select_id), self.select_class, options) ) result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html('id_str_options_empty') self.assertTrue(are_equals(result_html, expected_html)) def test_id_none_options_list(self): options = [ ('opt1', 'opt1', False), ('opt2', 'opt2', False), ('opt3', 'opt3', True) ] result_string = self.renderer._render_select(None, self.select_class, options) self.assertEqual(result_string, self.renderer._render_select(None, self.select_class, options)) # print result_string result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html('id_none_options_list') self.assertTrue(are_equals(result_html, expected_html)) def test_id_none_options_empty_list(self): options = [] result_string = self.renderer._render_select(None, self.select_class, options) self.assertEqual(result_string, self.renderer._render_select(None, self.select_class, options)) # print result_string result_html = etree.fromstring(result_string) expected_html = self.select_data_handler.get_html('id_none_options_empty') self.assertTrue(are_equals(result_html, expected_html)) # def test_id_not_str_not_none(self): # element_id = 'string' # # try: # for element_id in self.types_generator.generate_types_excluding(['str', 'unicode', 'none']): # with self.assertRaises(Exception): # self.renderer._render_select(element_id, self.select_class, []) # except AssertionError as error: # element_id_type = str(type(element_id)) # error.message += ' (element_id type: ' + element_id_type + ')' # raise AssertionError(error.message) # def test_options_not_list(self): # options = [] # # try: # for options in self.types_generator.generate_types_excluding(['list']): # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # except AssertionError as error: # options_type = str(type(options)) # error.message += ' (options type: ' + options_type + ')' # raise AssertionError(error.message) # def test_options_not_list_of_tuple(self): # options = [()] # # try: # for item in self.types_generator.generate_types_excluding(['tuple']): # options[0] = item # # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # except AssertionError as error: # item_type = str(type(options[0])) # error.message += ' (item type: ' + item_type + ')' # raise AssertionError(error.message) # def test_options_malformed_list(self): # options = [()] # # try: # for param in self.types_generator.generate_types_excluding(['str', 'unicode']): # options[0] = (param, '', False) # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # # options[0] = ('', param, False) # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # # for param in self.types_generator.generate_types_excluding(['bool']): # options[0] = ('', '', param) # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, options) # # with self.assertRaises(Exception): # self.renderer._render_select(self.select_id, self.select_class, [('elem0', 'elem1')]) # except AssertionError as error: # error.message += ' (option not considered as malformed: ' + str(options) + ')' # raise AssertionError(error.message) # FIXME New version (merge with up) def test_select_id_is_db_elem(self): pass def test_select_id_not_db_element(self): pass def test_select_id_not_str(self): pass def test_select_class_is_str(self): pass def test_select_class_is_not_str(self): pass def test_options_list_is_list_with_good_tuples(self): pass def test_options_list_is_list_with_bad_tuples(self): pass def test_options_list_is_list_without_tuples(self): pass def test_options_list_is_not_list(self): pass