Mercurial > repos > shellac > guppy_basecaller
view env/lib/python3.7/site-packages/humanfriendly/tests.py @ 0:26e78fe6e8c4 draft
"planemo upload commit c699937486c35866861690329de38ec1a5d9f783"
| author | shellac |
|---|---|
| date | Sat, 02 May 2020 07:14:21 -0400 |
| parents | |
| children |
line wrap: on
line source
#!/usr/bin/env python # vim: fileencoding=utf-8 : # Tests for the `humanfriendly' package. # # Author: Peter Odding <peter.odding@paylogic.eu> # Last Change: April 19, 2020 # URL: https://humanfriendly.readthedocs.io """Test suite for the `humanfriendly` package.""" # Standard library modules. import datetime import math import os import random import re import subprocess import sys import time import types import unittest import warnings # Modules included in our package. from humanfriendly import ( InvalidDate, InvalidLength, InvalidSize, InvalidTimespan, Timer, coerce_boolean, coerce_pattern, format_length, format_number, format_path, format_size, format_timespan, parse_date, parse_length, parse_path, parse_size, parse_timespan, prompts, round_number, ) from humanfriendly.case import CaseInsensitiveDict, CaseInsensitiveKey from humanfriendly.cli import main from humanfriendly.compat import StringIO from humanfriendly.decorators import cached from humanfriendly.deprecation import DeprecationProxy, define_aliases, deprecated_args, get_aliases from humanfriendly.prompts import ( TooManyInvalidReplies, prompt_for_confirmation, prompt_for_choice, prompt_for_input, ) from humanfriendly.sphinx import ( deprecation_note_callback, man_role, pypi_role, setup, special_methods_callback, usage_message_callback, ) from humanfriendly.tables import ( format_pretty_table, format_robust_table, format_rst_table, format_smart_table, ) from humanfriendly.terminal import ( ANSI_CSI, ANSI_ERASE_LINE, ANSI_HIDE_CURSOR, ANSI_RESET, ANSI_SGR, ANSI_SHOW_CURSOR, ansi_strip, ansi_style, ansi_width, ansi_wrap, clean_terminal_output, connected_to_terminal, find_terminal_size, get_pager_command, message, output, show_pager, terminal_supports_colors, warning, ) from humanfriendly.terminal.html import html_to_ansi from humanfriendly.terminal.spinners import AutomaticSpinner, Spinner from humanfriendly.testing import ( CallableTimedOut, CaptureOutput, MockedProgram, PatchedAttribute, PatchedItem, TemporaryDirectory, TestCase, retry, run_cli, skip_on_raise, touch, ) from humanfriendly.text import ( compact, compact_empty_lines, concatenate, dedent, generate_slug, pluralize, random_string, trim_empty_lines, ) from humanfriendly.usage import ( find_meta_variables, format_usage, parse_usage, render_usage, ) # Test dependencies. from mock import MagicMock class HumanFriendlyTestCase(TestCase): """Container for the `humanfriendly` test suite.""" def test_case_insensitive_dict(self): """Test the CaseInsensitiveDict class.""" # Test support for the dict(iterable) signature. assert len(CaseInsensitiveDict([('key', True), ('KEY', False)])) == 1 # Test support for the dict(iterable, **kw) signature. assert len(CaseInsensitiveDict([('one', True), ('ONE', False)], one=False, two=True)) == 2 # Test support for the dict(mapping) signature. assert len(CaseInsensitiveDict(dict(key=True, KEY=False))) == 1 # Test support for the dict(mapping, **kw) signature. assert len(CaseInsensitiveDict(dict(one=True, ONE=False), one=False, two=True)) == 2 # Test support for the dict(**kw) signature. assert len(CaseInsensitiveDict(one=True, ONE=False, two=True)) == 2 # Test support for dict.fromkeys(). obj = CaseInsensitiveDict.fromkeys(["One", "one", "ONE", "Two", "two", "TWO"]) assert len(obj) == 2 # Test support for dict.get(). obj = CaseInsensitiveDict(existing_key=42) assert obj.get('Existing_Key') == 42 # Test support for dict.pop(). obj = CaseInsensitiveDict(existing_key=42) assert obj.pop('Existing_Key') == 42 assert len(obj) == 0 # Test support for dict.setdefault(). obj = CaseInsensitiveDict(existing_key=42) assert obj.setdefault('Existing_Key') == 42 obj.setdefault('other_key', 11) assert obj['Other_Key'] == 11 # Test support for dict.__contains__(). obj = CaseInsensitiveDict(existing_key=42) assert 'Existing_Key' in obj # Test support for dict.__delitem__(). obj = CaseInsensitiveDict(existing_key=42) del obj['Existing_Key'] assert len(obj) == 0 # Test support for dict.__getitem__(). obj = CaseInsensitiveDict(existing_key=42) assert obj['Existing_Key'] == 42 # Test support for dict.__setitem__(). obj = CaseInsensitiveDict(existing_key=42) obj['Existing_Key'] = 11 assert obj['existing_key'] == 11 def test_case_insensitive_key(self): """Test the CaseInsensitiveKey class.""" # Test the __eq__() special method. polite = CaseInsensitiveKey("Please don't shout") rude = CaseInsensitiveKey("PLEASE DON'T SHOUT") assert polite == rude # Test the __hash__() special method. mapping = {} mapping[polite] = 1 mapping[rude] = 2 assert len(mapping) == 1 def test_capture_output(self): """Test the CaptureOutput class.""" with CaptureOutput() as capturer: sys.stdout.write("Something for stdout.\n") sys.stderr.write("And for stderr.\n") assert capturer.stdout.get_lines() == ["Something for stdout."] assert capturer.stderr.get_lines() == ["And for stderr."] def test_skip_on_raise(self): """Test the skip_on_raise() decorator.""" def test_fn(): raise NotImplementedError() decorator_fn = skip_on_raise(NotImplementedError) decorated_fn = decorator_fn(test_fn) self.assertRaises(NotImplementedError, test_fn) self.assertRaises(unittest.SkipTest, decorated_fn) def test_retry_raise(self): """Test :func:`~humanfriendly.testing.retry()` based on assertion errors.""" # Define a helper function that will raise an assertion error on the # first call and return a string on the second call. def success_helper(): if not hasattr(success_helper, 'was_called'): setattr(success_helper, 'was_called', True) assert False else: return 'yes' assert retry(success_helper) == 'yes' # Define a helper function that always raises an assertion error. def failure_helper(): assert False with self.assertRaises(AssertionError): retry(failure_helper, timeout=1) def test_retry_return(self): """Test :func:`~humanfriendly.testing.retry()` based on return values.""" # Define a helper function that will return False on the first call and # return a number on the second call. def success_helper(): if not hasattr(success_helper, 'was_called'): # On the first call we return False. setattr(success_helper, 'was_called', True) return False else: # On the second call we return a number. return 42 assert retry(success_helper) == 42 with self.assertRaises(CallableTimedOut): retry(lambda: False, timeout=1) def test_mocked_program(self): """Test :class:`humanfriendly.testing.MockedProgram`.""" name = random_string() script = dedent(''' # This goes to stdout. tr a-z A-Z # This goes to stderr. echo Fake warning >&2 ''') with MockedProgram(name=name, returncode=42, script=script) as directory: assert os.path.isdir(directory) assert os.path.isfile(os.path.join(directory, name)) program = subprocess.Popen(name, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = program.communicate(input=b'hello world\n') assert program.returncode == 42 assert stdout == b'HELLO WORLD\n' assert stderr == b'Fake warning\n' def test_temporary_directory(self): """Test :class:`humanfriendly.testing.TemporaryDirectory`.""" with TemporaryDirectory() as directory: assert os.path.isdir(directory) temporary_file = os.path.join(directory, 'some-file') with open(temporary_file, 'w') as handle: handle.write("Hello world!") assert not os.path.exists(temporary_file) assert not os.path.exists(directory) def test_touch(self): """Test :func:`humanfriendly.testing.touch()`.""" with TemporaryDirectory() as directory: # Create a file in the temporary directory. filename = os.path.join(directory, random_string()) assert not os.path.isfile(filename) touch(filename) assert os.path.isfile(filename) # Create a file in a subdirectory. filename = os.path.join(directory, random_string(), random_string()) assert not os.path.isfile(filename) touch(filename) assert os.path.isfile(filename) def test_patch_attribute(self): """Test :class:`humanfriendly.testing.PatchedAttribute`.""" class Subject(object): my_attribute = 42 instance = Subject() assert instance.my_attribute == 42 with PatchedAttribute(instance, 'my_attribute', 13) as return_value: assert return_value is instance assert instance.my_attribute == 13 assert instance.my_attribute == 42 def test_patch_item(self): """Test :class:`humanfriendly.testing.PatchedItem`.""" instance = dict(my_item=True) assert instance['my_item'] is True with PatchedItem(instance, 'my_item', False) as return_value: assert return_value is instance assert instance['my_item'] is False assert instance['my_item'] is True def test_run_cli_intercepts_exit(self): """Test that run_cli() intercepts SystemExit.""" returncode, output = run_cli(lambda: sys.exit(42)) self.assertEqual(returncode, 42) def test_run_cli_intercepts_error(self): """Test that run_cli() intercepts exceptions.""" returncode, output = run_cli(self.run_cli_raise_other) self.assertEqual(returncode, 1) def run_cli_raise_other(self): """run_cli() sample that raises an exception.""" raise ValueError() def test_run_cli_intercepts_output(self): """Test that run_cli() intercepts output.""" expected_output = random_string() + "\n" returncode, output = run_cli(lambda: sys.stdout.write(expected_output)) self.assertEqual(returncode, 0) self.assertEqual(output, expected_output) def test_caching_decorator(self): """Test the caching decorator.""" # Confirm that the caching decorator works. a = cached(lambda: random.random()) b = cached(lambda: random.random()) assert a() == a() assert b() == b() # Confirm that functions have their own cache. assert a() != b() def test_compact(self): """Test :func:`humanfriendly.text.compact()`.""" assert compact(' a \n\n b ') == 'a b' assert compact(''' %s template notation ''', 'Simple') == 'Simple template notation' assert compact(''' More {type} template notation ''', type='readable') == 'More readable template notation' def test_compact_empty_lines(self): """Test :func:`humanfriendly.text.compact_empty_lines()`.""" # Simple strings pass through untouched. assert compact_empty_lines('foo') == 'foo' # Horizontal whitespace remains untouched. assert compact_empty_lines('\tfoo') == '\tfoo' # Line breaks should be preserved. assert compact_empty_lines('foo\nbar') == 'foo\nbar' # Vertical whitespace should be preserved. assert compact_empty_lines('foo\n\nbar') == 'foo\n\nbar' # Vertical whitespace should be compressed. assert compact_empty_lines('foo\n\n\nbar') == 'foo\n\nbar' assert compact_empty_lines('foo\n\n\n\nbar') == 'foo\n\nbar' assert compact_empty_lines('foo\n\n\n\n\nbar') == 'foo\n\nbar' def test_dedent(self): """Test :func:`humanfriendly.text.dedent()`.""" assert dedent('\n line 1\n line 2\n\n') == 'line 1\n line 2\n' assert dedent(''' Dedented, %s text ''', 'interpolated') == 'Dedented, interpolated text\n' assert dedent(''' Dedented, {op} text ''', op='formatted') == 'Dedented, formatted text\n' def test_pluralization(self): """Test :func:`humanfriendly.text.pluralize()`.""" assert pluralize(1, 'word') == '1 word' assert pluralize(2, 'word') == '2 words' assert pluralize(1, 'box', 'boxes') == '1 box' assert pluralize(2, 'box', 'boxes') == '2 boxes' def test_generate_slug(self): """Test :func:`humanfriendly.text.generate_slug()`.""" # Test the basic functionality. self.assertEqual('some-random-text', generate_slug('Some Random Text!')) # Test that previous output doesn't change. self.assertEqual('some-random-text', generate_slug('some-random-text')) # Test that inputs which can't be converted to a slug raise an exception. with self.assertRaises(ValueError): generate_slug(' ') with self.assertRaises(ValueError): generate_slug('-') def test_boolean_coercion(self): """Test :func:`humanfriendly.coerce_boolean()`.""" for value in [True, 'TRUE', 'True', 'true', 'on', 'yes', '1']: self.assertEqual(True, coerce_boolean(value)) for value in [False, 'FALSE', 'False', 'false', 'off', 'no', '0']: self.assertEqual(False, coerce_boolean(value)) with self.assertRaises(ValueError): coerce_boolean('not a boolean') def test_pattern_coercion(self): """Test :func:`humanfriendly.coerce_pattern()`.""" empty_pattern = re.compile('') # Make sure strings are converted to compiled regular expressions. assert isinstance(coerce_pattern('foobar'), type(empty_pattern)) # Make sure compiled regular expressions pass through untouched. assert empty_pattern is coerce_pattern(empty_pattern) # Make sure flags are respected. pattern = coerce_pattern('foobar', re.IGNORECASE) assert pattern.match('FOOBAR') # Make sure invalid values raise the expected exception. with self.assertRaises(ValueError): coerce_pattern([]) def test_format_timespan(self): """Test :func:`humanfriendly.format_timespan()`.""" minute = 60 hour = minute * 60 day = hour * 24 week = day * 7 year = week * 52 assert '1 nanosecond' == format_timespan(0.000000001, detailed=True) assert '500 nanoseconds' == format_timespan(0.0000005, detailed=True) assert '1 microsecond' == format_timespan(0.000001, detailed=True) assert '500 microseconds' == format_timespan(0.0005, detailed=True) assert '1 millisecond' == format_timespan(0.001, detailed=True) assert '500 milliseconds' == format_timespan(0.5, detailed=True) assert '0.5 seconds' == format_timespan(0.5, detailed=False) assert '0 seconds' == format_timespan(0) assert '0.54 seconds' == format_timespan(0.54321) assert '1 second' == format_timespan(1) assert '3.14 seconds' == format_timespan(math.pi) assert '1 minute' == format_timespan(minute) assert '1 minute and 20 seconds' == format_timespan(80) assert '2 minutes' == format_timespan(minute * 2) assert '1 hour' == format_timespan(hour) assert '2 hours' == format_timespan(hour * 2) assert '1 day' == format_timespan(day) assert '2 days' == format_timespan(day * 2) assert '1 week' == format_timespan(week) assert '2 weeks' == format_timespan(week * 2) assert '1 year' == format_timespan(year) assert '2 years' == format_timespan(year * 2) assert '6 years, 5 weeks, 4 days, 3 hours, 2 minutes and 500 milliseconds' == \ format_timespan(year * 6 + week * 5 + day * 4 + hour * 3 + minute * 2 + 0.5, detailed=True) assert '1 year, 2 weeks and 3 days' == \ format_timespan(year + week * 2 + day * 3 + hour * 12) # Make sure milliseconds are never shown separately when detailed=False. # https://github.com/xolox/python-humanfriendly/issues/10 assert '1 minute, 1 second and 100 milliseconds' == format_timespan(61.10, detailed=True) assert '1 minute and 1.1 second' == format_timespan(61.10, detailed=False) # Test for loss of precision as reported in issue 11: # https://github.com/xolox/python-humanfriendly/issues/11 assert '1 minute and 0.3 seconds' == format_timespan(60.300) assert '5 minutes and 0.3 seconds' == format_timespan(300.300) assert '1 second and 15 milliseconds' == format_timespan(1.015, detailed=True) assert '10 seconds and 15 milliseconds' == format_timespan(10.015, detailed=True) assert '1 microsecond and 50 nanoseconds' == format_timespan(0.00000105, detailed=True) # Test the datetime.timedelta support: # https://github.com/xolox/python-humanfriendly/issues/27 now = datetime.datetime.now() then = now - datetime.timedelta(hours=23) assert '23 hours' == format_timespan(now - then) def test_parse_timespan(self): """Test :func:`humanfriendly.parse_timespan()`.""" self.assertEqual(0, parse_timespan('0')) self.assertEqual(0, parse_timespan('0s')) self.assertEqual(0.000000001, parse_timespan('1ns')) self.assertEqual(0.000000051, parse_timespan('51ns')) self.assertEqual(0.000001, parse_timespan('1us')) self.assertEqual(0.000052, parse_timespan('52us')) self.assertEqual(0.001, parse_timespan('1ms')) self.assertEqual(0.001, parse_timespan('1 millisecond')) self.assertEqual(0.5, parse_timespan('500 milliseconds')) self.assertEqual(0.5, parse_timespan('0.5 seconds')) self.assertEqual(5, parse_timespan('5s')) self.assertEqual(5, parse_timespan('5 seconds')) self.assertEqual(60 * 2, parse_timespan('2m')) self.assertEqual(60 * 2, parse_timespan('2 minutes')) self.assertEqual(60 * 3, parse_timespan('3 min')) self.assertEqual(60 * 3, parse_timespan('3 mins')) self.assertEqual(60 * 60 * 3, parse_timespan('3 h')) self.assertEqual(60 * 60 * 3, parse_timespan('3 hours')) self.assertEqual(60 * 60 * 24 * 4, parse_timespan('4d')) self.assertEqual(60 * 60 * 24 * 4, parse_timespan('4 days')) self.assertEqual(60 * 60 * 24 * 7 * 5, parse_timespan('5 w')) self.assertEqual(60 * 60 * 24 * 7 * 5, parse_timespan('5 weeks')) with self.assertRaises(InvalidTimespan): parse_timespan('1z') def test_parse_date(self): """Test :func:`humanfriendly.parse_date()`.""" self.assertEqual((2013, 6, 17, 0, 0, 0), parse_date('2013-06-17')) self.assertEqual((2013, 6, 17, 2, 47, 42), parse_date('2013-06-17 02:47:42')) self.assertEqual((2016, 11, 30, 0, 47, 17), parse_date(u'2016-11-30 00:47:17')) with self.assertRaises(InvalidDate): parse_date('2013-06-XY') def test_format_size(self): """Test :func:`humanfriendly.format_size()`.""" self.assertEqual('0 bytes', format_size(0)) self.assertEqual('1 byte', format_size(1)) self.assertEqual('42 bytes', format_size(42)) self.assertEqual('1 KB', format_size(1000 ** 1)) self.assertEqual('1 MB', format_size(1000 ** 2)) self.assertEqual('1 GB', format_size(1000 ** 3)) self.assertEqual('1 TB', format_size(1000 ** 4)) self.assertEqual('1 PB', format_size(1000 ** 5)) self.assertEqual('1 EB', format_size(1000 ** 6)) self.assertEqual('1 ZB', format_size(1000 ** 7)) self.assertEqual('1 YB', format_size(1000 ** 8)) self.assertEqual('1 KiB', format_size(1024 ** 1, binary=True)) self.assertEqual('1 MiB', format_size(1024 ** 2, binary=True)) self.assertEqual('1 GiB', format_size(1024 ** 3, binary=True)) self.assertEqual('1 TiB', format_size(1024 ** 4, binary=True)) self.assertEqual('1 PiB', format_size(1024 ** 5, binary=True)) self.assertEqual('1 EiB', format_size(1024 ** 6, binary=True)) self.assertEqual('1 ZiB', format_size(1024 ** 7, binary=True)) self.assertEqual('1 YiB', format_size(1024 ** 8, binary=True)) self.assertEqual('45 KB', format_size(1000 * 45)) self.assertEqual('2.9 TB', format_size(1000 ** 4 * 2.9)) def test_parse_size(self): """Test :func:`humanfriendly.parse_size()`.""" self.assertEqual(0, parse_size('0B')) self.assertEqual(42, parse_size('42')) self.assertEqual(42, parse_size('42B')) self.assertEqual(1000, parse_size('1k')) self.assertEqual(1024, parse_size('1k', binary=True)) self.assertEqual(1000, parse_size('1 KB')) self.assertEqual(1000, parse_size('1 kilobyte')) self.assertEqual(1024, parse_size('1 kilobyte', binary=True)) self.assertEqual(1000 ** 2 * 69, parse_size('69 MB')) self.assertEqual(1000 ** 3, parse_size('1 GB')) self.assertEqual(1000 ** 4, parse_size('1 TB')) self.assertEqual(1000 ** 5, parse_size('1 PB')) self.assertEqual(1000 ** 6, parse_size('1 EB')) self.assertEqual(1000 ** 7, parse_size('1 ZB')) self.assertEqual(1000 ** 8, parse_size('1 YB')) self.assertEqual(1000 ** 3 * 1.5, parse_size('1.5 GB')) self.assertEqual(1024 ** 8 * 1.5, parse_size('1.5 YiB')) with self.assertRaises(InvalidSize): parse_size('1q') with self.assertRaises(InvalidSize): parse_size('a') def test_format_length(self): """Test :func:`humanfriendly.format_length()`.""" self.assertEqual('0 metres', format_length(0)) self.assertEqual('1 metre', format_length(1)) self.assertEqual('42 metres', format_length(42)) self.assertEqual('1 km', format_length(1 * 1000)) self.assertEqual('15.3 cm', format_length(0.153)) self.assertEqual('1 cm', format_length(1e-02)) self.assertEqual('1 mm', format_length(1e-03)) self.assertEqual('1 nm', format_length(1e-09)) def test_parse_length(self): """Test :func:`humanfriendly.parse_length()`.""" self.assertEqual(0, parse_length('0m')) self.assertEqual(42, parse_length('42')) self.assertEqual(1.5, parse_length('1.5')) self.assertEqual(42, parse_length('42m')) self.assertEqual(1000, parse_length('1km')) self.assertEqual(0.153, parse_length('15.3 cm')) self.assertEqual(1e-02, parse_length('1cm')) self.assertEqual(1e-03, parse_length('1mm')) self.assertEqual(1e-09, parse_length('1nm')) with self.assertRaises(InvalidLength): parse_length('1z') with self.assertRaises(InvalidLength): parse_length('a') def test_format_number(self): """Test :func:`humanfriendly.format_number()`.""" self.assertEqual('1', format_number(1)) self.assertEqual('1.5', format_number(1.5)) self.assertEqual('1.56', format_number(1.56789)) self.assertEqual('1.567', format_number(1.56789, 3)) self.assertEqual('1,000', format_number(1000)) self.assertEqual('1,000', format_number(1000.12, 0)) self.assertEqual('1,000,000', format_number(1000000)) self.assertEqual('1,000,000.42', format_number(1000000.42)) def test_round_number(self): """Test :func:`humanfriendly.round_number()`.""" self.assertEqual('1', round_number(1)) self.assertEqual('1', round_number(1.0)) self.assertEqual('1.00', round_number(1, keep_width=True)) self.assertEqual('3.14', round_number(3.141592653589793)) def test_format_path(self): """Test :func:`humanfriendly.format_path()`.""" friendly_path = os.path.join('~', '.vimrc') absolute_path = os.path.join(os.environ['HOME'], '.vimrc') self.assertEqual(friendly_path, format_path(absolute_path)) def test_parse_path(self): """Test :func:`humanfriendly.parse_path()`.""" friendly_path = os.path.join('~', '.vimrc') absolute_path = os.path.join(os.environ['HOME'], '.vimrc') self.assertEqual(absolute_path, parse_path(friendly_path)) def test_pretty_tables(self): """Test :func:`humanfriendly.tables.format_pretty_table()`.""" # The simplest case possible :-). data = [['Just one column']] assert format_pretty_table(data) == dedent(""" ------------------- | Just one column | ------------------- """).strip() # A bit more complex: two rows, three columns, varying widths. data = [['One', 'Two', 'Three'], ['1', '2', '3']] assert format_pretty_table(data) == dedent(""" --------------------- | One | Two | Three | | 1 | 2 | 3 | --------------------- """).strip() # A table including column names. column_names = ['One', 'Two', 'Three'] data = [['1', '2', '3'], ['a', 'b', 'c']] assert ansi_strip(format_pretty_table(data, column_names)) == dedent(""" --------------------- | One | Two | Three | --------------------- | 1 | 2 | 3 | | a | b | c | --------------------- """).strip() # A table that contains a column with only numeric data (will be right aligned). column_names = ['Just a label', 'Important numbers'] data = [['Row one', '15'], ['Row two', '300']] assert ansi_strip(format_pretty_table(data, column_names)) == dedent(""" ------------------------------------ | Just a label | Important numbers | ------------------------------------ | Row one | 15 | | Row two | 300 | ------------------------------------ """).strip() def test_robust_tables(self): """Test :func:`humanfriendly.tables.format_robust_table()`.""" column_names = ['One', 'Two', 'Three'] data = [['1', '2', '3'], ['a', 'b', 'c']] assert ansi_strip(format_robust_table(data, column_names)) == dedent(""" -------- One: 1 Two: 2 Three: 3 -------- One: a Two: b Three: c -------- """).strip() column_names = ['One', 'Two', 'Three'] data = [['1', '2', '3'], ['a', 'b', 'Here comes a\nmulti line column!']] assert ansi_strip(format_robust_table(data, column_names)) == dedent(""" ------------------ One: 1 Two: 2 Three: 3 ------------------ One: a Two: b Three: Here comes a multi line column! ------------------ """).strip() def test_smart_tables(self): """Test :func:`humanfriendly.tables.format_smart_table()`.""" column_names = ['One', 'Two', 'Three'] data = [['1', '2', '3'], ['a', 'b', 'c']] assert ansi_strip(format_smart_table(data, column_names)) == dedent(""" --------------------- | One | Two | Three | --------------------- | 1 | 2 | 3 | | a | b | c | --------------------- """).strip() column_names = ['One', 'Two', 'Three'] data = [['1', '2', '3'], ['a', 'b', 'Here comes a\nmulti line column!']] assert ansi_strip(format_smart_table(data, column_names)) == dedent(""" ------------------ One: 1 Two: 2 Three: 3 ------------------ One: a Two: b Three: Here comes a multi line column! ------------------ """).strip() def test_rst_tables(self): """Test :func:`humanfriendly.tables.format_rst_table()`.""" # Generate a table with column names. column_names = ['One', 'Two', 'Three'] data = [['1', '2', '3'], ['a', 'b', 'c']] self.assertEqual( format_rst_table(data, column_names), dedent(""" === === ===== One Two Three === === ===== 1 2 3 a b c === === ===== """).rstrip(), ) # Generate a table without column names. data = [['1', '2', '3'], ['a', 'b', 'c']] self.assertEqual( format_rst_table(data), dedent(""" = = = 1 2 3 a b c = = = """).rstrip(), ) def test_concatenate(self): """Test :func:`humanfriendly.text.concatenate()`.""" assert concatenate([]) == '' assert concatenate(['one']) == 'one' assert concatenate(['one', 'two']) == 'one and two' assert concatenate(['one', 'two', 'three']) == 'one, two and three' def test_split(self): """Test :func:`humanfriendly.text.split()`.""" from humanfriendly.text import split self.assertEqual(split(''), []) self.assertEqual(split('foo'), ['foo']) self.assertEqual(split('foo, bar'), ['foo', 'bar']) self.assertEqual(split('foo, bar, baz'), ['foo', 'bar', 'baz']) self.assertEqual(split('foo,bar,baz'), ['foo', 'bar', 'baz']) def test_timer(self): """Test :func:`humanfriendly.Timer`.""" for seconds, text in ((1, '1 second'), (2, '2 seconds'), (60, '1 minute'), (60 * 2, '2 minutes'), (60 * 60, '1 hour'), (60 * 60 * 2, '2 hours'), (60 * 60 * 24, '1 day'), (60 * 60 * 24 * 2, '2 days'), (60 * 60 * 24 * 7, '1 week'), (60 * 60 * 24 * 7 * 2, '2 weeks')): t = Timer(time.time() - seconds) self.assertEqual(round_number(t.elapsed_time, keep_width=True), '%i.00' % seconds) self.assertEqual(str(t), text) # Test rounding to seconds. t = Timer(time.time() - 2.2) self.assertEqual(t.rounded, '2 seconds') # Test automatic timer. automatic_timer = Timer() time.sleep(1) # XXX The following normalize_timestamp(ndigits=0) calls are intended # to compensate for unreliable clock sources in virtual machines # like those encountered on Travis CI, see also: # https://travis-ci.org/xolox/python-humanfriendly/jobs/323944263 self.assertEqual(normalize_timestamp(automatic_timer.elapsed_time, 0), '1.00') # Test resumable timer. resumable_timer = Timer(resumable=True) for i in range(2): with resumable_timer: time.sleep(1) self.assertEqual(normalize_timestamp(resumable_timer.elapsed_time, 0), '2.00') # Make sure Timer.__enter__() returns the timer object. with Timer(resumable=True) as timer: assert timer is not None def test_spinner(self): """Test :func:`humanfriendly.Spinner`.""" stream = StringIO() spinner = Spinner(label='test spinner', total=4, stream=stream, interactive=True) for progress in [1, 2, 3, 4]: spinner.step(progress=progress) time.sleep(0.2) spinner.clear() output = stream.getvalue() output = (output.replace(ANSI_SHOW_CURSOR, '') .replace(ANSI_HIDE_CURSOR, '')) lines = [line for line in output.split(ANSI_ERASE_LINE) if line] self.assertTrue(len(lines) > 0) self.assertTrue(all('test spinner' in l for l in lines)) self.assertTrue(all('%' in l for l in lines)) self.assertEqual(sorted(set(lines)), sorted(lines)) def test_automatic_spinner(self): """ Test :func:`humanfriendly.AutomaticSpinner`. There's not a lot to test about the :class:`.AutomaticSpinner` class, but by at least running it here we are assured that the code functions on all supported Python versions. :class:`.AutomaticSpinner` is built on top of the :class:`.Spinner` class so at least we also have the tests for the :class:`.Spinner` class to back us up. """ with AutomaticSpinner(label='test spinner'): time.sleep(1) def test_prompt_for_choice(self): """Test :func:`humanfriendly.prompts.prompt_for_choice()`.""" # Choice selection without any options should raise an exception. with self.assertRaises(ValueError): prompt_for_choice([]) # If there's only one option no prompt should be rendered so we expect # the following code to not raise an EOFError exception (despite # connecting standard input to /dev/null). with open(os.devnull) as handle: with PatchedAttribute(sys, 'stdin', handle): only_option = 'only one option (shortcut)' assert prompt_for_choice([only_option]) == only_option # Choice selection by full string match. with PatchedAttribute(prompts, 'interactive_prompt', lambda p: 'foo'): assert prompt_for_choice(['foo', 'bar']) == 'foo' # Choice selection by substring input. with PatchedAttribute(prompts, 'interactive_prompt', lambda p: 'f'): assert prompt_for_choice(['foo', 'bar']) == 'foo' # Choice selection by number. with PatchedAttribute(prompts, 'interactive_prompt', lambda p: '2'): assert prompt_for_choice(['foo', 'bar']) == 'bar' # Choice selection by going with the default. with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): assert prompt_for_choice(['foo', 'bar'], default='bar') == 'bar' # Invalid substrings are refused. replies = ['', 'q', 'z'] with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): assert prompt_for_choice(['foo', 'bar', 'baz']) == 'baz' # Choice selection by substring input requires an unambiguous substring match. replies = ['a', 'q'] with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): assert prompt_for_choice(['foo', 'bar', 'baz', 'qux']) == 'qux' # Invalid numbers are refused. replies = ['42', '2'] with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): assert prompt_for_choice(['foo', 'bar', 'baz']) == 'bar' # Test that interactive prompts eventually give up on invalid replies. with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): with self.assertRaises(TooManyInvalidReplies): prompt_for_choice(['a', 'b', 'c']) def test_prompt_for_confirmation(self): """Test :func:`humanfriendly.prompts.prompt_for_confirmation()`.""" # Test some (more or less) reasonable replies that indicate agreement. for reply in 'yes', 'Yes', 'YES', 'y', 'Y': with PatchedAttribute(prompts, 'interactive_prompt', lambda p: reply): assert prompt_for_confirmation("Are you sure?") is True # Test some (more or less) reasonable replies that indicate disagreement. for reply in 'no', 'No', 'NO', 'n', 'N': with PatchedAttribute(prompts, 'interactive_prompt', lambda p: reply): assert prompt_for_confirmation("Are you sure?") is False # Test that empty replies select the default choice. for default_choice in True, False: with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): assert prompt_for_confirmation("Are you sure?", default=default_choice) is default_choice # Test that a warning is shown when no input nor a default is given. replies = ['', 'y'] with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): with CaptureOutput(merged=True) as capturer: assert prompt_for_confirmation("Are you sure?") is True assert "there's no default choice" in capturer.get_text() # Test that the default reply is shown in uppercase. with PatchedAttribute(prompts, 'interactive_prompt', lambda p: 'y'): for default_value, expected_text in (True, 'Y/n'), (False, 'y/N'), (None, 'y/n'): with CaptureOutput(merged=True) as capturer: assert prompt_for_confirmation("Are you sure?", default=default_value) is True assert expected_text in capturer.get_text() # Test that interactive prompts eventually give up on invalid replies. with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): with self.assertRaises(TooManyInvalidReplies): prompt_for_confirmation("Are you sure?") def test_prompt_for_input(self): """Test :func:`humanfriendly.prompts.prompt_for_input()`.""" with open(os.devnull) as handle: with PatchedAttribute(sys, 'stdin', handle): # If standard input isn't connected to a terminal the default value should be returned. default_value = "To seek the holy grail!" assert prompt_for_input("What is your quest?", default=default_value) == default_value # If standard input isn't connected to a terminal and no default value # is given the EOFError exception should be propagated to the caller. with self.assertRaises(EOFError): prompt_for_input("What is your favorite color?") def test_cli(self): """Test the command line interface.""" # Test that the usage message is printed by default. returncode, output = run_cli(main) assert 'Usage:' in output # Test that the usage message can be requested explicitly. returncode, output = run_cli(main, '--help') assert 'Usage:' in output # Test handling of invalid command line options. returncode, output = run_cli(main, '--unsupported-option') assert returncode != 0 # Test `humanfriendly --format-number'. returncode, output = run_cli(main, '--format-number=1234567') assert output.strip() == '1,234,567' # Test `humanfriendly --format-size'. random_byte_count = random.randint(1024, 1024 * 1024) returncode, output = run_cli(main, '--format-size=%i' % random_byte_count) assert output.strip() == format_size(random_byte_count) # Test `humanfriendly --format-size --binary'. random_byte_count = random.randint(1024, 1024 * 1024) returncode, output = run_cli(main, '--format-size=%i' % random_byte_count, '--binary') assert output.strip() == format_size(random_byte_count, binary=True) # Test `humanfriendly --format-length'. random_len = random.randint(1024, 1024 * 1024) returncode, output = run_cli(main, '--format-length=%i' % random_len) assert output.strip() == format_length(random_len) random_len = float(random_len) / 12345.6 returncode, output = run_cli(main, '--format-length=%f' % random_len) assert output.strip() == format_length(random_len) # Test `humanfriendly --format-table'. returncode, output = run_cli(main, '--format-table', '--delimiter=\t', input='1\t2\t3\n4\t5\t6\n7\t8\t9') assert output.strip() == dedent(''' ------------- | 1 | 2 | 3 | | 4 | 5 | 6 | | 7 | 8 | 9 | ------------- ''').strip() # Test `humanfriendly --format-timespan'. random_timespan = random.randint(5, 600) returncode, output = run_cli(main, '--format-timespan=%i' % random_timespan) assert output.strip() == format_timespan(random_timespan) # Test `humanfriendly --parse-size'. returncode, output = run_cli(main, '--parse-size=5 KB') assert int(output) == parse_size('5 KB') # Test `humanfriendly --parse-size'. returncode, output = run_cli(main, '--parse-size=5 YiB') assert int(output) == parse_size('5 YB', binary=True) # Test `humanfriendly --parse-length'. returncode, output = run_cli(main, '--parse-length=5 km') assert int(output) == parse_length('5 km') returncode, output = run_cli(main, '--parse-length=1.05 km') assert float(output) == parse_length('1.05 km') # Test `humanfriendly --run-command'. returncode, output = run_cli(main, '--run-command', 'bash', '-c', 'sleep 2 && exit 42') assert returncode == 42 # Test `humanfriendly --demo'. The purpose of this test is # to ensure that the demo runs successfully on all versions # of Python and outputs the expected sections (recognized by # their headings) without triggering exceptions. This was # written as a regression test after issue #28 was reported: # https://github.com/xolox/python-humanfriendly/issues/28 returncode, output = run_cli(main, '--demo') assert returncode == 0 lines = [ansi_strip(l) for l in output.splitlines()] assert "Text styles:" in lines assert "Foreground colors:" in lines assert "Background colors:" in lines assert "256 color mode (standard colors):" in lines assert "256 color mode (high-intensity colors):" in lines assert "256 color mode (216 colors):" in lines assert "256 color mode (gray scale colors):" in lines def test_ansi_style(self): """Test :func:`humanfriendly.terminal.ansi_style()`.""" assert ansi_style(bold=True) == '%s1%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(faint=True) == '%s2%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(italic=True) == '%s3%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(underline=True) == '%s4%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(inverse=True) == '%s7%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(strike_through=True) == '%s9%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(color='blue') == '%s34%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(background='blue') == '%s44%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(color='blue', bright=True) == '%s94%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(color=214) == '%s38;5;214%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(background=214) == '%s39;5;214%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(color=(0, 0, 0)) == '%s38;2;0;0;0%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(color=(255, 255, 255)) == '%s38;2;255;255;255%s' % (ANSI_CSI, ANSI_SGR) assert ansi_style(background=(50, 100, 150)) == '%s48;2;50;100;150%s' % (ANSI_CSI, ANSI_SGR) with self.assertRaises(ValueError): ansi_style(color='unknown') def test_ansi_width(self): """Test :func:`humanfriendly.terminal.ansi_width()`.""" text = "Whatever" # Make sure ansi_width() works as expected on strings without ANSI escape sequences. assert len(text) == ansi_width(text) # Wrap a text in ANSI escape sequences and make sure ansi_width() treats it as expected. wrapped = ansi_wrap(text, bold=True) # Make sure ansi_wrap() changed the text. assert wrapped != text # Make sure ansi_wrap() added additional bytes. assert len(wrapped) > len(text) # Make sure the result of ansi_width() stays the same. assert len(text) == ansi_width(wrapped) def test_ansi_wrap(self): """Test :func:`humanfriendly.terminal.ansi_wrap()`.""" text = "Whatever" # Make sure ansi_wrap() does nothing when no keyword arguments are given. assert text == ansi_wrap(text) # Make sure ansi_wrap() starts the text with the CSI sequence. assert ansi_wrap(text, bold=True).startswith(ANSI_CSI) # Make sure ansi_wrap() ends the text by resetting the ANSI styles. assert ansi_wrap(text, bold=True).endswith(ANSI_RESET) def test_html_to_ansi(self): """Test the :func:`humanfriendly.terminal.html_to_ansi()` function.""" assert html_to_ansi("Just some plain text") == "Just some plain text" # Hyperlinks. assert html_to_ansi('<a href="https://python.org">python.org</a>') == \ '\x1b[0m\x1b[4;94mpython.org\x1b[0m (\x1b[0m\x1b[4;94mhttps://python.org\x1b[0m)' # Make sure `mailto:' prefixes are stripped (they're not at all useful in a terminal). assert html_to_ansi('<a href="mailto:peter@peterodding.com">peter@peterodding.com</a>') == \ '\x1b[0m\x1b[4;94mpeter@peterodding.com\x1b[0m' # Bold text. assert html_to_ansi("Let's try <b>bold</b>") == "Let's try \x1b[0m\x1b[1mbold\x1b[0m" assert html_to_ansi("Let's try <span style=\"font-weight: bold\">bold</span>") == \ "Let's try \x1b[0m\x1b[1mbold\x1b[0m" # Italic text. assert html_to_ansi("Let's try <i>italic</i>") == \ "Let's try \x1b[0m\x1b[3mitalic\x1b[0m" assert html_to_ansi("Let's try <span style=\"font-style: italic\">italic</span>") == \ "Let's try \x1b[0m\x1b[3mitalic\x1b[0m" # Underlined text. assert html_to_ansi("Let's try <ins>underline</ins>") == \ "Let's try \x1b[0m\x1b[4munderline\x1b[0m" assert html_to_ansi("Let's try <span style=\"text-decoration: underline\">underline</span>") == \ "Let's try \x1b[0m\x1b[4munderline\x1b[0m" # Strike-through text. assert html_to_ansi("Let's try <s>strike-through</s>") == \ "Let's try \x1b[0m\x1b[9mstrike-through\x1b[0m" assert html_to_ansi("Let's try <span style=\"text-decoration: line-through\">strike-through</span>") == \ "Let's try \x1b[0m\x1b[9mstrike-through\x1b[0m" # Pre-formatted text. assert html_to_ansi("Let's try <code>pre-formatted</code>") == \ "Let's try \x1b[0m\x1b[33mpre-formatted\x1b[0m" # Text colors (with a 6 digit hexadecimal color value). assert html_to_ansi("Let's try <span style=\"color: #AABBCC\">text colors</s>") == \ "Let's try \x1b[0m\x1b[38;2;170;187;204mtext colors\x1b[0m" # Background colors (with an rgb(N, N, N) expression). assert html_to_ansi("Let's try <span style=\"background-color: rgb(50, 50, 50)\">background colors</s>") == \ "Let's try \x1b[0m\x1b[48;2;50;50;50mbackground colors\x1b[0m" # Line breaks. assert html_to_ansi("Let's try some<br>line<br>breaks") == \ "Let's try some\nline\nbreaks" # Check that decimal entities are decoded. assert html_to_ansi("&") == "&" # Check that named entities are decoded. assert html_to_ansi("&") == "&" assert html_to_ansi(">") == ">" assert html_to_ansi("<") == "<" # Check that hexadecimal entities are decoded. assert html_to_ansi("&") == "&" # Check that the text callback is actually called. def callback(text): return text.replace(':wink:', ';-)') assert ':wink:' not in html_to_ansi('<b>:wink:</b>', callback=callback) # Check that the text callback doesn't process preformatted text. assert ':wink:' in html_to_ansi('<code>:wink:</code>', callback=callback) # Try a somewhat convoluted but nevertheless real life example from my # personal chat archives that causes humanfriendly releases 4.15 and # 4.15.1 to raise an exception. assert html_to_ansi(u''' Tweakers zit er idd nog steeds:<br><br> peter@peter-work> curl -s <a href="tweakers.net">tweakers.net</a> | grep -i hosting<br> <a href="<a href="http://www.true.nl/webhosting/">http://www.true.nl/webhosting/</a>" rel="external" id="true" title="Hosting door True"></a><br> Hosting door <a href="<a href="http://www.true.nl/vps/">http://www.true.nl/vps/</a>" title="VPS hosting" rel="external">True</a> ''') def test_generate_output(self): """Test the :func:`humanfriendly.terminal.output()` function.""" text = "Standard output generated by output()" with CaptureOutput(merged=False) as capturer: output(text) self.assertEqual([text], capturer.stdout.get_lines()) self.assertEqual([], capturer.stderr.get_lines()) def test_generate_message(self): """Test the :func:`humanfriendly.terminal.message()` function.""" text = "Standard error generated by message()" with CaptureOutput(merged=False) as capturer: message(text) self.assertEqual([], capturer.stdout.get_lines()) self.assertEqual([text], capturer.stderr.get_lines()) def test_generate_warning(self): """Test the :func:`humanfriendly.terminal.warning()` function.""" from capturer import CaptureOutput text = "Standard error generated by warning()" with CaptureOutput(merged=False) as capturer: warning(text) self.assertEqual([], capturer.stdout.get_lines()) self.assertEqual([ansi_wrap(text, color='red')], self.ignore_coverage_warning(capturer.stderr)) def ignore_coverage_warning(self, stream): """ Filter out coverage.py warning from standard error. This is intended to remove the following line from the lines captured on the standard error stream: Coverage.py warning: No data was collected. (no-data-collected) """ return [line for line in stream.get_lines() if 'no-data-collected' not in line] def test_clean_output(self): """Test :func:`humanfriendly.terminal.clean_terminal_output()`.""" # Simple output should pass through unharmed (single line). assert clean_terminal_output('foo') == ['foo'] # Simple output should pass through unharmed (multiple lines). assert clean_terminal_output('foo\nbar') == ['foo', 'bar'] # Carriage returns and preceding substrings are removed. assert clean_terminal_output('foo\rbar\nbaz') == ['bar', 'baz'] # Carriage returns move the cursor to the start of the line without erasing text. assert clean_terminal_output('aaa\rab') == ['aba'] # Backspace moves the cursor one position back without erasing text. assert clean_terminal_output('aaa\b\bb') == ['aba'] # Trailing empty lines should be stripped. assert clean_terminal_output('foo\nbar\nbaz\n\n\n') == ['foo', 'bar', 'baz'] def test_find_terminal_size(self): """Test :func:`humanfriendly.terminal.find_terminal_size()`.""" lines, columns = find_terminal_size() # We really can't assert any minimum or maximum values here because it # simply doesn't make any sense; it's impossible for me to anticipate # on what environments this test suite will run in the future. assert lines > 0 assert columns > 0 # The find_terminal_size_using_ioctl() function is the default # implementation and it will likely work fine. This makes it hard to # test the fall back code paths though. However there's an easy way to # make find_terminal_size_using_ioctl() fail ... saved_stdin = sys.stdin saved_stdout = sys.stdout saved_stderr = sys.stderr try: # What do you mean this is brute force?! ;-) sys.stdin = StringIO() sys.stdout = StringIO() sys.stderr = StringIO() # Now find_terminal_size_using_ioctl() should fail even though # find_terminal_size_using_stty() might work fine. lines, columns = find_terminal_size() assert lines > 0 assert columns > 0 # There's also an ugly way to make `stty size' fail: The # subprocess.Popen class uses os.execvp() underneath, so if we # clear the $PATH it will break. saved_path = os.environ['PATH'] try: os.environ['PATH'] = '' # Now find_terminal_size_using_stty() should fail. lines, columns = find_terminal_size() assert lines > 0 assert columns > 0 finally: os.environ['PATH'] = saved_path finally: sys.stdin = saved_stdin sys.stdout = saved_stdout sys.stderr = saved_stderr def test_terminal_capabilities(self): """Test the functions that check for terminal capabilities.""" from capturer import CaptureOutput for test_stream in connected_to_terminal, terminal_supports_colors: # This test suite should be able to run interactively as well as # non-interactively, so we can't expect or demand that standard streams # will always be connected to a terminal. Fortunately Capturer enables # us to fake it :-). for stream in sys.stdout, sys.stderr: with CaptureOutput(): assert test_stream(stream) # Test something that we know can never be a terminal. with open(os.devnull) as handle: assert not test_stream(handle) # Verify that objects without isatty() don't raise an exception. assert not test_stream(object()) def test_show_pager(self): """Test :func:`humanfriendly.terminal.show_pager()`.""" original_pager = os.environ.get('PAGER', None) try: # We specifically avoid `less' because it would become awkward to # run the test suite in an interactive terminal :-). os.environ['PAGER'] = 'cat' # Generate a significant amount of random text spread over multiple # lines that we expect to be reported literally on the terminal. random_text = "\n".join(random_string(25) for i in range(50)) # Run the pager command and validate the output. with CaptureOutput() as capturer: show_pager(random_text) assert random_text in capturer.get_text() finally: if original_pager is not None: # Restore the original $PAGER value. os.environ['PAGER'] = original_pager else: # Clear the custom $PAGER value. os.environ.pop('PAGER') def test_get_pager_command(self): """Test :func:`humanfriendly.terminal.get_pager_command()`.""" # Make sure --RAW-CONTROL-CHARS isn't used when it's not needed. assert '--RAW-CONTROL-CHARS' not in get_pager_command("Usage message") # Make sure --RAW-CONTROL-CHARS is used when it's needed. assert '--RAW-CONTROL-CHARS' in get_pager_command(ansi_wrap("Usage message", bold=True)) # Make sure that less-specific options are only used when valid. options_specific_to_less = ['--no-init', '--quit-if-one-screen'] for pager in 'cat', 'less': original_pager = os.environ.get('PAGER', None) try: # Set $PAGER to `cat' or `less'. os.environ['PAGER'] = pager # Get the pager command line. command_line = get_pager_command() # Check for less-specific options. if pager == 'less': assert all(opt in command_line for opt in options_specific_to_less) else: assert not any(opt in command_line for opt in options_specific_to_less) finally: if original_pager is not None: # Restore the original $PAGER value. os.environ['PAGER'] = original_pager else: # Clear the custom $PAGER value. os.environ.pop('PAGER') def test_find_meta_variables(self): """Test :func:`humanfriendly.usage.find_meta_variables()`.""" assert sorted(find_meta_variables(""" Here's one example: --format-number=VALUE Here's another example: --format-size=BYTES A final example: --format-timespan=SECONDS This line doesn't contain a META variable. """)) == sorted(['VALUE', 'BYTES', 'SECONDS']) def test_parse_usage_simple(self): """Test :func:`humanfriendly.usage.parse_usage()` (a simple case).""" introduction, options = self.preprocess_parse_result(""" Usage: my-fancy-app [OPTIONS] Boring description. Supported options: -h, --help Show this message and exit. """) # The following fragments are (expected to be) part of the introduction. assert "Usage: my-fancy-app [OPTIONS]" in introduction assert "Boring description." in introduction assert "Supported options:" in introduction # The following fragments are (expected to be) part of the documented options. assert "-h, --help" in options assert "Show this message and exit." in options def test_parse_usage_tricky(self): """Test :func:`humanfriendly.usage.parse_usage()` (a tricky case).""" introduction, options = self.preprocess_parse_result(""" Usage: my-fancy-app [OPTIONS] Here's the introduction to my-fancy-app. Some of the lines in the introduction start with a command line option just to confuse the parsing algorithm :-) For example --an-awesome-option is still part of the introduction. Supported options: -a, --an-awesome-option Explanation why this is an awesome option. -b, --a-boring-option Explanation why this is a boring option. """) # The following fragments are (expected to be) part of the introduction. assert "Usage: my-fancy-app [OPTIONS]" in introduction assert any('still part of the introduction' in p for p in introduction) assert "Supported options:" in introduction # The following fragments are (expected to be) part of the documented options. assert "-a, --an-awesome-option" in options assert "Explanation why this is an awesome option." in options assert "-b, --a-boring-option" in options assert "Explanation why this is a boring option." in options def test_parse_usage_commas(self): """Test :func:`humanfriendly.usage.parse_usage()` against option labels containing commas.""" introduction, options = self.preprocess_parse_result(""" Usage: my-fancy-app [OPTIONS] Some introduction goes here. Supported options: -f, --first-option Explanation of first option. -s, --second-option=WITH,COMMA This should be a separate option's description. """) # The following fragments are (expected to be) part of the introduction. assert "Usage: my-fancy-app [OPTIONS]" in introduction assert "Some introduction goes here." in introduction assert "Supported options:" in introduction # The following fragments are (expected to be) part of the documented options. assert "-f, --first-option" in options assert "Explanation of first option." in options assert "-s, --second-option=WITH,COMMA" in options assert "This should be a separate option's description." in options def preprocess_parse_result(self, text): """Ignore leading/trailing whitespace in usage parsing tests.""" return tuple([p.strip() for p in r] for r in parse_usage(dedent(text))) def test_format_usage(self): """Test :func:`humanfriendly.usage.format_usage()`.""" # Test that options are highlighted. usage_text = "Just one --option" formatted_text = format_usage(usage_text) assert len(formatted_text) > len(usage_text) assert formatted_text.startswith("Just one ") # Test that the "Usage: ..." line is highlighted. usage_text = "Usage: humanfriendly [OPTIONS]" formatted_text = format_usage(usage_text) assert len(formatted_text) > len(usage_text) assert usage_text in formatted_text assert not formatted_text.startswith(usage_text) # Test that meta variables aren't erroneously highlighted. usage_text = ( "--valid-option=VALID_METAVAR\n" "VALID_METAVAR is bogus\n" "INVALID_METAVAR should not be highlighted\n" ) formatted_text = format_usage(usage_text) formatted_lines = formatted_text.splitlines() # Make sure the meta variable in the second line is highlighted. assert ANSI_CSI in formatted_lines[1] # Make sure the meta variable in the third line isn't highlighted. assert ANSI_CSI not in formatted_lines[2] def test_render_usage(self): """Test :func:`humanfriendly.usage.render_usage()`.""" assert render_usage("Usage: some-command WITH ARGS") == "**Usage:** `some-command WITH ARGS`" assert render_usage("Supported options:") == "**Supported options:**" assert 'code-block' in render_usage(dedent(""" Here comes a shell command: $ echo test test """)) assert all(token in render_usage(dedent(""" Supported options: -n, --dry-run Don't change anything. """)) for token in ('`-n`', '`--dry-run`')) def test_deprecated_args(self): """Test the deprecated_args() decorator function.""" @deprecated_args('foo', 'bar') def test_function(**options): assert options['foo'] == 'foo' assert options.get('bar') in (None, 'bar') return 42 fake_fn = MagicMock() with PatchedAttribute(warnings, 'warn', fake_fn): assert test_function('foo', 'bar') == 42 with self.assertRaises(TypeError): test_function('foo', 'bar', 'baz') assert fake_fn.was_called def test_alias_proxy_deprecation_warning(self): """Test that the DeprecationProxy class emits deprecation warnings.""" fake_fn = MagicMock() with PatchedAttribute(warnings, 'warn', fake_fn): module = sys.modules[__name__] aliases = dict(concatenate='humanfriendly.text.concatenate') proxy = DeprecationProxy(module, aliases) assert proxy.concatenate == concatenate assert fake_fn.was_called def test_alias_proxy_sphinx_compensation(self): """Test that the DeprecationProxy class emits deprecation warnings.""" with PatchedItem(sys.modules, 'sphinx', types.ModuleType('sphinx')): define_aliases(__name__, concatenate='humanfriendly.text.concatenate') assert "concatenate" in dir(sys.modules[__name__]) assert "concatenate" in get_aliases(__name__) def test_alias_proxy_sphinx_integration(self): """Test that aliases can be injected into generated documentation.""" module = sys.modules[__name__] define_aliases(__name__, concatenate='humanfriendly.text.concatenate') lines = module.__doc__.splitlines() deprecation_note_callback(app=None, what=None, name=None, obj=module, options=None, lines=lines) # Check that something was injected. assert "\n".join(lines) != module.__doc__ def test_sphinx_customizations(self): """Test the :mod:`humanfriendly.sphinx` module.""" class FakeApp(object): def __init__(self): self.callbacks = {} self.roles = {} def __documented_special_method__(self): """Documented unofficial special method.""" pass def __undocumented_special_method__(self): # Intentionally not documented :-). pass def add_role(self, name, callback): self.roles[name] = callback def connect(self, event, callback): self.callbacks.setdefault(event, []).append(callback) def bogus_usage(self): """Usage: This is not supposed to be reformatted!""" pass # Test event callback registration. fake_app = FakeApp() setup(fake_app) assert man_role == fake_app.roles['man'] assert pypi_role == fake_app.roles['pypi'] assert deprecation_note_callback in fake_app.callbacks['autodoc-process-docstring'] assert special_methods_callback in fake_app.callbacks['autodoc-skip-member'] assert usage_message_callback in fake_app.callbacks['autodoc-process-docstring'] # Test that `special methods' which are documented aren't skipped. assert special_methods_callback( app=None, what=None, name=None, obj=FakeApp.__documented_special_method__, skip=True, options=None, ) is False # Test that `special methods' which are undocumented are skipped. assert special_methods_callback( app=None, what=None, name=None, obj=FakeApp.__undocumented_special_method__, skip=True, options=None, ) is True # Test formatting of usage messages. obj/lines from humanfriendly import cli, sphinx # We expect the docstring in the `cli' module to be reformatted # (because it contains a usage message in the expected format). assert self.docstring_is_reformatted(cli) # We don't expect the docstring in the `sphinx' module to be # reformatted (because it doesn't contain a usage message). assert not self.docstring_is_reformatted(sphinx) # We don't expect the docstring of the following *method* to be # reformatted because only *module* docstrings should be reformatted. assert not self.docstring_is_reformatted(fake_app.bogus_usage) def docstring_is_reformatted(self, entity): """Check whether :func:`.usage_message_callback()` reformats a module's docstring.""" lines = trim_empty_lines(entity.__doc__).splitlines() saved_lines = list(lines) usage_message_callback( app=None, what=None, name=None, obj=entity, options=None, lines=lines, ) return lines != saved_lines def normalize_timestamp(value, ndigits=1): """ Round timestamps to the given number of digits. This helps to make the test suite less sensitive to timing issues caused by multitasking, processor scheduling, etc. """ return '%.2f' % round(float(value), ndigits=ndigits)