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)