class TestInlineFlagsPrinty(unittest.TestCase): """ Test case for inline formatting """ def setUp(self): self.printy = Printy() self.raw_text = self.printy.get_formatted_text def test_inline_format_with_global_flags(self): """ Tests that passing a text with inline formatting and also a global set of flags takes this last one as the format to be applied """ inline_formatted = "[y]Hey you@" no_format = 'Hey you' global_flags = 'rB' result_one = self.raw_text(inline_formatted, global_flags) result_two = self.raw_text(no_format, global_flags) self.assertEqual(result_one, result_two) def test_inline_format_without_ending_format_character(self): """ Tests that passing an inline formatted text without the ending formatting character still returns the formatted text """ result_one = self.raw_text('[y]Hey you') result_two = self.raw_text('[y]Hey you@') self.assertEqual(result_one, result_two) def test_escape_special_characters(self): """ Tests that escaping special characters prints them out """ inline_text_one = '[y]myemail\@mydomain.com@' global_text_one = '*****@*****.**', 'y' inline_text_two = '[bH]Some text \@@' global_text_two = 'Some text @', 'bH' inline_result_one = self.raw_text(inline_text_one) global_result_one = self.raw_text(global_text_one[0], global_text_one[1]) inline_result_two = self.raw_text(inline_text_two) global_result_two = self.raw_text(global_text_two[0], global_text_two[1]) self.assertEqual(inline_result_one, global_result_one) self.assertEqual(inline_result_two, global_result_two) def test_multiple_sections(self): """ Test that formats are applied correctly to each section """ section_one = "Some" section_two = ' ' section_three = 'text' global_format_one = self.raw_text(section_one, 'rB') global_format_two = self.raw_text(section_two) global_format_three = self.raw_text(section_three, 'y') joined_global_format = global_format_one + global_format_two + global_format_three inline_text = '[rB]Some@ [y]text@' inline_format = self.raw_text(inline_text) self.assertEqual(inline_format, joined_global_format) def test_read_file(self): """ Test retrieving the text from a file """ text_in_file = 'printy' file_name = 'printy_file' with mock.patch('builtins.open', mock.mock_open(read_data=text_in_file)) as m: result = self.printy.read_file(file_name) m.assert_called_once_with(file_name) self.assertEqual(result, text_in_file) def test_escape_special_chars_method(self): """ Test escaping especial characters correctly, this method is used when an object other than a string is passed """ text_to_escape = '[some text @ ]' expected_value = '\[some text \@ \]' escaped_text = Printy._escape_special_chars(text_to_escape) self.assertEqual(expected_value, escaped_text) def test_pretty_print_dicts(self): """ Test pretty printing dictionaries """ dict_to_print = {'name': 'John Doe', 'age': 34} expected_result = '{\n [n>]\'name\'@: [c>]\'John Doe\'@[<oB],@\n [n>]\'age\'@: [c]34@[<oB],@\n}' pretty_dict = Printy._repr_value(dict_to_print) self.assertEqual(expected_result, pretty_dict) def test_pretty_print_lists(self): """ Test pretty printing lists """ list_to_print = [1, 2, 'hello'] expected_result = '\[\n [c]1@[<oB],@ [c]2@[<oB],@ [c>]\'hello\'@\n\]' pretty_list = Printy._repr_value(list_to_print) self.assertEqual(expected_result, pretty_list) def test_pretty_printy_tuples(self): """ Test pretty printing tuples """ tuple_to_print = (1, 2, 'hello') expected_result = '(\n [c]1@[<oB],@ [c]2@[<oB],@ [c>]\'hello\'@\n)' pretty_tuple = Printy._repr_value(tuple_to_print) self.assertEqual(expected_result, pretty_tuple) def test_pretty_printy_sets(self): """ Test pretty printing sets """ set_to_print = {1, 2, 'hello'} expected_result = '{\n [c]1@[<oB],@ [c]2@[<oB],@ [c>]\'hello\'@\n}' pretty_set = Printy._repr_value(set_to_print) self.assertEqual(expected_result, pretty_set) def test_pretty_printy_dict_pretty_false(self): """ Tests pretty printing a dict when 'pretty' parameter is set to False """ dict_to_print = {'name': 'John Doe', 'age': 34} expected_result = '{\'name\': \'John Doe\', \'age\': 34}' not_pretty_dict = Printy._repr_value(dict_to_print, pretty=False) self.assertEqual(expected_result, not_pretty_dict) def test_pretty_printy_list_pretty_false(self): """ Tests pretty printing a list when 'pretty' parameter is set to False """ list_to_print = [1, 2, 'hello'] expected_result = '\[1, 2, \'hello\'\]' not_pretty_list = Printy._repr_value(list_to_print, pretty=False) self.assertEqual(expected_result, not_pretty_list) def test_pretty_printy_tuple_pretty_false(self): """ Tests pretty printing a tuple when 'pretty' parameter is set to False """ tuple_to_print = (1, 2, 'hello') expected_result = '(1, 2, \'hello\')' not_pretty_tuple = Printy._repr_value(tuple_to_print, pretty=False) self.assertEqual(expected_result, not_pretty_tuple) def test_pretty_printy_set_pretty_false(self): """ Tests pretty printing a set when 'pretty' parameter is set to False """ set_to_print = {1, 2, 'hello'} expected_result = '{1, 2, \'hello\'}' not_pretty_set = Printy._repr_value(set_to_print, pretty=False) self.assertEqual(expected_result, not_pretty_set) def test_pretty_print_str_method_of_objects(self): """ Test printing the str method of an object, both not defined and defined """ builtin_obj = int expected_builtin_result = '<class \'int\'>' pretty_builtin = Printy._repr_value(builtin_obj) class Person: def __str__(self): return '[c]I am a person@' custom_str = Person() # Notice how it should not return the escaped character expected_custom_result = '[c]I am a person@' pretty_custom = Printy._repr_value(custom_str) self.assertEqual(expected_builtin_result, pretty_builtin) self.assertEqual(expected_custom_result, pretty_custom) def test_pretty_object_in_dictionary(self): """ Test pretty printing an str method of an object inside a dictionary or any iterable, it should give it a light magenta color """ dict_to_print = {'class': int} expected_result = '{\n [n>]\'class\'@: <class \'int\'>[<oB],@\n}' pretty_dict = Printy._repr_value(dict_to_print) self.assertEqual(expected_result, pretty_dict) def test_pretty_custom_str_method_in_dictionary(self): class CustomStrMethod: def __str__(self): return '[rBU]Red Bold Underlined@ and [y]Yellow@' dict_to_print = {'str': CustomStrMethod()} expected_result = '{\n [n>]\'str\'@: [rBU]Red Bold Underlined@ and [y]Yellow@[<oB],@\n}' pretty_dict = Printy._repr_value(dict_to_print) self.assertEqual(expected_result, pretty_dict) def test_print_number(self): integer_to_print = 123 float_to_print = 123.45 expected_result_integer = '[c]123@' expected_result_float = '[c]123.45@' result_integer = Printy._repr_value(integer_to_print) result_float = Printy._repr_value(float_to_print) self.assertEqual(expected_result_integer, result_integer) self.assertEqual(expected_result_float, result_float) def test_print_boolean(self): expected_false = '[<o]False@' expected_true = '[<o]True@' result_false = Printy._repr_value(False) result_true = Printy._repr_value(True) self.assertEqual(expected_false, result_false) self.assertEqual(expected_true, result_true) def test_print_none(self): expected_none = '[<o]None@' result_none = Printy._repr_value(None) self.assertEqual(expected_none, result_none)
class TestInlineFlagsPrinty(unittest.TestCase): """ Test case for inline formatting """ def setUp(self): self.printy = Printy() self.raw_text = self.printy.get_formatted_text def test_inline_format_with_global_flags(self): """ Tests that passing a text with inline formatting and also a global set of flags takes this last one as the format to be applied """ inline_formatted = "[y]Hey you@" no_format = 'Hey you' global_flags = 'rB' result_one = self.raw_text(inline_formatted, global_flags) result_two = self.raw_text(no_format, global_flags) self.assertEqual(result_one, result_two) def test_inline_format_without_ending_format_character(self): """ Tests that passing an inline formatted text without the ending formatting character still returns the formatted text """ result_one = self.raw_text('[y]Hey you') result_two = self.raw_text('[y]Hey you@') self.assertEqual(result_one, result_two) def test_escape_special_characters(self): """ Tests that escaping special characters prints them out """ inline_text_one = '[y]myemail\@mydomain.com@' global_text_one = '*****@*****.**', 'y' inline_text_two = '[bH]Some text \@@' global_text_two = 'Some text @', 'bH' inline_result_one = self.raw_text(inline_text_one) global_result_one = self.raw_text(global_text_one[0], global_text_one[1]) inline_result_two = self.raw_text(inline_text_two) global_result_two = self.raw_text(global_text_two[0], global_text_two[1]) self.assertEqual(inline_result_one, global_result_one) self.assertEqual(inline_result_two, global_result_two) def test_multiple_sections(self): """ Test that formats are applied correctly to each section """ section_one = "Some" section_two = ' ' section_three = 'text' global_format_one = self.raw_text(section_one, 'rB') global_format_two = self.raw_text(section_two) global_format_three = self.raw_text(section_three, 'y') joined_global_format = global_format_one + global_format_two + global_format_three inline_text = '[rB]Some@ [y]text@' inline_format = self.raw_text(inline_text) self.assertEqual(inline_format, joined_global_format) def test_read_file(self): """ Test retrieving the text from a file """ text_in_file = 'printy' file_name = 'printy_file' with mock.patch('builtins.open', mock.mock_open(read_data=text_in_file)) as m: result = self.printy.read_file(file_name) m.assert_called_once_with(file_name) self.assertEqual(result, text_in_file)