/tests/regressiontests/utils/termcolors.py

https://code.google.com/p/mango-py/ · Python · 148 lines · 125 code · 23 blank · 0 comment · 0 complexity · 62f95de3a047bf001e63d980fa45789e MD5 · raw file 

    

  1. from django.utils import unittest
    2. 

  2. from django.utils.termcolors import parse_color_setting, PALETTES, DEFAULT_PALETTE, LIGHT_PALETTE, DARK_PALETTE, NOCOLOR_PALETTE
    3. 

  3. 

  4. class TermColorTests(unittest.TestCase):
    5. 

  5. 

  6.     def test_empty_string(self):
    7. 

  7.         self.assertEqual(parse_color_setting(''), PALETTES[DEFAULT_PALETTE])
    8. 

  8. 

  9.     def test_simple_palette(self):
    10. 

  10.         self.assertEqual(parse_color_setting('light'), PALETTES[LIGHT_PALETTE])
    11. 

  11.         self.assertEqual(parse_color_setting('dark'), PALETTES[DARK_PALETTE])
    12. 

  12.         self.assertEqual(parse_color_setting('nocolor'), None)
    13. 

  13. 

  14.     def test_fg(self):
    15. 

  15.         self.assertEqual(parse_color_setting('error=green'),
    16. 

  16.                           dict(PALETTES[NOCOLOR_PALETTE],
    17. 

  17.                             ERROR={'fg':'green'}))
    18. 

  18. 

  19.     def test_fg_bg(self):
    20. 

  20.         self.assertEqual(parse_color_setting('error=green/blue'),
    21. 

  21.                           dict(PALETTES[NOCOLOR_PALETTE],
    22. 

  22.                             ERROR={'fg':'green', 'bg':'blue'}))
    23. 

  23. 

  24.     def test_fg_opts(self):
    25. 

  25.         self.assertEqual(parse_color_setting('error=green,blink'),
    26. 

  26.                           dict(PALETTES[NOCOLOR_PALETTE],
    27. 

  27.                             ERROR={'fg':'green', 'opts': ('blink',)}))
    28. 

  28.         self.assertEqual(parse_color_setting('error=green,bold,blink'),
    29. 

  29.                           dict(PALETTES[NOCOLOR_PALETTE],
    30. 

  30.                             ERROR={'fg':'green', 'opts': ('blink','bold')}))
    31. 

  31. 

  32.     def test_fg_bg_opts(self):
    33. 

  33.         self.assertEqual(parse_color_setting('error=green/blue,blink'),
    34. 

  34.                           dict(PALETTES[NOCOLOR_PALETTE],
    35. 

  35.                             ERROR={'fg':'green', 'bg':'blue', 'opts': ('blink',)}))
    36. 

  36.         self.assertEqual(parse_color_setting('error=green/blue,bold,blink'),
    37. 

  37.                           dict(PALETTES[NOCOLOR_PALETTE],
    38. 

  38.                             ERROR={'fg':'green', 'bg':'blue', 'opts': ('blink','bold')}))
    39. 

  39. 

  40.     def test_override_palette(self):
    41. 

  41.         self.assertEqual(parse_color_setting('light;error=green'),
    42. 

  42.                           dict(PALETTES[LIGHT_PALETTE],
    43. 

  43.                             ERROR={'fg':'green'}))
    44. 

  44. 

  45.     def test_override_nocolor(self):
    46. 

  46.         self.assertEqual(parse_color_setting('nocolor;error=green'),
    47. 

  47.                           dict(PALETTES[NOCOLOR_PALETTE],
    48. 

  48.                             ERROR={'fg': 'green'}))
    49. 

  49. 

  50.     def test_reverse_override(self):
    51. 

  51.         self.assertEqual(parse_color_setting('error=green;light'), PALETTES[LIGHT_PALETTE])
    52. 

  52. 

  53.     def test_multiple_roles(self):
    54. 

  54.         self.assertEqual(parse_color_setting('error=green;sql_field=blue'),
    55. 

  55.                           dict(PALETTES[NOCOLOR_PALETTE],
    56. 

  56.                             ERROR={'fg':'green'},
    57. 

  57.                             SQL_FIELD={'fg':'blue'}))
    58. 

  58. 

  59.     def test_override_with_multiple_roles(self):
    60. 

  60.         self.assertEqual(parse_color_setting('light;error=green;sql_field=blue'),
    61. 

  61.                           dict(PALETTES[LIGHT_PALETTE],
    62. 

  62.                             ERROR={'fg':'green'},
    63. 

  63.                             SQL_FIELD={'fg':'blue'}))
    64. 

  64. 

  65.     def test_empty_definition(self):
    66. 

  66.         self.assertEqual(parse_color_setting(';'), None)
    67. 

  67.         self.assertEqual(parse_color_setting('light;'), PALETTES[LIGHT_PALETTE])
    68. 

  68.         self.assertEqual(parse_color_setting(';;;'), None)
    69. 

  69. 

  70.     def test_empty_options(self):
    71. 

  71.         self.assertEqual(parse_color_setting('error=green,'),
    72. 

  72.                           dict(PALETTES[NOCOLOR_PALETTE],
    73. 

  73.                             ERROR={'fg':'green'}))
    74. 

  74.         self.assertEqual(parse_color_setting('error=green,,,'),
    75. 

  75.                           dict(PALETTES[NOCOLOR_PALETTE],
    76. 

  76.                             ERROR={'fg':'green'}))
    77. 

  77.         self.assertEqual(parse_color_setting('error=green,,blink,,'),
    78. 

  78.                           dict(PALETTES[NOCOLOR_PALETTE],
    79. 

  79.                             ERROR={'fg':'green', 'opts': ('blink',)}))
    80. 

  80. 

  81.     def test_bad_palette(self):
    82. 

  82.         self.assertEqual(parse_color_setting('unknown'), None)
    83. 

  83. 

  84.     def test_bad_role(self):
    85. 

  85.         self.assertEqual(parse_color_setting('unknown='), None)
    86. 

  86.         self.assertEqual(parse_color_setting('unknown=green'), None)
    87. 

  87.         self.assertEqual(parse_color_setting('unknown=green;sql_field=blue'),
    88. 

  88.                           dict(PALETTES[NOCOLOR_PALETTE],
    89. 

  89.                             SQL_FIELD={'fg':'blue'}))
    90. 

  90. 

  91.     def test_bad_color(self):
    92. 

  92.         self.assertEqual(parse_color_setting('error='), None)
    93. 

  93.         self.assertEqual(parse_color_setting('error=;sql_field=blue'),
    94. 

  94.                           dict(PALETTES[NOCOLOR_PALETTE],
    95. 

  95.                             SQL_FIELD={'fg':'blue'}))
    96. 

  96.         self.assertEqual(parse_color_setting('error=unknown'), None)
    97. 

  97.         self.assertEqual(parse_color_setting('error=unknown;sql_field=blue'),
    98. 

  98.                           dict(PALETTES[NOCOLOR_PALETTE],
    99. 

  99.                             SQL_FIELD={'fg':'blue'}))
    100. 

  100.         self.assertEqual(parse_color_setting('error=green/unknown'),
    101. 

  101.                           dict(PALETTES[NOCOLOR_PALETTE],
    102. 

  102.                             ERROR={'fg':'green'}))
    103. 

  103.         self.assertEqual(parse_color_setting('error=green/blue/something'),
    104. 

  104.                           dict(PALETTES[NOCOLOR_PALETTE],
    105. 

  105.                             ERROR={'fg':'green', 'bg': 'blue'}))
    106. 

  106.         self.assertEqual(parse_color_setting('error=green/blue/something,blink'),
    107. 

  107.                           dict(PALETTES[NOCOLOR_PALETTE],
    108. 

  108.                             ERROR={'fg':'green', 'bg': 'blue', 'opts': ('blink',)}))
    109. 

  109. 

  110.     def test_bad_option(self):
    111. 

  111.         self.assertEqual(parse_color_setting('error=green,unknown'),
    112. 

  112.                           dict(PALETTES[NOCOLOR_PALETTE],
    113. 

  113.                             ERROR={'fg':'green'}))
    114. 

  114.         self.assertEqual(parse_color_setting('error=green,unknown,blink'),
    115. 

  115.                           dict(PALETTES[NOCOLOR_PALETTE],
    116. 

  116.                             ERROR={'fg':'green', 'opts': ('blink',)}))
    117. 

  117. 

  118.     def test_role_case(self):
    119. 

  119.         self.assertEqual(parse_color_setting('ERROR=green'),
    120. 

  120.                           dict(PALETTES[NOCOLOR_PALETTE],
    121. 

  121.                             ERROR={'fg':'green'}))
    122. 

  122.         self.assertEqual(parse_color_setting('eRrOr=green'),
    123. 

  123.                           dict(PALETTES[NOCOLOR_PALETTE],
    124. 

  124.                             ERROR={'fg':'green'}))
    125. 

  125. 

  126.     def test_color_case(self):
    127. 

  127.         self.assertEqual(parse_color_setting('error=GREEN'),
    128. 

  128.                           dict(PALETTES[NOCOLOR_PALETTE],
    129. 

  129.                             ERROR={'fg':'green'}))
    130. 

  130.         self.assertEqual(parse_color_setting('error=GREEN/BLUE'),
    131. 

  131.                           dict(PALETTES[NOCOLOR_PALETTE],
    132. 

  132.                             ERROR={'fg':'green', 'bg':'blue'}))
    133. 

  133. 

  134.         self.assertEqual(parse_color_setting('error=gReEn'),
    135. 

  135.                           dict(PALETTES[NOCOLOR_PALETTE],
    136. 

  136.                             ERROR={'fg':'green'}))
    137. 

  137.         self.assertEqual(parse_color_setting('error=gReEn/bLuE'),
    138. 

  138.                           dict(PALETTES[NOCOLOR_PALETTE],
    139. 

  139.                             ERROR={'fg':'green', 'bg':'blue'}))
    140. 

  140. 

  141.     def test_opts_case(self):
    142. 

  142.         self.assertEqual(parse_color_setting('error=green,BLINK'),
    143. 

  143.                           dict(PALETTES[NOCOLOR_PALETTE],
    144. 

  144.                             ERROR={'fg':'green', 'opts': ('blink',)}))
    145. 

  145. 

  146.         self.assertEqual(parse_color_setting('error=green,bLiNk'),
    147. 

  147.                           dict(PALETTES[NOCOLOR_PALETTE],
    148. 

  148.                             ERROR={'fg':'green', 'opts': ('blink',)}))
    149.