path: root/tests/test_history.py

# coding=utf-8
# flake8: noqa E302
"""
Test history functions of cmd2
"""
import tempfile
import os
import pickle
import sys

import pytest

# Python 3.5 had some regressions in the unitest.mock module, so use 3rd party mock if available
try:
    import mock
except ImportError:
    from unittest import mock

import cmd2
from .conftest import run_cmd, normalize, HELP_HISTORY


def test_base_help_history(base_app):
    out, err = run_cmd(base_app, 'help history')
    assert out == normalize(HELP_HISTORY)

def test_exclude_from_history(base_app, monkeypatch):
    # Set a fake editor just to make sure we have one.  We aren't really going to call it due to the mock
    base_app.editor = 'fooedit'

    # Mock out the subprocess.Popen call so we don't actually open an editor
    m = mock.MagicMock(name='Popen')
    monkeypatch.setattr("subprocess.Popen", m)

    # Run edit command
    run_cmd(base_app, 'edit')

    # Run history command
    run_cmd(base_app, 'history')

    # Verify that the history is empty
    out, err = run_cmd(base_app, 'history')
    assert out == []

    # Now run a command which isn't excluded from the history
    run_cmd(base_app, 'help')

    # And verify we have a history now ...
    out, err = run_cmd(base_app, 'history')
    expected = normalize("""    1  help""")
    assert out == expected


@pytest.fixture
def hist():
    from cmd2.parsing import Statement
    from cmd2.cmd2 import History, HistoryItem
    h = History([HistoryItem(Statement('', raw='first'), 1),
                 HistoryItem(Statement('', raw='second'), 2),
                 HistoryItem(Statement('', raw='third'), 3),
                 HistoryItem(Statement('', raw='fourth'),4)])
    return h

def test_history_class_span(hist):
    for tryit in ['*', ':', '-', 'all', 'ALL']:
        assert hist.span(tryit) == hist

    assert hist.span('3')[0].statement.raw == 'third'
    assert hist.span('-1')[0].statement.raw == 'fourth'

    span = hist.span('2..')
    assert len(span) == 3
    assert span[0].statement.raw == 'second'
    assert span[1].statement.raw == 'third'
    assert span[2].statement.raw == 'fourth'

    span = hist.span('2:')
    assert len(span) == 3
    assert span[0].statement.raw == 'second'
    assert span[1].statement.raw == 'third'
    assert span[2].statement.raw == 'fourth'

    span = hist.span('-2..')
    assert len(span) == 2
    assert span[0].statement.raw == 'third'
    assert span[1].statement.raw == 'fourth'

    span = hist.span('-2:')
    assert len(span) == 2
    assert span[0].statement.raw == 'third'
    assert span[1].statement.raw == 'fourth'

    span = hist.span('1..3')
    assert len(span) == 3
    assert span[0].statement.raw == 'first'
    assert span[1].statement.raw == 'second'
    assert span[2].statement.raw == 'third'

    span = hist.span('1:3')
    assert len(span) == 3
    assert span[0].statement.raw == 'first'
    assert span[1].statement.raw == 'second'
    assert span[2].statement.raw == 'third'

    span = hist.span('2:-1')
    assert len(span) == 3
    assert span[0].statement.raw == 'second'
    assert span[1].statement.raw == 'third'
    assert span[2].statement.raw == 'fourth'

    span = hist.span('-3:4')
    assert len(span) == 3
    assert span[0].statement.raw == 'second'
    assert span[1].statement.raw == 'third'
    assert span[2].statement.raw == 'fourth'

    span = hist.span('-4:-2')
    assert len(span) == 3
    assert span[0].statement.raw == 'first'
    assert span[1].statement.raw == 'second'
    assert span[2].statement.raw == 'third'

    span = hist.span(':-2')
    assert len(span) == 3
    assert span[0].statement.raw == 'first'
    assert span[1].statement.raw == 'second'
    assert span[2].statement.raw == 'third'

    span = hist.span('..-2')
    assert len(span) == 3
    assert span[0].statement.raw == 'first'
    assert span[1].statement.raw == 'second'
    assert span[2].statement.raw == 'third'

    value_errors = ['fred', 'fred:joe', 'a..b', '2 ..', '1 : 3', '1:0', '0:3']
    for tryit in value_errors:
        with pytest.raises(ValueError):
            hist.span(tryit)

def test_history_class_get(hist):
    assert hist.get('1').statement.raw == 'first'
    assert hist.get(3).statement.raw == 'third'
    assert hist.get('-2') == hist[-2]
    assert hist.get(-1).statement.raw == 'fourth'

    with pytest.raises(IndexError):
        hist.get(0)
    with pytest.raises(IndexError):
        hist.get('0')

    with pytest.raises(IndexError):
        hist.get('5')
    with pytest.raises(ValueError):
        hist.get('2-3')
    with pytest.raises(ValueError):
        hist.get('1..2')
    with pytest.raises(ValueError):
        hist.get('3:4')
    with pytest.raises(ValueError):
        hist.get('fred')
    with pytest.raises(ValueError):
        hist.get('')
    with pytest.raises(TypeError):
        hist.get(None)

def test_history_str_search(hist):
    items = hist.str_search('ir')
    assert len(items) == 2
    assert items[0].statement.raw == 'first'
    assert items[1].statement.raw == 'third'

    items = hist.str_search('rth')
    assert len(items) == 1
    assert items[0].statement.raw == 'fourth'

def test_history_regex_search(hist):
    items = hist.regex_search('/i.*d/')
    assert len(items) == 1
    assert items[0].statement.raw == 'third'

    items = hist.regex_search('s[a-z]+ond')
    assert len(items) == 1
    assert items[0].statement.raw == 'second'

def test_history_max_length_zero(hist):
    hist.truncate(0)
    assert len(hist) == 0

def test_history_max_length_negative(hist):
    hist.truncate(-1)
    assert len(hist) == 0

def test_history_max_length(hist):
    hist.truncate(2)
    assert len(hist) == 2
    assert hist.get(1).statement.raw == 'third'
    assert hist.get(2).statement.raw == 'fourth'

def test_base_history(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    out, err = run_cmd(base_app, 'history')
    expected = normalize("""
    1  help
    2  shortcuts
""")
    assert out == expected

    out, err = run_cmd(base_app, 'history he')
    expected = normalize("""
    1  help
""")
    assert out == expected

    out, err = run_cmd(base_app, 'history sh')
    expected = normalize("""
    2  shortcuts
""")
    assert out == expected

def test_history_script_format(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    out, err = run_cmd(base_app, 'history -s')
    expected = normalize("""
help
shortcuts
""")
    assert out == expected

def test_history_with_string_argument(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    run_cmd(base_app, 'help history')
    out, err = run_cmd(base_app, 'history help')
    expected = normalize("""
    1  help
    3  help history
""")
    assert out == expected

def test_history_expanded_with_string_argument(base_app):
    run_cmd(base_app, 'alias create sc shortcuts')
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'help history')
    run_cmd(base_app, 'sc')
    out, err = run_cmd(base_app, 'history -v shortcuts')
    expected = normalize("""
    1  alias create sc shortcuts
    4  sc
    4x shortcuts
""")
    assert out == expected

def test_history_expanded_with_regex_argument(base_app):
    run_cmd(base_app, 'alias create sc shortcuts')
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'help history')
    run_cmd(base_app, 'sc')
    out, err = run_cmd(base_app, 'history -v /sh.*cuts/')
    expected = normalize("""
    1  alias create sc shortcuts
    4  sc
    4x shortcuts
""")
    assert out == expected

def test_history_with_integer_argument(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    out, err = run_cmd(base_app, 'history 1')
    expected = normalize("""
    1  help
""")
    assert out == expected


def test_history_with_integer_span(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    run_cmd(base_app, 'help history')
    out, err = run_cmd(base_app, 'history 1..2')
    expected = normalize("""
    1  help
    2  shortcuts
""")
    assert out == expected

def test_history_with_span_start(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    run_cmd(base_app, 'help history')
    out, err = run_cmd(base_app, 'history 2:')
    expected = normalize("""
    2  shortcuts
    3  help history
""")
    assert out == expected

def test_history_with_span_end(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    run_cmd(base_app, 'help history')
    out, err = run_cmd(base_app, 'history :2')
    expected = normalize("""
    1  help
    2  shortcuts
""")
    assert out == expected

def test_history_with_span_index_error(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'help history')
    run_cmd(base_app, '!ls -hal :')
    with pytest.raises(ValueError):
        base_app.onecmd('history "hal :"')

def test_history_output_file(base_app):
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'shortcuts')
    run_cmd(base_app, 'help history')

    fd, fname = tempfile.mkstemp(prefix='', suffix='.txt')
    os.close(fd)
    run_cmd(base_app, 'history -o "{}"'.format(fname))
    expected = normalize('\n'.join(['help', 'shortcuts', 'help history']))
    with open(fname) as f:
        content = normalize(f.read())
    assert content == expected

def test_history_edit(base_app, monkeypatch):
    # Set a fake editor just to make sure we have one.  We aren't really
    # going to call it due to the mock
    base_app.editor = 'fooedit'

    # Mock out the Popen call so we don't actually open an editor
    m = mock.MagicMock(name='Popen')
    monkeypatch.setattr("subprocess.Popen", m)

    # Run help command just so we have a command in history
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'history -e 1')

    # We have an editor, so should expect a Popen call
    m.assert_called_once()

def test_history_run_all_commands(base_app):
    # make sure we refuse to run all commands as a default
    run_cmd(base_app, 'shortcuts')
    out, err = run_cmd(base_app, 'history -r')
    # this should generate an error, but we don't currently have a way to
    # capture stderr in these tests. So we assume that if we got nothing on
    # standard out, that the error occurred because if the command executed
    # then we should have a list of shortcuts in our output
    assert out == []

def test_history_run_one_command(base_app):
    out1, err1 = run_cmd(base_app, 'help')
    out2, err2 = run_cmd(base_app, 'history -r 1')
    assert out1 == out2

def test_history_clear(base_app):
    # Add commands to history
    run_cmd(base_app, 'help')
    run_cmd(base_app, 'alias')

    # Make sure history has items
    out, err = run_cmd(base_app, 'history')
    assert out

    # Clear the history
    run_cmd(base_app, 'history --clear')

    # Make sure history is empty
    out, err = run_cmd(base_app, 'history')
    assert out == []

def test_history_verbose_with_other_options(base_app):
    # make sure -v shows a usage error if any other options are present
    options_to_test = ['-r', '-e', '-o file', '-t file', '-c', '-x']
    for opt in options_to_test:
        out, err = run_cmd(base_app, 'history -v ' + opt)
        assert len(out) == 3
        assert out[1].startswith('Usage:')

def test_history_verbose(base_app):
    # validate function of -v option
    run_cmd(base_app, 'alias create s shortcuts')
    run_cmd(base_app, 's')
    out, err = run_cmd(base_app, 'history -v')
    assert len(out) == 3
    # TODO test for basic formatting once we figure it out

def test_history_script_with_invalid_options(base_app):
    # make sure -s shows a usage error if -c, -r, -e, -o, or -t are present
    options_to_test = ['-r', '-e', '-o file', '-t file', '-c']
    for opt in options_to_test:
        out, err = run_cmd(base_app, 'history -s ' + opt)
        assert len(out) == 3
        assert out[1].startswith('Usage:')

def test_history_script(base_app):
    cmds = ['alias create s shortcuts', 's']
    for cmd in cmds:
        run_cmd(base_app, cmd)
    out, err = run_cmd(base_app, 'history -s')
    assert out == cmds

def test_history_expanded_with_invalid_options(base_app):
    # make sure -x shows a usage error if -c, -r, -e, -o, or -t are present
    options_to_test = ['-r', '-e', '-o file', '-t file', '-c']
    for opt in options_to_test:
        out, err = run_cmd(base_app, 'history -x ' + opt)
        assert len(out) == 3
        assert out[1].startswith('Usage:')

def test_history_expanded(base_app):
    # validate function of -x option
    cmds = ['alias create s shortcuts', 's']
    for cmd in cmds:
        run_cmd(base_app, cmd)
    out, err = run_cmd(base_app, 'history -x')
    expected = ['    1  alias create s shortcuts', '    2  shortcuts']
    assert out == expected

def test_history_script_expanded(base_app):
    # validate function of -s -x options together
    cmds = ['alias create s shortcuts', 's']
    for cmd in cmds:
        run_cmd(base_app, cmd)
    out, err = run_cmd(base_app, 'history -sx')
    expected = ['alias create s shortcuts', 'shortcuts']
    assert out == expected


#####
#
# readline tests
#
#####
def test_readline_remove_history_item(base_app):
    from cmd2.rl_utils import readline
    assert readline.get_current_history_length() == 0
    readline.add_history('this is a test')
    assert readline.get_current_history_length() == 1
    readline.remove_history_item(0)
    assert readline.get_current_history_length() == 0


@pytest.fixture(scope="session")
def hist_file():
    fd, filename = tempfile.mkstemp(prefix='hist_file', suffix='.txt')
    os.close(fd)
    yield filename
    # teardown code
    try:
        os.remove(filename)
    except FileNotFoundError:
        pass

def test_bad_history_file_path(capsys, request):
    # Use a directory path as the history file
    test_dir = os.path.dirname(request.module.__file__)

    # Create a new cmd2 app
    cmd2.Cmd(persistent_history_file=test_dir)
    _, err = capsys.readouterr()

    assert 'is a directory' in err

def test_history_file_conversion_no_truncate_on_init(hist_file, capsys):
    # test the code that converts a plain text history file to a pickle binary
    # history file

    # first we need some plain text commands in the history file
    with open(hist_file, 'w') as hfobj:
        hfobj.write('help\n')
        hfobj.write('alias\n')
        hfobj.write('alias create s shortcuts\n')

    # Create a new cmd2 app
    cmd2.Cmd(persistent_history_file=hist_file)

    # history should be initialized, but the file on disk should
    # still be plain text
    with open(hist_file, 'r') as hfobj:
        histlist= hfobj.readlines()

    assert len(histlist) == 3
    # history.get() is overridden to be one based, not zero based
    assert histlist[0]== 'help\n'
    assert histlist[1] == 'alias\n'
    assert histlist[2] == 'alias create s shortcuts\n'

def test_history_populates_readline(hist_file):
    # - create a cmd2 with persistent history
    app = cmd2.Cmd(persistent_history_file=hist_file)
    run_cmd(app, 'help')
    run_cmd(app, 'shortcuts')
    run_cmd(app, 'shortcuts')
    run_cmd(app, 'alias')

    # call the private method which is registered to write history at exit
    app._persist_history_on_exit()
    # - create a new cmd2 with persistent history
    app = cmd2.Cmd(persistent_history_file=hist_file)

    assert len(app.history) == 4
    assert app.history.get(1).statement.raw == 'help'
    assert app.history.get(2).statement.raw == 'shortcuts'
    assert app.history.get(3).statement.raw == 'shortcuts'
    assert app.history.get(4).statement.raw == 'alias'

    # readline only adds a single entry for multiple sequential identical commands
    # so we check to make sure that cmd2 populated the readline history
    # using the same rules
    from cmd2.rl_utils import readline
    assert readline.get_current_history_length() == 3
    assert readline.get_history_item(1) == 'help'
    assert readline.get_history_item(2) == 'shortcuts'
    assert readline.get_history_item(3) == 'alias'