MirroredRepos/thefuck
1
0
Fork 0
mirror of https://github.com/nvbn/thefuck.git synced 2024-10-05 18:31:10 +01:00
Code Issues Releases Wiki Activity

#682: Unify work with output in classic and instant mode

Browse Source
This commit is contained in:
Vladimir Iakovlev 2017-08-31 17:58:56 +02:00
parent 96843fc6cd
commit 4625d8503d
237 changed files with 1322 additions and 1332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
tests/rules/test_ag_literal.py
View File

@ -1,25 +1,25 @@
import pytest
from thefuck.rules.ag_literal import get_new_command, match
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return ('ERR: Bad regex! pcre_compile() failed at position 1: missing )\n'
'If you meant to search for a literal string, run ag with -Q\n')
@pytest.mark.parametrize('script', ['ag \('])
def test_match(script, stderr):
assert match(Command(script=script, stderr=stderr))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['ag foo'])
def test_not_match(script):
assert not match(Command(script=script))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, new_cmd', [
('ag \(', 'ag -Q \(')])
def test_get_new_command(script, new_cmd, stderr):
assert get_new_command((Command(script=script, stderr=stderr))) == new_cmd
def test_get_new_command(script, new_cmd, output):
assert get_new_command((Command(script, output))) == new_cmd

26
tests/rules/test_apt_get.py
View File

@ -1,14 +1,14 @@
import pytest
from thefuck.rules.apt_get import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command, packages', [
(Command(script='vim', stderr='vim: command not found'),
(Command('vim', 'vim: command not found'),
[('vim', 'main'), ('vim-tiny', 'main')]),
(Command(script='sudo vim', stderr='vim: command not found'),
(Command('sudo vim', 'vim: command not found'),
[('vim', 'main'), ('vim-tiny', 'main')]),
(Command(script='vim', stderr="The program 'vim' is currently not installed. You can install it by typing: sudo apt install vim"),
(Command('vim', "The program 'vim' is currently not installed. You can install it by typing: sudo apt install vim"),
[('vim', 'main'), ('vim-tiny', 'main')])])
def test_match(mocker, command, packages):
mocker.patch('thefuck.rules.apt_get.which', return_value=None)
@ -20,13 +20,13 @@ def test_match(mocker, command, packages):
@pytest.mark.parametrize('command, packages, which', [
(Command(script='a_bad_cmd', stderr='a_bad_cmd: command not found'),
(Command('a_bad_cmd', 'a_bad_cmd: command not found'),
[], None),
(Command(script='vim', stderr=''), [], None),
(Command(), [], None),
(Command(script='vim', stderr='vim: command not found'),
(Command('vim', ''), [], None),
(Command('', ''), [], None),
(Command('vim', 'vim: command not found'),
['vim'], '/usr/bin/vim'),
(Command(script='sudo vim', stderr='vim: command not found'),
(Command('sudo vim', 'vim: command not found'),
['vim'], '/usr/bin/vim')])
def test_not_match(mocker, command, packages, which):
mocker.patch('thefuck.rules.apt_get.which', return_value=which)
@ -38,14 +38,14 @@ def test_not_match(mocker, command, packages, which):
@pytest.mark.parametrize('command, new_command, packages', [
(Command('vim'), 'sudo apt-get install vim && vim',
(Command('vim', ''), 'sudo apt-get install vim && vim',
[('vim', 'main'), ('vim-tiny', 'main')]),
(Command('convert'), 'sudo apt-get install imagemagick && convert',
(Command('convert', ''), 'sudo apt-get install imagemagick && convert',
[('imagemagick', 'main'),
('graphicsmagick-imagemagick-compat', 'universe')]),
(Command('sudo vim'), 'sudo apt-get install vim && sudo vim',
(Command('sudo vim', ''), 'sudo apt-get install vim && sudo vim',
[('vim', 'main'), ('vim-tiny', 'main')]),
(Command('sudo convert'), 'sudo apt-get install imagemagick && sudo convert',
(Command('sudo convert', ''), 'sudo apt-get install imagemagick && sudo convert',
[('imagemagick', 'main'),
('graphicsmagick-imagemagick-compat', 'universe')])])
def test_get_new_command(mocker, command, new_command, packages):

23
tests/rules/test_apt_get_search.py
View File

@ -1,25 +1,26 @@
import pytest
from thefuck.rules.apt_get_search import get_new_command, match
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command('apt-get search foo'))
assert match(Command('apt-get search foo', ''))
@pytest.mark.parametrize('command', [
Command('apt-cache search foo'),
Command('aptitude search foo'),
Command('apt search foo'),
Command('apt-get install foo'),
Command('apt-get source foo'),
Command('apt-get clean'),
Command('apt-get remove'),
Command('apt-get update')
Command('apt-cache search foo', ''),
Command('aptitude search foo', ''),
Command('apt search foo', ''),
Command('apt-get install foo', ''),
Command('apt-get source foo', ''),
Command('apt-get clean', ''),
Command('apt-get remove', ''),
Command('apt-get update', '')
])
def test_not_match(command):
assert not match(command)
def test_get_new_command():
assert get_new_command(Command('apt-get search foo')) == 'apt-cache search foo'
new_command = get_new_command(Command('apt-get search foo', ''))
assert new_command == 'apt-cache search foo'

20
tests/rules/test_apt_invalid_operation.py
View File

@ -1,6 +1,6 @@
from io import BytesIO
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.apt_invalid_operation import match, get_new_command, \
_get_operations
@ -77,19 +77,19 @@ apt_get_operations = ['update', 'upgrade', 'install', 'remove', 'autoremove',
'changelog', 'download']
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('apt', invalid_operation('saerch')),
('apt-get', invalid_operation('isntall')),
('apt-cache', invalid_operation('rumove'))])
def test_match(script, stderr):
assert match(Command(script, stderr=stderr))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('vim', invalid_operation('vim')),
('apt-get', "")])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.fixture
@ -111,12 +111,12 @@ def test_get_operations(set_help, app, help_text, operations):
assert _get_operations(app) == operations
@pytest.mark.parametrize('script, stderr, help_text, result', [
@pytest.mark.parametrize('script, output, help_text, result', [
('apt-get isntall vim', invalid_operation('isntall'),
apt_get_help, 'apt-get install vim'),
('apt saerch vim', invalid_operation('saerch'),
apt_help, 'apt search vim'),
])
def test_get_new_command(set_help, stderr, script, help_text, result):
def test_get_new_command(set_help, output, script, help_text, result):
set_help(help_text)
assert get_new_command(Command(script, stderr=stderr))[0] == result
assert get_new_command(Command(script, output))[0] == result

16
tests/rules/test_aws_cli.py
View File

@ -1,7 +1,7 @@
import pytest
from thefuck.rules.aws_cli import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
no_suggestions = '''\
@ -77,25 +77,25 @@ Invalid choice: 't-item', maybe you meant:
@pytest.mark.parametrize('command', [
Command('aws dynamdb scan', stderr=misspelled_command),
Command('aws dynamodb scn', stderr=misspelled_subcommand),
Command('aws dynamdb scan', misspelled_command),
Command('aws dynamodb scn', misspelled_subcommand),
Command('aws dynamodb t-item',
stderr=misspelled_subcommand_with_multiple_options)])
misspelled_subcommand_with_multiple_options)])
def test_match(command):
assert match(command)
def test_not_match():
assert not match(Command('aws dynamodb invalid', stderr=no_suggestions))
assert not match(Command('aws dynamodb invalid', no_suggestions))
@pytest.mark.parametrize('command, result', [
(Command('aws dynamdb scan', stderr=misspelled_command),
(Command('aws dynamdb scan', misspelled_command),
['aws dynamodb scan']),
(Command('aws dynamodb scn', stderr=misspelled_subcommand),
(Command('aws dynamodb scn', misspelled_subcommand),
['aws dynamodb scan']),
(Command('aws dynamodb t-item',
stderr=misspelled_subcommand_with_multiple_options),
misspelled_subcommand_with_multiple_options),
['aws dynamodb put-item', 'aws dynamodb get-item'])])
def test_get_new_command(command, result):
assert get_new_command(command) == result

12
tests/rules/test_brew_install.py
View File

@ -1,7 +1,7 @@
import pytest
from thefuck.rules.brew_install import match, get_new_command
from thefuck.rules.brew_install import _get_formulas
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -28,19 +28,19 @@ def _is_not_okay_to_test():
def test_match(brew_no_available_formula, brew_already_installed,
brew_install_no_argument):
assert match(Command('brew install elsticsearch',
stderr=brew_no_available_formula))
brew_no_available_formula))
assert not match(Command('brew install git',
stderr=brew_already_installed))
assert not match(Command('brew install', stderr=brew_install_no_argument))
brew_already_installed))
assert not match(Command('brew install', brew_install_no_argument))
@pytest.mark.skipif(_is_not_okay_to_test(),
reason='No need to run if there\'s no formula')
def test_get_new_command(brew_no_available_formula):
assert get_new_command(Command('brew install elsticsearch',
stderr=brew_no_available_formula))\
brew_no_available_formula))\
== 'brew install elasticsearch'
assert get_new_command(Command('brew install aa',
stderr=brew_no_available_formula))\
brew_no_available_formula))\
!= 'brew install aha'

15
tests/rules/test_brew_link.py
View File

@ -1,10 +1,10 @@
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.brew_link import get_new_command, match
@pytest.fixture
def stderr():
def output():
return ("Error: Could not symlink bin/gcp\n"
"Target /usr/local/bin/gcp\n"
"already exists. You may want to remove it:\n"
@ -23,16 +23,15 @@ def new_command(formula):
@pytest.mark.parametrize('script', ['brew link coreutils', 'brew ln coreutils'])
def test_match(stderr, script):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['brew link coreutils'])
def test_not_match(script):
stderr = ''
assert not match(Command(script=script, stderr=stderr))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, formula, ', [('brew link coreutils', 'coreutils')])
def test_get_new_command(stderr, new_command, script, formula):
assert get_new_command(Command(script=script, stderr=stderr)) == new_command
def test_get_new_command(output, new_command, script, formula):
assert get_new_command(Command(script, output)) == new_command

16
tests/rules/test_brew_uninstall.py
View File

@ -1,10 +1,10 @@
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.brew_uninstall import get_new_command, match
@pytest.fixture
def stdout():
def output():
return ("Uninstalling /usr/local/Cellar/tbb/4.4-20160916... (118 files, 1.9M)\n"
"tbb 4.4-20160526, 4.4-20160722 are still installed.\n"
"Remove all versions with `brew uninstall --force tbb`.\n")
@ -16,16 +16,16 @@ def new_command(formula):
@pytest.mark.parametrize('script', ['brew uninstall tbb', 'brew rm tbb', 'brew remove tbb'])
def test_match(stdout, script):
assert match(Command(script=script, stdout=stdout))
def test_match(output, script):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['brew remove gnuplot'])
def test_not_match(script):
stdout = 'Uninstalling /usr/local/Cellar/gnuplot/5.0.4_1... (44 files, 2.3M)\n'
assert not match(Command(script=script, stdout=stdout))
output = 'Uninstalling /usr/local/Cellar/gnuplot/5.0.4_1... (44 files, 2.3M)\n'
assert not match(Command(script, output))
@pytest.mark.parametrize('script, formula, ', [('brew uninstall tbb', 'tbb')])
def test_get_new_command(stdout, new_command, script, formula):
assert get_new_command(Command(script=script, stdout=stdout)) == new_command
def test_get_new_command(output, new_command, script, formula):
assert get_new_command(Command(script, output)) == new_command

10
tests/rules/test_brew_unknown_command.py
View File

@ -1,7 +1,7 @@
import pytest
from thefuck.rules.brew_unknown_command import match, get_new_command
from thefuck.rules.brew_unknown_command import _brew_commands
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -15,15 +15,15 @@ def brew_unknown_cmd2():
def test_match(brew_unknown_cmd):
assert match(Command('brew inst', stderr=brew_unknown_cmd))
assert match(Command('brew inst', brew_unknown_cmd))
for command in _brew_commands():
assert not match(Command('brew ' + command))
assert not match(Command('brew ' + command, ''))
def test_get_new_command(brew_unknown_cmd, brew_unknown_cmd2):
assert (get_new_command(Command('brew inst', stderr=brew_unknown_cmd))
assert (get_new_command(Command('brew inst', brew_unknown_cmd))
== ['brew list', 'brew install', 'brew uninstall'])
cmds = get_new_command(Command('brew instaa', stderr=brew_unknown_cmd2))
cmds = get_new_command(Command('brew instaa', brew_unknown_cmd2))
assert 'brew install' in cmds
assert 'brew uninstall' in cmds

14
tests/rules/test_brew_update_formula.py
View File

@ -1,10 +1,10 @@
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.brew_update_formula import get_new_command, match
@pytest.fixture
def stderr():
def output():
return ("Error: This command updates brew itself, and does not take formula"
" names.\nUse 'brew upgrade <formula>'.")
@ -15,16 +15,16 @@ def new_command(formula):
@pytest.mark.parametrize('script', ['brew update foo', 'brew update bar zap'])
def test_match(stderr, script):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['brew upgrade foo', 'brew update'])
def test_not_match(script):
assert not match(Command(script=script, stderr=''))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, formula, ', [
('brew update foo', 'foo'), ('brew update bar zap', 'bar zap')])
def test_get_new_command(stderr, new_command, script, formula):
assert get_new_command(Command(script=script, stderr=stderr)) == new_command
def test_get_new_command(output, new_command, script, formula):
assert get_new_command(Command(script, output)) == new_command

6
tests/rules/test_brew_upgrade.py
View File

@ -1,15 +1,15 @@
import pytest
from thefuck.rules.brew_upgrade import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='brew upgrade')])
Command('brew upgrade', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('brew upgrade'), 'brew upgrade --all')])
(Command('brew upgrade', ''), 'brew upgrade --all')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

10
tests/rules/test_cargo_no_command.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.cargo_no_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
no_such_subcommand_old = """No such subcommand
@ -15,14 +15,14 @@ no_such_subcommand = """error: no such subcommand
@pytest.mark.parametrize('command', [
Command(script='cargo buid', stderr=no_such_subcommand_old),
Command(script='cargo buils', stderr=no_such_subcommand)])
Command('cargo buid', no_such_subcommand_old),
Command('cargo buils', no_such_subcommand)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('cargo buid', stderr=no_such_subcommand_old), 'cargo build'),
(Command('cargo buils', stderr=no_such_subcommand), 'cargo build')])
(Command('cargo buid', no_such_subcommand_old), 'cargo build'),
(Command('cargo buils', no_such_subcommand), 'cargo build')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

16
tests/rules/test_cd_mkdir.py
View File

@ -1,25 +1,25 @@
import pytest
from thefuck.rules.cd_mkdir import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='cd foo', stderr='cd: foo: No such file or directory'),
Command(script='cd foo/bar/baz',
stderr='cd: foo: No such file or directory'),
Command(script='cd foo/bar/baz', stderr='cd: can\'t cd to foo/bar/baz')])
Command('cd foo', 'cd: foo: No such file or directory'),
Command('cd foo/bar/baz',
'cd: foo: No such file or directory'),
Command('cd foo/bar/baz', 'cd: can\'t cd to foo/bar/baz')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='cd foo', stderr=''), Command()])
Command('cd foo', ''), Command('', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('cd foo'), 'mkdir -p foo && cd foo'),
(Command('cd foo/bar/baz'), 'mkdir -p foo/bar/baz && cd foo/bar/baz')])
(Command('cd foo', ''), 'mkdir -p foo && cd foo'),
(Command('cd foo/bar/baz', ''), 'mkdir -p foo/bar/baz && cd foo/bar/baz')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

9
tests/rules/test_cd_parent.py
View File

@ -1,12 +1,11 @@
from thefuck.rules.cd_parent import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command('cd..', stderr='cd..: command not found'))
assert not match(Command())
assert match(Command('cd..', 'cd..: command not found'))
assert not match(Command('', ''))
def test_get_new_command():
assert get_new_command(
Command('cd..')) == 'cd ..'
assert get_new_command(Command('cd..', '')) == 'cd ..'

16
tests/rules/test_chmod_x.py
View File

@ -1,5 +1,5 @@
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.chmod_x import match, get_new_command
@ -14,26 +14,26 @@ def file_access(mocker):
@pytest.mark.usefixtures('file_exists', 'file_access')
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('./gradlew build', 'gradlew: Permission denied'),
('./install.sh --help', 'install.sh: permission denied')])
def test_match(script, stderr):
assert match(Command(script, stderr=stderr))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script, stderr, exists, callable', [
@pytest.mark.parametrize('script, output, exists, callable', [
('./gradlew build', 'gradlew: Permission denied', True, True),
('./gradlew build', 'gradlew: Permission denied', False, False),
('./gradlew build', 'gradlew: error', True, False),
('gradlew build', 'gradlew: Permission denied', True, False)])
def test_not_match(file_exists, file_access, script, stderr, exists, callable):
def test_not_match(file_exists, file_access, script, output, exists, callable):
file_exists.return_value = exists
file_access.return_value = callable
assert not match(Command(script, stderr=stderr))
assert not match(Command(script, output))
@pytest.mark.parametrize('script, result', [
('./gradlew build', 'chmod +x gradlew && ./gradlew build'),
('./install.sh --help', 'chmod +x install.sh && ./install.sh --help')])
def test_get_new_command(script, result):
assert get_new_command(Command(script)) == result
assert get_new_command(Command(script, '')) == result

12
tests/rules/test_composer_not_command.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.composer_not_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -41,16 +41,16 @@ def composer_not_command_one_of_this():
def test_match(composer_not_command, composer_not_command_one_of_this):
assert match(Command('composer udpate',
stderr=composer_not_command))
composer_not_command))
assert match(Command('composer pdate',
stderr=composer_not_command_one_of_this))
assert not match(Command('ls update', stderr=composer_not_command))
composer_not_command_one_of_this))
assert not match(Command('ls update', composer_not_command))
def test_get_new_command(composer_not_command, composer_not_command_one_of_this):
assert (get_new_command(Command('composer udpate',
stderr=composer_not_command))
composer_not_command))
== 'composer update')
assert (get_new_command(Command('composer pdate',
stderr=composer_not_command_one_of_this))
composer_not_command_one_of_this))
== 'composer selfupdate')

16
tests/rules/test_cp_omitting_directory.py
View File

@ -1,22 +1,22 @@
import pytest
from thefuck.rules.cp_omitting_directory import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('cp dir', 'cp: dor: is a directory'),
('cp dir', "cp: omitting directory 'dir'")])
def test_match(script, stderr):
assert match(Command(script, stderr=stderr))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('some dir', 'cp: dor: is a directory'),
('some dir', "cp: omitting directory 'dir'"),
('cp dir', '')])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
def test_not_match(script, output):
assert not match(Command(script, output))
def test_get_new_command():
assert get_new_command(Command(script='cp dir')) == 'cp -a dir'
assert get_new_command(Command('cp dir', '')) == 'cp -a dir'

8
tests/rules/test_dirty_untar.py
View File

@ -3,7 +3,7 @@ import pytest
import tarfile
from thefuck.rules.dirty_untar import match, get_new_command, side_effect, \
tar_extensions # noqa: E126
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -52,7 +52,7 @@ parametrize_script = pytest.mark.parametrize('script, fixed', [
@parametrize_script
def test_match(ext, tar_error, filename, unquoted, quoted, script, fixed):
tar_error(unquoted.format(ext))
assert match(Command(script=script.format(filename.format(ext))))
assert match(Command(script.format(filename.format(ext)), ''))
@parametrize_extensions
@ -60,7 +60,7 @@ def test_match(ext, tar_error, filename, unquoted, quoted, script, fixed):
@parametrize_script
def test_side_effect(ext, tar_error, filename, unquoted, quoted, script, fixed):
tar_error(unquoted.format(ext))
side_effect(Command(script=script.format(filename.format(ext))), None)
side_effect(Command(script.format(filename.format(ext)), ''), None)
assert set(os.listdir('.')) == {unquoted.format(ext), 'd'}
@ -69,5 +69,5 @@ def test_side_effect(ext, tar_error, filename, unquoted, quoted, script, fixed):
@parametrize_script
def test_get_new_command(ext, tar_error, filename, unquoted, quoted, script, fixed):
tar_error(unquoted.format(ext))
assert (get_new_command(Command(script=script.format(filename.format(ext))))
assert (get_new_command(Command(script.format(filename.format(ext)), ''))
== fixed.format(dir=quoted.format(''), filename=filename.format(ext)))

8
tests/rules/test_dirty_unzip.py
View File

@ -4,7 +4,7 @@ import os
import pytest
import zipfile
from thefuck.rules.dirty_unzip import match, get_new_command, side_effect
from tests.utils import Command
from thefuck.types import Command
from unicodedata import normalize
@ -42,7 +42,7 @@ def zip_error(tmpdir):
(u'unzip foo.zip', u'foo.zip')])
def test_match(zip_error, script, filename):
zip_error(filename)
assert match(Command(script=script))
assert match(Command(script, ''))
@pytest.mark.parametrize('script,filename', [
@ -52,7 +52,7 @@ def test_match(zip_error, script, filename):
(u'unzip foo.zip', u'foo.zip')])
def test_side_effect(zip_error, script, filename):
zip_error(filename)
side_effect(Command(script=script), None)
side_effect(Command(script, ''), None)
dir_list = os.listdir(u'.')
if filename not in set(dir_list):
@ -68,4 +68,4 @@ def test_side_effect(zip_error, script, filename):
(u'unzip foo.zip', u'unzip foo.zip -d foo', u'foo.zip')])
def test_get_new_command(zip_error, script, fixed, filename):
zip_error(filename)
assert get_new_command(Command(script=script)) == fixed
assert get_new_command(Command(script, '')) == fixed

18
tests/rules/test_django_south_ghost.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.django_south_ghost import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''Traceback (most recent call last):
File "/home/nvbn/work/.../bin/python", line 42, in <module>
exec(compile(__file__f.read(), __file__, "exec"))
@ -40,14 +40,14 @@ south.exceptions.GhostMigrations:
''' # noqa
def test_match(stderr):
assert match(Command('./manage.py migrate', stderr=stderr))
assert match(Command('python manage.py migrate', stderr=stderr))
assert not match(Command('./manage.py migrate'))
assert not match(Command('app migrate', stderr=stderr))
assert not match(Command('./manage.py test', stderr=stderr))
def test_match(output):
assert match(Command('./manage.py migrate', output))
assert match(Command('python manage.py migrate', output))
assert not match(Command('./manage.py migrate', ''))
assert not match(Command('app migrate', output))
assert not match(Command('./manage.py test', output))
def test_get_new_command():
assert get_new_command(Command('./manage.py migrate auth'))\
assert get_new_command(Command('./manage.py migrate auth', ''))\
== './manage.py migrate auth --delete-ghost-migrations'

18
tests/rules/test_django_south_merge.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.django_south_merge import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''Running migrations for app:
! Migration app:0003_auto... should not have been applied before app:0002_auto__add_field_query_due_date_ but was.
Traceback (most recent call last):
@ -30,14 +30,14 @@ The following options are available:
'''
def test_match(stderr):
assert match(Command('./manage.py migrate', stderr=stderr))
assert match(Command('python manage.py migrate', stderr=stderr))
assert not match(Command('./manage.py migrate'))
assert not match(Command('app migrate', stderr=stderr))
assert not match(Command('./manage.py test', stderr=stderr))
def test_match(output):
assert match(Command('./manage.py migrate', output))
assert match(Command('python manage.py migrate', output))
assert not match(Command('./manage.py migrate', ''))
assert not match(Command('app migrate', output))
assert not match(Command('./manage.py test', output))
def test_get_new_command():
assert (get_new_command(Command('./manage.py migrate auth'))
assert (get_new_command(Command('./manage.py migrate auth', ''))
== './manage.py migrate auth --merge')

16
tests/rules/test_docker_not_command.py
View File

@ -1,6 +1,6 @@
import pytest
from io import BytesIO
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.docker_not_command import get_new_command, match
@ -104,20 +104,20 @@ Run 'docker COMMAND --help' for more information on a command.
return mock
def stderr(cmd):
def output(cmd):
return "docker: '{}' is not a docker command.\n" \
"See 'docker --help'.".format(cmd)
def test_match():
assert match(Command('docker pes', stderr=stderr('pes')))
assert match(Command('docker pes', output('pes')))
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('docker ps', ''),
('cat pes', stderr('pes'))])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
('cat pes', output('pes'))])
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.usefixtures('docker_help')
@ -125,5 +125,5 @@ def test_not_match(script, stderr):
('pes', ['ps', 'push', 'pause']),
('tags', ['tag', 'stats', 'images'])])
def test_get_new_command(wrong, fixed):
command = Command('docker {}'.format(wrong), stderr=stderr(wrong))
command = Command('docker {}'.format(wrong), output(wrong))
assert get_new_command(command) == ['docker {}'.format(x) for x in fixed]

10
tests/rules/test_dry.py
View File

@ -1,17 +1,17 @@
import pytest
from thefuck.rules.dry import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='cd cd foo'),
Command(script='git git push origin/master')])
Command('cd cd foo', ''),
Command('git git push origin/master', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('cd cd foo'), 'cd foo'),
(Command('git git push origin/master'), 'git push origin/master')])
(Command('cd cd foo', ''), 'cd foo'),
(Command('git git push origin/master', ''), 'git push origin/master')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

19
tests/rules/test_fab_command_not_found.py
View File

@ -1,13 +1,12 @@
import pytest
from thefuck.rules.fab_command_not_found import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
stderr = '''
output = '''
Warning: Command(s) not found:
extenson
deloyp
'''
stdout = '''
Available commands:
update_config
@ -21,16 +20,16 @@ Available commands:
@pytest.mark.parametrize('command', [
Command('fab extenson', stderr=stderr),
Command('fab deloyp', stderr=stderr),
Command('fab extenson deloyp', stderr=stderr)])
Command('fab extenson', output),
Command('fab deloyp', output),
Command('fab extenson deloyp', output)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('gulp extenson', stderr=stderr),
Command('fab deloyp')])
Command('gulp extenson', output),
Command('fab deloyp', '')])
def test_not_match(command):
assert not match(command)
@ -45,5 +44,5 @@ def test_not_match(command):
'fab prepare_extension:version=2016 deploy:beta=true -H the.fuck'),
])
def test_get_new_command(script, result):
command = Command(script, stdout, stderr)
command = Command(script, output)
assert get_new_command(command) == result

10
tests/rules/test_fix_alt_space.py
View File

@ -1,7 +1,7 @@
# -*- encoding: utf-8 -*-
from thefuck.rules.fix_alt_space import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
def test_match():
@ -11,12 +11,12 @@ def test_match():
"""
assert match(Command(u'ps -ef | grep foo',
stderr=u'-bash:  grep: command not found'))
assert not match(Command('ps -ef | grep foo'))
assert not match(Command())
u'-bash:  grep: command not found'))
assert not match(Command('ps -ef | grep foo', ''))
assert not match(Command('', ''))
def test_get_new_command():
""" Replace the Alt+Space character by a simple space """
assert (get_new_command(Command(u'ps -ef | grep foo'))
assert (get_new_command(Command(u'ps -ef | grep foo', ''))
== 'ps -ef | grep foo')

58
tests/rules/test_fix_file.py
View File

@ -3,12 +3,12 @@
import pytest
import os
from thefuck.rules.fix_file import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
# (script, file, line, col (or None), stdout, stderr)
# (script, file, line, col (or None), output)
tests = (
('gcc a.c', 'a.c', 3, 1, '',
('gcc a.c', 'a.c', 3, 1,
"""
a.c: In function 'main':
a.c:3:1: error: expected expression before '}' token
@ -16,47 +16,47 @@ a.c:3:1: error: expected expression before '}' token
^
"""),
('clang a.c', 'a.c', 3, 1, '',
('clang a.c', 'a.c', 3, 1,
"""
a.c:3:1: error: expected expression
}
^
"""),
('perl a.pl', 'a.pl', 3, None, '',
('perl a.pl', 'a.pl', 3, None,
"""
syntax error at a.pl line 3, at EOF
Execution of a.pl aborted due to compilation errors.
"""),
('perl a.pl', 'a.pl', 2, None, '',
('perl a.pl', 'a.pl', 2, None,
"""
Search pattern not terminated at a.pl line 2.
"""),
('sh a.sh', 'a.sh', 2, None, '',
('sh a.sh', 'a.sh', 2, None,
"""
a.sh: line 2: foo: command not found
"""),
('zsh a.sh', 'a.sh', 2, None, '',
('zsh a.sh', 'a.sh', 2, None,
"""
a.sh:2: command not found: foo
"""),
('bash a.sh', 'a.sh', 2, None, '',
('bash a.sh', 'a.sh', 2, None,
"""
a.sh: line 2: foo: command not found
"""),
('rustc a.rs', 'a.rs', 2, 5, '',
('rustc a.rs', 'a.rs', 2, 5,
"""
a.rs:2:5: 2:6 error: unexpected token: `+`
a.rs:2 +
^
"""),
('cargo build', 'src/lib.rs', 3, 5, '',
('cargo build', 'src/lib.rs', 3, 5,
"""
Compiling test v0.1.0 (file:///tmp/fix-error/test)
src/lib.rs:3:5: 3:6 error: unexpected token: `+`
@ -67,7 +67,7 @@ Could not compile `test`.
To learn more, run the command again with --verbose.
"""),
('python a.py', 'a.py', 2, None, '',
('python a.py', 'a.py', 2, None,
"""
File "a.py", line 2
+
@ -75,7 +75,7 @@ To learn more, run the command again with --verbose.
SyntaxError: invalid syntax
"""),
('python a.py', 'a.py', 8, None, '',
('python a.py', 'a.py', 8, None,
"""
Traceback (most recent call last):
File "a.py", line 8, in <module>
@ -89,7 +89,7 @@ Traceback (most recent call last):
TypeError: first argument must be string or compiled pattern
"""),
(u'python café.py', u'café.py', 8, None, '',
(u'python café.py', u'café.py', 8, None,
u"""
Traceback (most recent call last):
File "café.py", line 8, in <module>
@ -103,43 +103,43 @@ Traceback (most recent call last):
TypeError: first argument must be string or compiled pattern
"""),
('ruby a.rb', 'a.rb', 3, None, '',
('ruby a.rb', 'a.rb', 3, None,
"""
a.rb:3: syntax error, unexpected keyword_end
"""),
('lua a.lua', 'a.lua', 2, None, '',
('lua a.lua', 'a.lua', 2, None,
"""
lua: a.lua:2: unexpected symbol near '+'
"""),
('fish a.sh', '/tmp/fix-error/a.sh', 2, None, '',
('fish a.sh', '/tmp/fix-error/a.sh', 2, None,
"""
fish: Unknown command 'foo'
/tmp/fix-error/a.sh (line 2): foo
^
"""),
('./a', './a', 2, None, '',
('./a', './a', 2, None,
"""
awk: ./a:2: BEGIN { print "Hello, world!" + }
awk: ./a:2: ^ syntax error
"""),
('llc a.ll', 'a.ll', 1, 2, '',
('llc a.ll', 'a.ll', 1, 2,
"""
llc: a.ll:1:2: error: expected top-level entity
+
^
"""),
('go build a.go', 'a.go', 1, 2, '',
('go build a.go', 'a.go', 1, 2,
"""
can't load package:
a.go:1:2: expected 'package', found '+'
"""),
('make', 'Makefile', 2, None, '',
('make', 'Makefile', 2, None,
"""
bidule
make: bidule: Command not found
@ -147,12 +147,12 @@ Makefile:2: recipe for target 'target' failed
make: *** [target] Error 127
"""),
('git st', '/home/martin/.config/git/config', 1, None, '',
('git st', '/home/martin/.config/git/config', 1, None,
"""
fatal: bad config file line 1 in /home/martin/.config/git/config
"""),
('node fuck.js asdf qwer', '/Users/pablo/Workspace/barebones/fuck.js', '2', 5, '',
('node fuck.js asdf qwer', '/Users/pablo/Workspace/barebones/fuck.js', '2', 5,
"""
/Users/pablo/Workspace/barebones/fuck.js:2
conole.log(arg); // this should read console.log(arg);
@ -176,7 +176,7 @@ ReferenceError: conole is not defined
./tests/rules/test_systemctl.py:18:80: E501 line too long (103 > 79 characters)
./tests/rules/test_whois.py:20:80: E501 line too long (89 > 79 characters)
./tests/rules/test_whois.py:22:80: E501 line too long (83 > 79 characters)
""", ''),
"""),
('py.test', '/home/thefuck/tests/rules/test_fix_file.py', 218, None,
"""
@ -190,7 +190,7 @@ test = ('fish a.sh', '/tmp/fix-error/a.sh', 2, None, '', "\\nfish: Unknown comma
E NameError: name 'mocker' is not defined
/home/thefuck/tests/rules/test_fix_file.py:218: NameError
""", ''),
"""),
) # noqa
@ -199,7 +199,7 @@ E NameError: name 'mocker' is not defined
def test_match(mocker, monkeypatch, test):
mocker.patch('os.path.isfile', return_value=True)
monkeypatch.setenv('EDITOR', 'dummy_editor')
assert match(Command(stdout=test[4], stderr=test[5]))
assert match(Command('', test[4]))
@pytest.mark.parametrize('test', tests)
@ -209,7 +209,7 @@ def test_no_editor(mocker, monkeypatch, test):
if 'EDITOR' in os.environ:
monkeypatch.delenv('EDITOR')
assert not match(Command(stdout=test[4], stderr=test[5]))
assert not match(Command('', test[4]))
@pytest.mark.parametrize('test', tests)
@ -218,7 +218,7 @@ def test_not_file(mocker, monkeypatch, test):
mocker.patch('os.path.isfile', return_value=False)
monkeypatch.setenv('EDITOR', 'dummy_editor')
assert not match(Command(stdout=test[4], stderr=test[5]))
assert not match(Command('', test[4]))
@pytest.mark.parametrize('test', tests)
@ -234,7 +234,7 @@ def test_get_new_command_with_settings(mocker, monkeypatch, test, settings):
mocker.patch('os.path.isfile', return_value=True)
monkeypatch.setenv('EDITOR', 'dummy_editor')
cmd = Command(script=test[0], stdout=test[4], stderr=test[5])
cmd = Command(test[0], test[4])
settings.fixcolcmd = '{editor} {file} +{line}:{col}'
if test[3]:

24
tests/rules/test_gem_unknown_command.py
View File

@ -1,9 +1,9 @@
import pytest
from six import BytesIO
from thefuck.rules.gem_unknown_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
stderr = '''
output = '''
ERROR: While executing gem ... (Gem::CommandLineError)
Unknown command {}
'''
@ -64,19 +64,19 @@ def gem_help_commands(mocker):
('gem isntall jekyll', 'isntall'),
('gem last --local', 'last')])
def test_match(script, command):
assert match(Command(script, stderr=stderr.format(command)))
assert match(Command(script, output.format(command)))
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('gem install jekyll', ''),
('git log', stderr.format('log'))])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
('git log', output.format('log'))])
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.parametrize('script, stderr, result', [
('gem isntall jekyll', stderr.format('isntall'), 'gem install jekyll'),
('gem last --local', stderr.format('last'), 'gem list --local')])
def test_get_new_command(script, stderr, result):
new_command = get_new_command(Command(script, stderr=stderr))
@pytest.mark.parametrize('script, output, result', [
('gem isntall jekyll', output.format('isntall'), 'gem install jekyll'),
('gem last --local', output.format('last'), 'gem list --local')])
def test_get_new_command(script, output, result):
new_command = get_new_command(Command(script, output))
assert new_command[0] == result

18
tests/rules/test_git_add.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.git_add import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture(autouse=True)
@ -10,7 +10,7 @@ def path_exists(mocker):
@pytest.fixture
def stderr(target):
def output(target):
return ("error: pathspec '{}' did not match any "
'file(s) known to git.'.format(target))
@ -18,17 +18,17 @@ def stderr(target):
@pytest.mark.parametrize('script, target', [
('git submodule update unknown', 'unknown'),
('git commit unknown', 'unknown')])
def test_match(stderr, script, target):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script, target):
assert match(Command(script, output))
@pytest.mark.parametrize('script, target, exists', [
('git submodule update known', '', True),
('git commit known', '', True),
('git submodule update known', stderr, False)])
def test_not_match(path_exists, stderr, script, target, exists):
('git submodule update known', output, False)])
def test_not_match(path_exists, output, script, target, exists):
path_exists.return_value = exists
assert not match(Command(script=script, stderr=stderr))
assert not match(Command(script, output))
@pytest.mark.parametrize('script, target, new_command', [
@ -36,5 +36,5 @@ def test_not_match(path_exists, stderr, script, target, exists):
'git add -- unknown && git submodule update unknown'),
('git commit unknown', 'unknown',
'git add -- unknown && git commit unknown')])
def test_get_new_command(stderr, script, target, new_command):
assert get_new_command(Command(script=script, stderr=stderr)) == new_command
def test_get_new_command(output, script, target, new_command):
assert get_new_command(Command(script, output)) == new_command

14
tests/rules/test_git_add_force.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_add_force import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return ('The following paths are ignored by one of your .gitignore files:\n'
'dist/app.js\n'
'dist/background.js\n'
@ -12,11 +12,11 @@ def stderr():
'Use -f if you really want to add them.\n')
def test_match(stderr):
assert match(Command('git add dist/*.js', stderr=stderr))
assert not match(Command('git add dist/*.js'))
def test_match(output):
assert match(Command('git add dist/*.js', output))
assert not match(Command('git add dist/*.js', ''))
def test_get_new_command(stderr):
assert (get_new_command(Command('git add dist/*.js', stderr=stderr))
def test_get_new_command(output):
assert (get_new_command(Command('git add dist/*.js', output))
== "git add --force dist/*.js")

14
tests/rules/test_git_bisect_usage.py
View File

@ -1,30 +1,30 @@
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.git_bisect_usage import match, get_new_command
@pytest.fixture
def stderr():
def output():
return ("usage: git bisect [help|start|bad|good|new|old"
"|terms|skip|next|reset|visualize|replay|log|run]")
@pytest.mark.parametrize('script', [
'git bisect strt', 'git bisect rset', 'git bisect goood'])
def test_match(stderr, script):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script):
assert match(Command(script, output))
@pytest.mark.parametrize('script', [
'git bisect', 'git bisect start', 'git bisect good'])
def test_not_match(script):
assert not match(Command(script=script, stderr=''))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, new_cmd, ', [
('git bisect goood', ['good', 'old', 'log']),
('git bisect strt', ['start', 'terms', 'reset']),
('git bisect rset', ['reset', 'next', 'start'])])
def test_get_new_command(stderr, script, new_cmd):
def test_get_new_command(output, script, new_cmd):
new_cmd = ['git bisect %s' % cmd for cmd in new_cmd]
assert get_new_command(Command(script=script, stderr=stderr)) == new_cmd
assert get_new_command(Command(script, output)) == new_cmd

16
tests/rules/test_git_branch_delete.py
View File

@ -1,22 +1,22 @@
import pytest
from thefuck.rules.git_branch_delete import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''error: The branch 'branch' is not fully merged.
If you are sure you want to delete it, run 'git branch -D branch'.
'''
def test_match(stderr):
assert match(Command('git branch -d branch', stderr=stderr))
assert not match(Command('git branch -d branch'))
assert not match(Command('ls', stderr=stderr))
def test_match(output):
assert match(Command('git branch -d branch', output))
assert not match(Command('git branch -d branch', ''))
assert not match(Command('ls', output))
def test_get_new_command(stderr):
assert get_new_command(Command('git branch -d branch', stderr=stderr))\
def test_get_new_command(output):
assert get_new_command(Command('git branch -d branch', output))\
== "git branch -D branch"

14
tests/rules/test_git_branch_exists.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_branch_exists import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr(branch_name):
def output(branch_name):
return "fatal: A branch named '{}' already exists.".format(branch_name)
@ -19,16 +19,16 @@ def new_command(branch_name):
@pytest.mark.parametrize('script, branch_name', [
('git branch foo', 'foo'), ('git checkout bar', 'bar')])
def test_match(stderr, script, branch_name):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script, branch_name):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['git branch foo', 'git checkout bar'])
def test_not_match(script):
assert not match(Command(script=script, stderr=''))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, branch_name, ', [
('git branch foo', 'foo'), ('git checkout bar', 'bar')])
def test_get_new_command(stderr, new_command, script, branch_name):
assert get_new_command(Command(script=script, stderr=stderr)) == new_command
def test_get_new_command(output, new_command, script, branch_name):
assert get_new_command(Command(script, output)) == new_command

14
tests/rules/test_git_branch_list.py
View File

@ -1,19 +1,19 @@
from thefuck.rules.git_branch_list import match, get_new_command
from thefuck.shells import shell
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command('git branch list'))
assert match(Command('git branch list', ''))
def test_not_match():
assert not match(Command())
assert not match(Command('git commit'))
assert not match(Command('git branch'))
assert not match(Command('git stash list'))
assert not match(Command('', ''))
assert not match(Command('git commit', ''))
assert not match(Command('git branch', ''))
assert not match(Command('git stash list', ''))
def test_get_new_command():
assert (get_new_command(Command('git branch list')) ==
assert (get_new_command(Command('git branch list', '')) ==
shell.and_('git branch --delete list', 'git branch'))

26
tests/rules/test_git_checkout.py
View File

@ -1,7 +1,7 @@
import pytest
from io import BytesIO
from thefuck.rules.git_checkout import match, get_branches, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -21,17 +21,17 @@ def git_branch(mocker, branches):
@pytest.mark.parametrize('command', [
Command(script='git checkout unknown', stderr=did_not_match('unknown')),
Command(script='git commit unknown', stderr=did_not_match('unknown'))])
Command('git checkout unknown', did_not_match('unknown')),
Command('git commit unknown', did_not_match('unknown'))])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='git submodule update unknown',
stderr=did_not_match('unknown', True)),
Command(script='git checkout known', stderr=('')),
Command(script='git commit known', stderr=(''))])
Command('git submodule update unknown',
did_not_match('unknown', True)),
Command('git checkout known', ''),
Command('git commit known', '')])
def test_not_match(command):
assert not match(command)
@ -51,18 +51,18 @@ def test_get_branches(branches, branch_list, git_branch):
@pytest.mark.parametrize('branches, command, new_command', [
(b'',
Command(script='git checkout unknown', stderr=did_not_match('unknown')),
Command('git checkout unknown', did_not_match('unknown')),
'git branch unknown && git checkout unknown'),
(b'',
Command('git commit unknown', stderr=did_not_match('unknown')),
Command('git commit unknown', did_not_match('unknown')),
'git branch unknown && git commit unknown'),
(b' test-random-branch-123',
Command(script='git checkout tst-rdm-brnch-123',
stderr=did_not_match('tst-rdm-brnch-123')),
Command('git checkout tst-rdm-brnch-123',
did_not_match('tst-rdm-brnch-123')),
'git checkout test-random-branch-123'),
(b' test-random-branch-123',
Command(script='git commit tst-rdm-brnch-123',
stderr=did_not_match('tst-rdm-brnch-123')),
Command('git commit tst-rdm-brnch-123',
did_not_match('tst-rdm-brnch-123')),
'git commit test-random-branch-123')])
def test_get_new_command(branches, command, new_command, git_branch):
git_branch(branches)

12
tests/rules/test_git_diff_no_index.py
View File

@ -1,23 +1,23 @@
import pytest
from thefuck.rules.git_diff_no_index import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='git diff foo bar')])
Command('git diff foo bar', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='git diff --no-index foo bar'),
Command(script='git diff foo'),
Command(script='git diff foo bar baz')])
Command('git diff --no-index foo bar', ''),
Command('git diff foo', ''),
Command('git diff foo bar baz', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('git diff foo bar'), 'git diff --no-index foo bar')])
(Command('git diff foo bar', ''), 'git diff --no-index foo bar')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

18
tests/rules/test_git_diff_staged.py
View File

@ -1,26 +1,26 @@
import pytest
from thefuck.rules.git_diff_staged import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='git diff foo'),
Command(script='git diff')])
Command('git diff foo', ''),
Command('git diff', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='git diff --staged'),
Command(script='git tag'),
Command(script='git branch'),
Command(script='git log')])
Command('git diff --staged', ''),
Command('git tag', ''),
Command('git branch', ''),
Command('git log', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('git diff'), 'git diff --staged'),
(Command('git diff foo'), 'git diff --staged foo')])
(Command('git diff', ''), 'git diff --staged'),
(Command('git diff foo', ''), 'git diff --staged foo')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

8
tests/rules/test_git_fix_stash.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.git_fix_stash import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
git_stash_err = '''
@ -20,11 +20,11 @@ usage: git stash list [<options>]
'git stash Some message',
'git stash saev Some message'])
def test_match(wrong):
assert match(Command(wrong, stderr=git_stash_err))
assert match(Command(wrong, git_stash_err))
def test_not_match():
assert not match(Command("git", stderr=git_stash_err))
assert not match(Command("git", git_stash_err))
@pytest.mark.parametrize('wrong,fixed', [
@ -32,4 +32,4 @@ def test_not_match():
('git stash Some message', 'git stash save Some message'),
('git stash saev Some message', 'git stash save Some message')])
def test_get_new_command(wrong, fixed):
assert get_new_command(Command(wrong, stderr=git_stash_err)) == fixed
assert get_new_command(Command(wrong, git_stash_err)) == fixed

12
tests/rules/test_git_flag_after_filename.py
View File

@ -1,13 +1,13 @@
import pytest
from thefuck.rules.git_flag_after_filename import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
command1 = Command('git log README.md -p',
stderr="fatal: bad flag '-p' used after filename")
"fatal: bad flag '-p' used after filename")
command2 = Command('git log README.md -p CONTRIBUTING.md',
stderr="fatal: bad flag '-p' used after filename")
"fatal: bad flag '-p' used after filename")
command3 = Command('git log -p README.md --name-only',
stderr="fatal: bad flag '--name-only' used after filename")
"fatal: bad flag '--name-only' used after filename")
@pytest.mark.parametrize('command', [
@ -17,8 +17,8 @@ def test_match(command):
@pytest.mark.parametrize('command', [
Command('git log README.md'),
Command('git log -p README.md')])
Command('git log README.md', ''),
Command('git log -p README.md', '')])
def test_not_match(command):
assert not match(command)

20
tests/rules/test_git_help_aliased.py
View File

@ -1,24 +1,24 @@
import pytest
from thefuck.rules.git_help_aliased import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('script, stdout', [
@pytest.mark.parametrize('script, output', [
('git help st', "`git st' is aliased to `status'"),
('git help ds', "`git ds' is aliased to `diff --staged'")])
def test_match(script, stdout):
assert match(Command(script=script, stdout=stdout))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script, stdout', [
@pytest.mark.parametrize('script, output', [
('git help status', "GIT-STATUS(1)...Git Manual...GIT-STATUS(1)"),
('git help diff', "GIT-DIFF(1)...Git Manual...GIT-DIFF(1)")])
def test_not_match(script, stdout):
assert not match(Command(script=script, stdout=stdout))
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.parametrize('script, stdout, new_command', [
@pytest.mark.parametrize('script, output, new_command', [
('git help st', "`git st' is aliased to `status'", 'git help status'),
('git help ds', "`git ds' is aliased to `diff --staged'", 'git help diff')])
def test_get_new_command(script, stdout, new_command):
assert get_new_command(Command(script=script, stdout=stdout)) == new_command
def test_get_new_command(script, output, new_command):
assert get_new_command(Command(script, output)) == new_command

16
tests/rules/test_git_not_command.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.git_not_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -41,17 +41,17 @@ def git_command():
def test_match(git_not_command, git_command, git_not_command_one_of_this):
assert match(Command('git brnch', stderr=git_not_command))
assert match(Command('git st', stderr=git_not_command_one_of_this))
assert not match(Command('ls brnch', stderr=git_not_command))
assert not match(Command('git branch', stderr=git_command))
assert match(Command('git brnch', git_not_command))
assert match(Command('git st', git_not_command_one_of_this))
assert not match(Command('ls brnch', git_not_command))
assert not match(Command('git branch', git_command))
def test_get_new_command(git_not_command, git_not_command_one_of_this,
git_not_command_closest):
assert (get_new_command(Command('git brnch', stderr=git_not_command))
assert (get_new_command(Command('git brnch', git_not_command))
== ['git branch'])
assert (get_new_command(Command('git st', stderr=git_not_command_one_of_this))
assert (get_new_command(Command('git st', git_not_command_one_of_this))
== ['git stats', 'git stash', 'git stage'])
assert (get_new_command(Command('git tags', stderr=git_not_command_closest))
assert (get_new_command(Command('git tags', git_not_command_closest))
== ['git tag', 'git stage'])

16
tests/rules/test_git_pull.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_pull import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''There is no tracking information for the current branch.
Please specify which branch you want to merge with.
See git-pull(1) for details
@ -18,12 +18,12 @@ If you wish to set tracking information for this branch you can do so with:
'''
def test_match(stderr):
assert match(Command('git pull', stderr=stderr))
assert not match(Command('git pull'))
assert not match(Command('ls', stderr=stderr))
def test_match(output):
assert match(Command('git pull', output))
assert not match(Command('git pull', ''))
assert not match(Command('ls', output))
def test_get_new_command(stderr):
assert (get_new_command(Command('git pull', stderr=stderr))
def test_get_new_command(output):
assert (get_new_command(Command('git pull', output))
== "git branch --set-upstream-to=origin/master master && git pull")

6
tests/rules/test_git_pull_clone.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.git_pull_clone import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
git_err = '''
@ -10,12 +10,12 @@ Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set).
@pytest.mark.parametrize('command', [
Command(script='git pull git@github.com:mcarton/thefuck.git', stderr=git_err)])
Command('git pull git@github.com:mcarton/thefuck.git', git_err)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, output', [
(Command(script='git pull git@github.com:mcarton/thefuck.git', stderr=git_err), 'git clone git@github.com:mcarton/thefuck.git')])
(Command('git pull git@github.com:mcarton/thefuck.git', git_err), 'git clone git@github.com:mcarton/thefuck.git')])
def test_get_new_command(command, output):
assert get_new_command(command) == output

16
tests/rules/test_git_pull_uncommitted_changes.py
View File

@ -1,19 +1,19 @@
import pytest
from thefuck.rules.git_pull_uncommitted_changes import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''error: Cannot pull with rebase: You have unstaged changes.'''
def test_match(stderr):
assert match(Command('git pull', stderr=stderr))
assert not match(Command('git pull'))
assert not match(Command('ls', stderr=stderr))
def test_match(output):
assert match(Command('git pull', output))
assert not match(Command('git pull', ''))
assert not match(Command('ls', output))
def test_get_new_command(stderr):
assert (get_new_command(Command('git pull', stderr=stderr))
def test_get_new_command(output):
assert (get_new_command(Command('git pull', output))
== "git stash && git pull && git stash pop")

16
tests/rules/test_git_pull_unstaged_changes.py
View File

@ -1,19 +1,19 @@
import pytest
from thefuck.rules.git_pull_uncommitted_changes import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''error: Cannot pull with rebase: Your index contains uncommitted changes.'''
def test_match(stderr):
assert match(Command('git pull', stderr=stderr))
assert not match(Command('git pull'))
assert not match(Command('ls', stderr=stderr))
def test_match(output):
assert match(Command('git pull', output))
assert not match(Command('git pull', ''))
assert not match(Command('ls', output))
def test_get_new_command(stderr):
assert (get_new_command(Command('git pull', stderr=stderr))
def test_get_new_command(output):
assert (get_new_command(Command('git pull', output))
== "git stash && git pull && git stash pop")

26
tests/rules/test_git_push.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_push import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''fatal: The current branch master has no upstream branch.
To push the current branch and set the remote as upstream, use
@ -13,21 +13,21 @@ To push the current branch and set the remote as upstream, use
'''
def test_match(stderr):
assert match(Command('git push', stderr=stderr))
assert match(Command('git push master', stderr=stderr))
assert not match(Command('git push master'))
assert not match(Command('ls', stderr=stderr))
def test_match(output):
assert match(Command('git push', output))
assert match(Command('git push master', output))
assert not match(Command('git push master', ''))
assert not match(Command('ls', output))
def test_get_new_command(stderr):
assert get_new_command(Command('git push', stderr=stderr))\
def test_get_new_command(output):
assert get_new_command(Command('git push', output))\
== "git push --set-upstream origin master"
assert get_new_command(Command('git push -u', stderr=stderr))\
assert get_new_command(Command('git push -u', output))\
== "git push --set-upstream origin master"
assert get_new_command(Command('git push -u origin', stderr=stderr))\
assert get_new_command(Command('git push -u origin', output))\
== "git push --set-upstream origin master"
assert get_new_command(Command('git push --set-upstream origin', stderr=stderr))\
assert get_new_command(Command('git push --set-upstream origin', output))\
== "git push --set-upstream origin master"
assert get_new_command(Command('git push --quiet', stderr=stderr))\
assert get_new_command(Command('git push --quiet', output))\
== "git push --set-upstream origin master --quiet"

26
tests/rules/test_git_push_force.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.git_push_force import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
git_err = '''
@ -26,27 +26,27 @@ To /tmp/bar
@pytest.mark.parametrize('command', [
Command(script='git push', stderr=git_err),
Command(script='git push nvbn', stderr=git_err),
Command(script='git push nvbn master', stderr=git_err)])
Command('git push', git_err),
Command('git push nvbn', git_err),
Command('git push nvbn master', git_err)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='git push', stderr=git_ok),
Command(script='git push', stderr=git_uptodate),
Command(script='git push nvbn', stderr=git_ok),
Command(script='git push nvbn master', stderr=git_uptodate),
Command(script='git push nvbn', stderr=git_ok),
Command(script='git push nvbn master', stderr=git_uptodate)])
Command('git push', git_ok),
Command('git push', git_uptodate),
Command('git push nvbn', git_ok),
Command('git push nvbn master', git_uptodate),
Command('git push nvbn', git_ok),
Command('git push nvbn master', git_uptodate)])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, output', [
(Command(script='git push', stderr=git_err), 'git push --force-with-lease'),
(Command(script='git push nvbn', stderr=git_err), 'git push --force-with-lease nvbn'),
(Command(script='git push nvbn master', stderr=git_err), 'git push --force-with-lease nvbn master')])
(Command('git push', git_err), 'git push --force-with-lease'),
(Command('git push nvbn', git_err), 'git push --force-with-lease nvbn'),
(Command('git push nvbn master', git_err), 'git push --force-with-lease nvbn master')])
def test_get_new_command(command, output):
assert get_new_command(command) == output

38
tests/rules/test_git_push_pull.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.git_push_pull import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
git_err = '''
@ -37,37 +37,37 @@ To /tmp/bar
@pytest.mark.parametrize('command', [
Command(script='git push', stderr=git_err),
Command(script='git push nvbn', stderr=git_err),
Command(script='git push nvbn master', stderr=git_err),
Command(script='git push', stderr=git_err2),
Command(script='git push nvbn', stderr=git_err2),
Command(script='git push nvbn master', stderr=git_err2)])
Command('git push', git_err),
Command('git push nvbn', git_err),
Command('git push nvbn master', git_err),
Command('git push', git_err2),
Command('git push nvbn', git_err2),
Command('git push nvbn master', git_err2)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='git push', stderr=git_ok),
Command(script='git push', stderr=git_uptodate),
Command(script='git push nvbn', stderr=git_ok),
Command(script='git push nvbn master', stderr=git_uptodate),
Command(script='git push nvbn', stderr=git_ok),
Command(script='git push nvbn master', stderr=git_uptodate)])
Command('git push', git_ok),
Command('git push', git_uptodate),
Command('git push nvbn', git_ok),
Command('git push nvbn master', git_uptodate),
Command('git push nvbn', git_ok),
Command('git push nvbn master', git_uptodate)])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, output', [
(Command(script='git push', stderr=git_err), 'git pull && git push'),
(Command(script='git push nvbn', stderr=git_err),
(Command('git push', git_err), 'git pull && git push'),
(Command('git push nvbn', git_err),
'git pull nvbn && git push nvbn'),
(Command(script='git push nvbn master', stderr=git_err),
(Command('git push nvbn master', git_err),
'git pull nvbn master && git push nvbn master'),
(Command(script='git push', stderr=git_err2), 'git pull && git push'),
(Command(script='git push nvbn', stderr=git_err2),
(Command('git push', git_err2), 'git pull && git push'),
(Command('git push nvbn', git_err2),
'git pull nvbn && git push nvbn'),
(Command(script='git push nvbn master', stderr=git_err2),
(Command('git push nvbn master', git_err2),
'git pull nvbn master && git push nvbn master')])
def test_get_new_command(command, output):
assert get_new_command(command) == output

6
tests/rules/test_git_push_without_commits.py
View File

@ -1,6 +1,6 @@
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.git_push_without_commits import (
fix,
get_new_command,
@ -14,13 +14,13 @@ error: failed to push some refs to 'git@github.com:User/repo.git'
'''
@pytest.mark.parametrize('command', [Command(command, stderr=expected_error)])
@pytest.mark.parametrize('command', [Command(command, expected_error)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, result', [(
Command(command, stderr=expected_error),
Command(command, expected_error),
fix.format(command=command),
)])
def test_get_new_command(command, result):

18
tests/rules/test_git_rebase_merge_dir.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_rebase_merge_dir import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return ('\n\nIt seems that there is already a rebase-merge directory, and\n'
'I wonder if you are in the middle of another rebase. If that is the\n'
'case, please try\n'
@ -16,14 +16,16 @@ def stderr():
@pytest.mark.parametrize('script', [
('git rebase master'), ('git rebase -skip'), ('git rebase')])
def test_match(stderr, script):
assert match(Command(script=script, stderr=stderr))
'git rebase master',
'git rebase -skip',
'git rebase'])
def test_match(output, script):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['git rebase master', 'git rebase -abort'])
def test_not_match(script):
assert not match(Command(script=script))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, result', [
@ -36,5 +38,5 @@ def test_not_match(script):
('git rebase', [
'git rebase --skip', 'git rebase --abort', 'git rebase --continue',
'rm -fr "/foo/bar/baz/egg/.git/rebase-merge"'])])
def test_get_new_command(stderr, script, result):
assert get_new_command(Command(script=script, stderr=stderr)) == result
def test_get_new_command(output, script, result):
assert get_new_command(Command(script, output)) == result

16
tests/rules/test_git_rebase_no_changes.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_rebase_no_changes import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stdout():
def output():
return '''Applying: Test commit
No changes - did you forget to use 'git add'?
If there is nothing left to stage, chances are that something else
@ -17,12 +17,12 @@ To check out the original branch and stop rebasing, run "git rebase --abort".
'''
def test_match(stdout):
assert match(Command('git rebase --continue', stdout=stdout))
assert not match(Command('git rebase --continue'))
assert not match(Command('git rebase --skip'))
def test_match(output):
assert match(Command('git rebase --continue', output))
assert not match(Command('git rebase --continue', ''))
assert not match(Command('git rebase --skip', ''))
def test_get_new_command(stdout):
assert (get_new_command(Command('git rebase --continue', stdout=stdout)) ==
def test_get_new_command(output):
assert (get_new_command(Command('git rebase --continue', output)) ==
'git rebase --skip')

16
tests/rules/test_git_remote_seturl_add.py
View File

@ -1,26 +1,26 @@
import pytest
from thefuck.rules.git_remote_seturl_add import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='git remote set-url origin url', stderr="fatal: No such remote")])
Command('git remote set-url origin url', "fatal: No such remote")])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('git remote set-url origin url', stderr=""),
Command('git remote add origin url'),
Command('git remote remove origin'),
Command('git remote prune origin'),
Command('git remote set-branches origin branch')])
Command('git remote set-url origin url', ""),
Command('git remote add origin url', ''),
Command('git remote remove origin', ''),
Command('git remote prune origin', ''),
Command('git remote set-branches origin branch', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('git remote set-url origin git@github.com:nvbn/thefuck.git'),
(Command('git remote set-url origin git@github.com:nvbn/thefuck.git', ''),
'git remote add origin git@github.com:nvbn/thefuck.git')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

14
tests/rules/test_git_rm_local_modifications.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_rm_local_modifications import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr(target):
def output(target):
return ('error: the following file has local modifications:\n {}\n(use '
'--cached to keep the file, or -f to force removal)').format(target)
@ -12,17 +12,17 @@ def stderr(target):
@pytest.mark.parametrize('script, target', [
('git rm foo', 'foo'),
('git rm foo bar', 'bar')])
def test_match(stderr, script, target):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script, target):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['git rm foo', 'git rm foo bar', 'git rm'])
def test_not_match(script):
assert not match(Command(script=script, stderr=''))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, target, new_command', [
('git rm foo', 'foo', ['git rm --cached foo', 'git rm -f foo']),
('git rm foo bar', 'bar', ['git rm --cached foo bar', 'git rm -f foo bar'])])
def test_get_new_command(stderr, script, target, new_command):
assert get_new_command(Command(script=script, stderr=stderr)) == new_command
def test_get_new_command(output, script, target, new_command):
assert get_new_command(Command(script, output)) == new_command

14
tests/rules/test_git_rm_recursive.py
View File

@ -1,27 +1,27 @@
import pytest
from thefuck.rules.git_rm_recursive import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr(target):
def output(target):
return "fatal: not removing '{}' recursively without -r".format(target)
@pytest.mark.parametrize('script, target', [
('git rm foo', 'foo'),
('git rm foo bar', 'foo bar')])
def test_match(stderr, script, target):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script, target):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['git rm foo', 'git rm foo bar'])
def test_not_match(script):
assert not match(Command(script=script, stderr=''))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, target, new_command', [
('git rm foo', 'foo', 'git rm -r foo'),
('git rm foo bar', 'foo bar', 'git rm -r foo bar')])
def test_get_new_command(stderr, script, target, new_command):
assert get_new_command(Command(script=script, stderr=stderr)) == new_command
def test_get_new_command(output, script, target, new_command):
assert get_new_command(Command(script, output)) == new_command

14
tests/rules/test_git_rm_staged.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.git_rm_staged import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr(target):
def output(target):
return ('error: the following file has changes staged in the index:\n {}\n(use '
'--cached to keep the file, or -f to force removal)').format(target)
@ -12,17 +12,17 @@ def stderr(target):
@pytest.mark.parametrize('script, target', [
('git rm foo', 'foo'),
('git rm foo bar', 'bar')])
def test_match(stderr, script, target):
assert match(Command(script=script, stderr=stderr))
def test_match(output, script, target):
assert match(Command(script, output))
@pytest.mark.parametrize('script', ['git rm foo', 'git rm foo bar', 'git rm'])
def test_not_match(script):
assert not match(Command(script=script, stderr=''))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, target, new_command', [
('git rm foo', 'foo', ['git rm --cached foo', 'git rm -f foo']),
('git rm foo bar', 'bar', ['git rm --cached foo bar', 'git rm -f foo bar'])])
def test_get_new_command(stderr, script, target, new_command):
assert get_new_command(Command(script=script, stderr=stderr)) == new_command
def test_get_new_command(output, script, target, new_command):
assert get_new_command(Command(script, output)) == new_command

14
tests/rules/test_git_stash.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.git_stash import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
cherry_pick_error = (
@ -15,23 +15,23 @@ rebase_error = (
@pytest.mark.parametrize('command', [
Command(script='git cherry-pick a1b2c3d', stderr=cherry_pick_error),
Command(script='git rebase -i HEAD~7', stderr=rebase_error)])
Command('git cherry-pick a1b2c3d', cherry_pick_error),
Command('git rebase -i HEAD~7', rebase_error)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='git cherry-pick a1b2c3d', stderr=('')),
Command(script='git rebase -i HEAD~7', stderr=(''))])
Command('git cherry-pick a1b2c3d', ''),
Command('git rebase -i HEAD~7', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command(script='git cherry-pick a1b2c3d', stderr=cherry_pick_error),
(Command('git cherry-pick a1b2c3d', cherry_pick_error),
'git stash && git cherry-pick a1b2c3d'),
(Command('git rebase -i HEAD~7', stderr=rebase_error),
(Command('git rebase -i HEAD~7', rebase_error),
'git stash && git rebase -i HEAD~7')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

14
tests/rules/test_git_stash_pop.py
View File

@ -1,18 +1,18 @@
import pytest
from thefuck.rules.git_stash_pop import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''error: Your local changes to the following files would be overwritten by merge:'''
def test_match(stderr):
assert match(Command('git stash pop', stderr=stderr))
assert not match(Command('git stash'))
def test_match(output):
assert match(Command('git stash pop', output))
assert not match(Command('git stash', ''))
def test_get_new_command(stderr):
assert (get_new_command(Command('git stash pop', stderr=stderr))
def test_get_new_command(output):
assert (get_new_command(Command('git stash pop', output))
== "git add --update && git stash pop && git reset .")

14
tests/rules/test_git_tag_force.py
View File

@ -1,18 +1,18 @@
import pytest
from thefuck.rules.git_tag_force import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr():
def output():
return '''fatal: tag 'alert' already exists'''
def test_match(stderr):
assert match(Command('git tag alert', stderr=stderr))
assert not match(Command('git tag alert'))
def test_match(output):
assert match(Command('git tag alert', output))
assert not match(Command('git tag alert', ''))
def test_get_new_command(stderr):
assert (get_new_command(Command('git tag alert', stderr=stderr))
def test_get_new_command(output):
assert (get_new_command(Command('git tag alert', output))
== "git tag --force alert")

40
tests/rules/test_git_two_dashes.py
View File

@ -1,47 +1,45 @@
import pytest
from thefuck.rules.git_two_dashes import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr(meant):
return 'error: did you mean `%s` (with two dashes ?)' % meant
output = 'error: did you mean `{}` (with two dashes ?)'.format
@pytest.mark.parametrize('command', [
Command(script='git add -patch', stderr=stderr('--patch')),
Command(script='git checkout -patch', stderr=stderr('--patch')),
Command(script='git commit -amend', stderr=stderr('--amend')),
Command(script='git push -tags', stderr=stderr('--tags')),
Command(script='git rebase -continue', stderr=stderr('--continue'))])
Command('git add -patch', output('--patch')),
Command('git checkout -patch', output('--patch')),
Command('git commit -amend', output('--amend')),
Command('git push -tags', output('--tags')),
Command('git rebase -continue', output('--continue'))])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='git add --patch'),
Command(script='git checkout --patch'),
Command(script='git commit --amend'),
Command(script='git push --tags'),
Command(script='git rebase --continue')])
Command('git add --patch', ''),
Command('git checkout --patch', ''),
Command('git commit --amend', ''),
Command('git push --tags', ''),
Command('git rebase --continue', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, output', [
(Command(script='git add -patch', stderr=stderr('--patch')),
(Command('git add -patch', output('--patch')),
'git add --patch'),
(Command(script='git checkout -patch', stderr=stderr('--patch')),
(Command('git checkout -patch', output('--patch')),
'git checkout --patch'),
(Command(script='git checkout -patch', stderr=stderr('--patch')),
(Command('git checkout -patch', output('--patch')),
'git checkout --patch'),
(Command(script='git init -bare', stderr=stderr('--bare')),
(Command('git init -bare', output('--bare')),
'git init --bare'),
(Command(script='git commit -amend', stderr=stderr('--amend')),
(Command('git commit -amend', output('--amend')),
'git commit --amend'),
(Command(script='git push -tags', stderr=stderr('--tags')),
(Command('git push -tags', output('--tags')),
'git push --tags'),
(Command(script='git rebase -continue', stderr=stderr('--continue')),
(Command('git rebase -continue', output('--continue')),
'git rebase --continue')])
def test_get_new_command(command, output):
assert get_new_command(command) == output

10
tests/rules/test_go_run.py
View File

@ -1,17 +1,17 @@
import pytest
from thefuck.rules.go_run import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='go run foo'),
Command(script='go run bar')])
Command('go run foo', ''),
Command('go run bar', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('go run foo'), 'go run foo.go'),
(Command('go run bar'), 'go run bar.go')])
(Command('go run foo', ''), 'go run foo.go'),
(Command('go run bar', ''), 'go run bar.go')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

30
tests/rules/test_gradle_not_task.py
View File

@ -1,7 +1,7 @@
import pytest
from io import BytesIO
from thefuck.rules.gradle_no_task import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
gradle_tasks = b'''
:tasks
@ -97,7 +97,7 @@ BUILD SUCCESSFUL
Total time: 1.936 secs
'''
stderr_not_found = '''
output_not_found = '''
FAILURE: Build failed with an exception.
@ -108,7 +108,7 @@ Task '{}' not found in root project 'org.rerenderer_example.snake'.
Run gradlew tasks to get a list of available tasks. Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.
'''.format
stderr_ambiguous = '''
output_ambiguous = '''
FAILURE: Build failed with an exception.
@ -128,31 +128,31 @@ def tasks(mocker):
@pytest.mark.parametrize('command', [
Command('./gradlew assembler', stderr=stderr_ambiguous('assembler')),
Command('./gradlew instar', stderr=stderr_not_found('instar')),
Command('gradle assembler', stderr=stderr_ambiguous('assembler')),
Command('gradle instar', stderr=stderr_not_found('instar'))])
Command('./gradlew assembler', output_ambiguous('assembler')),
Command('./gradlew instar', output_not_found('instar')),
Command('gradle assembler', output_ambiguous('assembler')),
Command('gradle instar', output_not_found('instar'))])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('./gradlew assemble'),
Command('gradle assemble'),
Command('npm assembler', stderr=stderr_ambiguous('assembler')),
Command('npm instar', stderr=stderr_not_found('instar'))])
Command('./gradlew assemble', ''),
Command('gradle assemble', ''),
Command('npm assembler', output_ambiguous('assembler')),
Command('npm instar', output_not_found('instar'))])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, result', [
(Command('./gradlew assembler', stderr=stderr_ambiguous('assembler')),
(Command('./gradlew assembler', output_ambiguous('assembler')),
'./gradlew assemble'),
(Command('./gradlew instardebug', stderr=stderr_not_found('instardebug')),
(Command('./gradlew instardebug', output_not_found('instardebug')),
'./gradlew installDebug'),
(Command('gradle assembler', stderr=stderr_ambiguous('assembler')),
(Command('gradle assembler', output_ambiguous('assembler')),
'gradle assemble'),
(Command('gradle instardebug', stderr=stderr_not_found('instardebug')),
(Command('gradle instardebug', output_not_found('instardebug')),
'gradle installDebug')])
def test_get_new_command(command, result):
assert get_new_command(command)[0] == result

14
tests/rules/test_gradle_wrapper.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.gradle_wrapper import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture(autouse=True)
@ -10,8 +10,8 @@ def exists(mocker):
@pytest.mark.parametrize('command', [
Command('gradle tasks', stderr='gradle: not found'),
Command('gradle build', stderr='gradle: not found')])
Command('gradle tasks', 'gradle: not found'),
Command('gradle build', 'gradle: not found')])
def test_match(mocker, command):
mocker.patch('thefuck.rules.gradle_wrapper.which', return_value=None)
@ -19,9 +19,9 @@ def test_match(mocker, command):
@pytest.mark.parametrize('command, gradlew, which', [
(Command('gradle tasks', stderr='gradle: not found'), False, None),
(Command('gradle tasks', stderr='command not found'), True, '/usr/bin/gradle'),
(Command('npm tasks', stderr='npm: not found'), True, None)])
(Command('gradle tasks', 'gradle: not found'), False, None),
(Command('gradle tasks', 'command not found'), True, '/usr/bin/gradle'),
(Command('npm tasks', 'npm: not found'), True, None)])
def test_not_match(mocker, exists, command, gradlew, which):
mocker.patch('thefuck.rules.gradle_wrapper.which', return_value=which)
exists.return_value = gradlew
@ -34,5 +34,5 @@ def test_not_match(mocker, exists, command, gradlew, which):
('gradle --help', './gradlew --help'),
('gradle build -c', './gradlew build -c')])
def test_get_new_command(script, result):
command = Command(script)
command = Command(script, '')
assert get_new_command(command) == result

32
tests/rules/test_grep_arguments_order.py
View File

@ -1,8 +1,8 @@
import pytest
from thefuck.rules.grep_arguments_order import get_new_command, match
from tests.utils import Command
from thefuck.types import Command
stderr = 'grep: {}: No such file or directory'.format
output = 'grep: {}: No such file or directory'.format
@pytest.fixture(autouse=True)
@ -16,25 +16,25 @@ def os_path(monkeypatch):
('egrep test.py test', 'test'),
('egrep -lir . test', 'test')])
def test_match(script, file):
assert match(Command(script, stderr=stderr(file)))
assert match(Command(script, output(file)))
@pytest.mark.parametrize('script, stderr', [
('cat test.py', stderr('test')),
@pytest.mark.parametrize('script, output', [
('cat test.py', output('test')),
('grep test test.py', ''),
('grep -lir test .', ''),
('egrep test test.py', ''),
('egrep -lir test .', '')])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.parametrize('script, stderr, result', [
('grep test.py test', stderr('test'), 'grep test test.py'),
('grep -lir . test', stderr('test'), 'grep -lir test .'),
('grep . test -lir', stderr('test'), 'grep test -lir .'),
('egrep test.py test', stderr('test'), 'egrep test test.py'),
('egrep -lir . test', stderr('test'), 'egrep -lir test .'),
('egrep . test -lir', stderr('test'), 'egrep test -lir .')])
def test_get_new_command(script, stderr, result):
assert get_new_command(Command(script, stderr=stderr)) == result
@pytest.mark.parametrize('script, output, result', [
('grep test.py test', output('test'), 'grep test test.py'),
('grep -lir . test', output('test'), 'grep -lir test .'),
('grep . test -lir', output('test'), 'grep test -lir .'),
('egrep test.py test', output('test'), 'egrep test test.py'),
('egrep -lir . test', output('test'), 'egrep -lir test .'),
('egrep . test -lir', output('test'), 'egrep test -lir .')])
def test_get_new_command(script, output, result):
assert get_new_command(Command(script, output)) == result

12
tests/rules/test_grep_recursive.py
View File

@ -1,15 +1,15 @@
# -*- coding: utf-8 -*-
from thefuck.rules.grep_recursive import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command('grep blah .', stderr='grep: .: Is a directory'))
assert match(Command(u'grep café .', stderr='grep: .: Is a directory'))
assert not match(Command())
assert match(Command('grep blah .', 'grep: .: Is a directory'))
assert match(Command(u'grep café .', 'grep: .: Is a directory'))
assert not match(Command('', ''))
def test_get_new_command():
assert get_new_command(Command('grep blah .')) == 'grep -r blah .'
assert get_new_command(Command(u'grep café .')) == u'grep -r café .'
assert get_new_command(Command('grep blah .', '')) == 'grep -r blah .'
assert get_new_command(Command(u'grep café .', '')) == u'grep -r café .'

18
tests/rules/test_grunt_task_not_found.py
View File

@ -2,10 +2,10 @@
from io import BytesIO
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.grunt_task_not_found import match, get_new_command
stdout = '''
output = '''
Warning: Task "{}" not found. Use --force to continue.
Aborted due to warnings.
@ -107,23 +107,23 @@ def grunt_help(mocker):
@pytest.mark.parametrize('command', [
Command('grunt defualt', stdout('defualt')),
Command('grunt buld:css', stdout('buld:css'))])
Command('grunt defualt', output('defualt')),
Command('grunt buld:css', output('buld:css'))])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('npm nuild', stdout('nuild')),
Command('grunt rm')])
Command('npm nuild', output('nuild')),
Command('grunt rm', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, result', [
(Command('grunt defualt', stdout('defualt')), 'grunt default'),
(Command('grunt cmpass:all', stdout('cmpass:all')), 'grunt compass:all'),
(Command('grunt cmpass:all --color', stdout('cmpass:all')),
(Command('grunt defualt', output('defualt')), 'grunt default'),
(Command('grunt cmpass:all', output('cmpass:all')), 'grunt compass:all'),
(Command('grunt cmpass:all --color', output('cmpass:all')),
'grunt compass:all --color')])
def test_get_new_command(command, result):
assert get_new_command(command) == result

10
tests/rules/test_gulp_not_task.py
View File

@ -1,10 +1,10 @@
import pytest
from io import BytesIO
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.gulp_not_task import match, get_new_command
def stdout(task):
def output(task):
return '''[00:41:11] Using gulpfile gulpfile.js
[00:41:11] Task '{}' is not in your gulpfile
[00:41:11] Please check the documentation for proper gulpfile formatting
@ -12,12 +12,12 @@ def stdout(task):
def test_match():
assert match(Command('gulp srve', stdout('srve')))
assert match(Command('gulp srve', output('srve')))
@pytest.mark.parametrize('script, stdout', [
('gulp serve', ''),
('cat srve', stdout('srve'))])
('cat srve', output('srve'))])
def test_not_march(script, stdout):
assert not match(Command(script, stdout))
@ -25,5 +25,5 @@ def test_not_march(script, stdout):
def test_get_new_command(mocker):
mock = mocker.patch('subprocess.Popen')
mock.return_value.stdout = BytesIO(b'serve \nbuild \ndefault \n')
command = Command('gulp srve', stdout('srve'))
command = Command('gulp srve', output('srve'))
assert get_new_command(command) == ['gulp serve', 'gulp default']

14
tests/rules/test_has_exists_script.py
View File

@ -1,18 +1,18 @@
from mock import patch
from thefuck.rules.has_exists_script import match, get_new_command
from ..utils import Command
from thefuck.types import Command
def test_match():
with patch('os.path.exists', return_value=True):
assert match(Command(script='main', stderr='main: command not found'))
assert match(Command(script='main --help',
stderr='main: command not found'))
assert not match(Command(script='main', stderr=''))
assert match(Command('main', 'main: command not found'))
assert match(Command('main --help',
'main: command not found'))
assert not match(Command('main', ''))
with patch('os.path.exists', return_value=False):
assert not match(Command(script='main', stderr='main: command not found'))
assert not match(Command('main', 'main: command not found'))
def test_get_new_command():
assert get_new_command(Command(script='main --help')) == './main --help'
assert get_new_command(Command('main --help', '')) == './main --help'

16
tests/rules/test_heroku_not_command.py
View File

@ -1,11 +1,11 @@
# -*- coding: utf-8 -*-
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.heroku_not_command import match, get_new_command
suggest_stderr = '''
suggest_output = '''
▸ log is not a heroku command.
▸ Perhaps you meant logs?
▸ Run heroku _ to run heroku logs.
@ -15,17 +15,17 @@ suggest_stderr = '''
@pytest.mark.parametrize('cmd', ['log'])
def test_match(cmd):
assert match(
Command('heroku {}'.format(cmd), stderr=suggest_stderr))
Command('heroku {}'.format(cmd), suggest_output))
@pytest.mark.parametrize('script, stderr', [
('cat log', suggest_stderr)])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
@pytest.mark.parametrize('script, output', [
('cat log', suggest_output)])
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.parametrize('cmd, result', [
('log', 'heroku logs')])
def test_get_new_command(cmd, result):
command = Command('heroku {}'.format(cmd), stderr=suggest_stderr)
command = Command('heroku {}'.format(cmd), suggest_output)
assert get_new_command(command) == result

8
tests/rules/test_history.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.history import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture(autouse=True)
@ -12,16 +12,16 @@ def history_without_current(mocker):
@pytest.mark.parametrize('script', ['ls cet', 'daff x'])
def test_match(script):
assert match(Command(script=script))
assert match(Command(script, ''))
@pytest.mark.parametrize('script', ['apt-get', 'nocommand y'])
def test_not_match(script):
assert not match(Command(script=script))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, result', [
('ls cet', 'ls cat'),
('daff x', 'diff x')])
def test_get_new_command(script, result):
assert get_new_command(Command(script)) == result
assert get_new_command(Command(script, '')) == result

8
tests/rules/test_hostscli.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.hostscli import no_website, get_new_command, match
from tests.utils import Command
from thefuck.types import Command
no_website_long = '''
{}:
@ -15,15 +15,13 @@ type `hostscli websites` to see a list of websites that you can block/unblock
@pytest.mark.parametrize('command', [
Command('hostscli block a_website_that_does_not_exist',
stderr=no_website_long)])
Command('hostscli block a_website_that_does_not_exist', no_website_long)])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, result', [(
Command('hostscli block a_website_that_does_not_exist',
stderr=no_website_long),
Command('hostscli block a_website_that_does_not_exist', no_website_long),
['hostscli websites'])])
def test_get_new_command(command, result):
assert get_new_command(command) == result

22
tests/rules/test_ifconfig_device_not_found.py
View File

@ -1,10 +1,10 @@
import pytest
from six import BytesIO
from thefuck.rules.ifconfig_device_not_found import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
stderr = '{}: error fetching interface information: Device not found'
output = '{}: error fetching interface information: Device not found'
stdout = b'''
wlp2s0 Link encap:Ethernet HWaddr 5c:51:4f:7c:58:5d
@ -26,21 +26,21 @@ def ifconfig(mocker):
return mock
@pytest.mark.parametrize('script, stderr', [
('ifconfig wlan0', stderr.format('wlan0')),
('ifconfig -s eth0', stderr.format('eth0')),
@pytest.mark.parametrize('script, output', [
('ifconfig wlan0', output.format('wlan0')),
('ifconfig -s eth0', output.format('eth0')),
])
def test_match(script, stderr):
assert match(Command(script, stderr=stderr))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('config wlan0',
'wlan0: error fetching interface information: Device not found'),
('ifconfig eth0', ''),
])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.parametrize('script, result', [
@ -49,5 +49,5 @@ def test_not_match(script, stderr):
])
def test_get_new_comman(script, result):
new_command = get_new_command(
Command(script, stderr=stderr.format('wlan0')))
Command(script, output.format('wlan0')))
assert new_command == result

10
tests/rules/test_java.py
View File

@ -1,17 +1,17 @@
import pytest
from thefuck.rules.java import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='java foo.java'),
Command(script='java bar.java')])
Command('java foo.java', ''),
Command('java bar.java', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('java foo.java'), 'java foo'),
(Command('java bar.java'), 'java bar')])
(Command('java foo.java', ''), 'java foo'),
(Command('java bar.java', ''), 'java bar')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

10
tests/rules/test_javac.py
View File

@ -1,17 +1,17 @@
import pytest
from thefuck.rules.javac import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='javac foo'),
Command(script='javac bar')])
Command('javac foo', ''),
Command('javac bar', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('javac foo'), 'javac foo.java'),
(Command('javac bar'), 'javac bar.java')])
(Command('javac foo', ''), 'javac foo.java'),
(Command('javac bar', ''), 'javac bar.java')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

8
tests/rules/test_lein_not_task.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.lein_not_task import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -14,10 +14,10 @@ Did you mean this?
def test_match(is_not_task):
assert match(Command(script='lein rpl', stderr=is_not_task))
assert not match(Command(script='ls', stderr=is_not_task))
assert match(Command('lein rpl', is_not_task))
assert not match(Command('ls', is_not_task))
def test_get_new_command(is_not_task):
assert (get_new_command(Command(script='lein rpl --help', stderr=is_not_task))
assert (get_new_command(Command('lein rpl --help', is_not_task))
== ['lein repl --help', 'lein jar --help'])

16
tests/rules/test_ln_no_hard_link.py
View File

@ -1,27 +1,27 @@
# -*- coding: utf-8 -*-
import pytest
from thefuck.rules.ln_no_hard_link import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
error = "hard link not allowed for directory"
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
("ln barDir barLink", "ln: ‘barDir’: {}"),
("sudo ln a b", "ln: ‘a’: {}"),
("sudo ln -nbi a b", "ln: ‘a’: {}")])
def test_match(script, stderr):
command = Command(script, stderr=stderr.format(error))
def test_match(script, output):
command = Command(script, output.format(error))
assert match(command)
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('', ''),
("ln a b", "... hard link"),
("sudo ln a b", "... hard link"),
("a b", error)])
def test_not_match(script, stderr):
command = Command(script, stderr=stderr)
def test_not_match(script, output):
command = Command(script, output)
assert not match(command)
@ -33,5 +33,5 @@ def test_not_match(script, stderr):
("ln a ln", "ln -s a ln"),
("sudo ln a ln", "sudo ln -s a ln")])
def test_get_new_command(script, result):
command = Command(script)
command = Command(script, '')
assert get_new_command(command) == result

22
tests/rules/test_ln_s_order.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.ln_s_order import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -8,17 +8,17 @@ def file_exists(mocker):
return mocker.patch('os.path.exists', return_value=True)
get_stderr = "ln: failed to create symbolic link '{}': File exists".format
get_output = "ln: failed to create symbolic link '{}': File exists".format
@pytest.mark.parametrize('script, stderr, exists', [
('ln dest source', get_stderr('source'), True),
('ls -s dest source', get_stderr('source'), True),
@pytest.mark.parametrize('script, output, exists', [
('ln dest source', get_output('source'), True),
('ls -s dest source', get_output('source'), True),
('ln -s dest source', '', True),
('ln -s dest source', get_stderr('source'), False)])
def test_not_match(file_exists, script, stderr, exists):
('ln -s dest source', get_output('source'), False)])
def test_not_match(file_exists, script, output, exists):
file_exists.return_value = exists
assert not match(Command(script, stderr=stderr))
assert not match(Command(script, output))
@pytest.mark.usefixtures('file_exists')
@ -27,6 +27,6 @@ def test_not_match(file_exists, script, stderr, exists):
('ln dest -s source', 'ln -s source dest'),
('ln dest source -s', 'ln source -s dest')])
def test_match(script, result):
stderr = get_stderr('source')
assert match(Command(script, stderr=stderr))
assert get_new_command(Command(script, stderr=stderr)) == result
output = get_output('source')
assert match(Command(script, output))
assert get_new_command(Command(script, output)) == result

10
tests/rules/test_ls_all.py
View File

@ -1,12 +1,12 @@
from thefuck.rules.ls_all import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command(script='ls'))
assert not match(Command(script='ls', stdout='file.py\n'))
assert match(Command('ls', ''))
assert not match(Command('ls', 'file.py\n'))
def test_get_new_command():
assert get_new_command(Command(script='ls empty_dir')) == 'ls -A empty_dir'
assert get_new_command(Command(script='ls')) == 'ls -A'
assert get_new_command(Command('ls empty_dir', '')) == 'ls -A empty_dir'
assert get_new_command(Command('ls', '')) == 'ls -A'

18
tests/rules/test_ls_lah.py
View File

@ -1,16 +1,16 @@
from thefuck.rules.ls_lah import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command(script='ls'))
assert match(Command(script='ls file.py'))
assert match(Command(script='ls /opt'))
assert not match(Command(script='ls -lah /opt'))
assert not match(Command(script='pacman -S binutils'))
assert not match(Command(script='lsof'))
assert match(Command('ls', ''))
assert match(Command('ls file.py', ''))
assert match(Command('ls /opt', ''))
assert not match(Command('ls -lah /opt', ''))
assert not match(Command('pacman -S binutils', ''))
assert not match(Command('lsof', ''))
def test_get_new_command():
assert get_new_command(Command(script='ls file.py')) == 'ls -lah file.py'
assert get_new_command(Command(script='ls')) == 'ls -lah'
assert get_new_command(Command('ls file.py', '')) == 'ls -lah file.py'
assert get_new_command(Command('ls', '')) == 'ls -lah'

36
tests/rules/test_man.py
View File

@ -1,35 +1,35 @@
import pytest
from thefuck.rules.man import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command('man read'),
Command('man 2 read'),
Command('man 3 read'),
Command('man -s2 read'),
Command('man -s3 read'),
Command('man -s 2 read'),
Command('man -s 3 read')])
Command('man read', ''),
Command('man 2 read', ''),
Command('man 3 read', ''),
Command('man -s2 read', ''),
Command('man -s3 read', ''),
Command('man -s 2 read', ''),
Command('man -s 3 read', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('man'),
Command('man ')])
Command('man', ''),
Command('man ', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('man read'), ['man 3 read', 'man 2 read', 'read --help']),
(Command('man missing', stderr="No manual entry for missing\n"), ['missing --help']),
(Command('man 2 read'), 'man 3 read'),
(Command('man 3 read'), 'man 2 read'),
(Command('man -s2 read'), 'man -s3 read'),
(Command('man -s3 read'), 'man -s2 read'),
(Command('man -s 2 read'), 'man -s 3 read'),
(Command('man -s 3 read'), 'man -s 2 read')])
(Command('man read', ''), ['man 3 read', 'man 2 read', 'read --help']),
(Command('man missing', "No manual entry for missing\n"), ['missing --help']),
(Command('man 2 read', ''), 'man 3 read'),
(Command('man 3 read', ''), 'man 2 read'),
(Command('man -s2 read', ''), 'man -s3 read'),
(Command('man -s3 read', ''), 'man -s2 read'),
(Command('man -s 2 read', ''), 'man -s 3 read'),
(Command('man -s 3 read', ''), 'man -s 2 read')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

9
tests/rules/test_man_no_space.py
View File

@ -1,12 +1,11 @@
from thefuck.rules.man_no_space import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command('mandiff', stderr='mandiff: command not found'))
assert not match(Command())
assert match(Command('mandiff', 'mandiff: command not found'))
assert not match(Command('', ''))
def test_get_new_command():
assert get_new_command(
Command('mandiff')) == 'man diff'
assert get_new_command(Command('mandiff', '')) == 'man diff'

56
tests/rules/test_mercurial.py
View File

@ -1,37 +1,37 @@
import pytest
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.mercurial import (
extract_possibilities, match, get_new_command
)
@pytest.mark.parametrize('command', [
Command('hg base', stderr=(
Command('hg base', (
"hg: unknown command 'base'"
'\n(did you mean one of blame, phase, rebase?)'
)),
Command('hg branchch', stderr=(
Command('hg branchch', (
"hg: unknown command 'branchch'"
'\n(did you mean one of branch, branches?)'
)),
Command('hg vert', stderr=(
Command('hg vert', (
"hg: unknown command 'vert'"
'\n(did you mean one of revert?)'
)),
Command('hg lgo -r tip', stderr=(
Command('hg lgo -r tip', (
"hg: command 're' is ambiguous:"
'\n(did you mean one of log?)'
)),
Command('hg rerere', stderr=(
Command('hg rerere', (
"hg: unknown command 'rerere'"
'\n(did you mean one of revert?)'
)),
Command('hg re', stderr=(
Command('hg re', (
"hg: command 're' is ambiguous:"
'\n rebase recover remove rename resolve revert'
)),
Command('hg re re', stderr=(
Command('hg re re', (
"hg: command 're' is ambiguous:"
'\n rebase recover remove rename resolve revert'
)),
@ -41,24 +41,24 @@ def test_match(command):
@pytest.mark.parametrize('command', [
Command('hg', stderr=(
Command('hg', (
'\nMercurial Distributed SCM\n\nbasic commands:'
)),
Command('hg asdf', stderr=(
Command('hg asdf', (
"hg: unknown command 'asdf'"
'\nMercurial Distributed SCM\n\nbasic commands:'
)),
Command('hg qwer', stderr=(
Command('hg qwer', (
"hg: unknown command 'qwer'"
'\nMercurial Distributed SCM\n\nbasic commands:'
)),
Command('hg me', stderr=(
Command('hg me', (
"\nabort: no repository found in './thefuck' (.hg not found)!"
)),
Command('hg reb', stderr=(
Command('hg reb', (
"\nabort: no repository found in './thefuck' (.hg not found)!"
)),
Command('hg co', stderr=(
Command('hg co', (
"\nabort: no repository found in './thefuck' (.hg not found)!"
)),
])
@ -67,31 +67,31 @@ def test_not_match(command):
@pytest.mark.parametrize('command, possibilities', [
(Command('hg base', stderr=(
(Command('hg base', (
"hg: unknown command 'base'"
'\n(did you mean one of blame, phase, rebase?)'
)), ['blame', 'phase', 'rebase']),
(Command('hg branchch', stderr=(
(Command('hg branchch', (
"hg: unknown command 'branchch'"
'\n(did you mean one of branch, branches?)'
)), ['branch', 'branches']),
(Command('hg vert', stderr=(
(Command('hg vert', (
"hg: unknown command 'vert'"
'\n(did you mean one of revert?)'
)), ['revert']),
(Command('hg lgo -r tip', stderr=(
(Command('hg lgo -r tip', (
"hg: command 're' is ambiguous:"
'\n(did you mean one of log?)'
)), ['log']),
(Command('hg rerere', stderr=(
(Command('hg rerere', (
"hg: unknown command 'rerere'"
'\n(did you mean one of revert?)'
)), ['revert']),
(Command('hg re', stderr=(
(Command('hg re', (
"hg: command 're' is ambiguous:"
'\n rebase recover remove rename resolve revert'
)), ['rebase', 'recover', 'remove', 'rename', 'resolve', 'revert']),
(Command('hg re re', stderr=(
(Command('hg re re', (
"hg: command 're' is ambiguous:"
'\n rebase recover remove rename resolve revert'
)), ['rebase', 'recover', 'remove', 'rename', 'resolve', 'revert']),
@ -101,31 +101,31 @@ def test_extract_possibilities(command, possibilities):
@pytest.mark.parametrize('command, new_command', [
(Command('hg base', stderr=(
(Command('hg base', (
"hg: unknown command 'base'"
'\n(did you mean one of blame, phase, rebase?)'
)), 'hg rebase'),
(Command('hg branchch', stderr=(
(Command('hg branchch', (
"hg: unknown command 'branchch'"
'\n(did you mean one of branch, branches?)'
)), 'hg branch'),
(Command('hg vert', stderr=(
(Command('hg vert', (
"hg: unknown command 'vert'"
'\n(did you mean one of revert?)'
)), 'hg revert'),
(Command('hg lgo -r tip', stderr=(
(Command('hg lgo -r tip', (
"hg: command 're' is ambiguous:"
'\n(did you mean one of log?)'
)), 'hg log -r tip'),
(Command('hg rerere', stderr=(
(Command('hg rerere', (
"hg: unknown command 'rerere'"
'\n(did you mean one of revert?)'
)), 'hg revert'),
(Command('hg re', stderr=(
(Command('hg re', (
"hg: command 're' is ambiguous:"
'\n rebase recover remove rename resolve revert'
)), 'hg rebase'),
(Command('hg re re', stderr=(
(Command('hg re re', (
"hg: command 're' is ambiguous:"
'\n rebase recover remove rename resolve revert'
)), 'hg rebase re'),

8
tests/rules/test_missing_space_before_subcommand.py
View File

@ -1,7 +1,7 @@
import pytest
from thefuck.rules.missing_space_before_subcommand import (
match, get_new_command)
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture(autouse=True)
@ -14,12 +14,12 @@ def all_executables(mocker):
@pytest.mark.parametrize('script', [
'gitbranch', 'ls-la', 'npminstall'])
def test_match(script):
assert match(Command(script))
assert match(Command(script, ''))
@pytest.mark.parametrize('script', ['git branch', 'vimfile'])
def test_not_match(script):
assert not match(Command(script))
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, result', [
@ -27,4 +27,4 @@ def test_not_match(script):
('ls-la', 'ls -la'),
('npminstall webpack', 'npm install webpack')])
def test_get_new_command(script, result):
assert get_new_command(Command(script)) == result
assert get_new_command(Command(script, '')) == result

24
tests/rules/test_mkdir_p.py
View File

@ -1,32 +1,32 @@
import pytest
from thefuck.rules.mkdir_p import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command('mkdir foo/bar/baz', stderr='mkdir: foo/bar: No such file or directory'),
Command('./bin/hdfs dfs -mkdir foo/bar/baz', stderr='mkdir: `foo/bar/baz\': No such file or directory'),
Command('hdfs dfs -mkdir foo/bar/baz', stderr='mkdir: `foo/bar/baz\': No such file or directory')
Command('mkdir foo/bar/baz', 'mkdir: foo/bar: No such file or directory'),
Command('./bin/hdfs dfs -mkdir foo/bar/baz', 'mkdir: `foo/bar/baz\': No such file or directory'),
Command('hdfs dfs -mkdir foo/bar/baz', 'mkdir: `foo/bar/baz\': No such file or directory')
])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('mkdir foo/bar/baz'),
Command('mkdir foo/bar/baz', stderr='foo bar baz'),
Command('hdfs dfs -mkdir foo/bar/baz'),
Command('./bin/hdfs dfs -mkdir foo/bar/baz'),
Command(),
Command('mkdir foo/bar/baz', ''),
Command('mkdir foo/bar/baz', 'foo bar baz'),
Command('hdfs dfs -mkdir foo/bar/baz', ''),
Command('./bin/hdfs dfs -mkdir foo/bar/baz', ''),
Command('', ''),
])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('mkdir foo/bar/baz'), 'mkdir -p foo/bar/baz'),
(Command('hdfs dfs -mkdir foo/bar/baz'), 'hdfs dfs -mkdir -p foo/bar/baz'),
(Command('./bin/hdfs dfs -mkdir foo/bar/baz'), './bin/hdfs dfs -mkdir -p foo/bar/baz'),
(Command('mkdir foo/bar/baz', ''), 'mkdir -p foo/bar/baz'),
(Command('hdfs dfs -mkdir foo/bar/baz', ''), 'hdfs dfs -mkdir -p foo/bar/baz'),
(Command('./bin/hdfs dfs -mkdir foo/bar/baz', ''), './bin/hdfs dfs -mkdir -p foo/bar/baz'),
])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

14
tests/rules/test_mvn_no_command.py
View File

@ -1,16 +1,16 @@
import pytest
from thefuck.rules.mvn_no_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='mvn', stdout='[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]')])
Command('mvn', '[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='mvn clean', stdout="""
Command('mvn clean', """
[INFO] Scanning for projects...[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building test 0.2
@ -26,15 +26,15 @@ def test_match(command):
[INFO] Final Memory: 6M/240M
[INFO] ------------------------------------------------------------------------
"""), # noqa
Command(script='mvn --help'),
Command(script='mvn -v')
Command('mvn --help', ''),
Command('mvn -v', '')
])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command(script='mvn', stdout='[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn clean package', 'mvn clean install']),
(Command(script='mvn -N', stdout='[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn -N clean package', 'mvn -N clean install'])])
(Command('mvn', '[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn clean package', 'mvn clean install']),
(Command('mvn -N', '[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn -N clean package', 'mvn -N clean install'])])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

14
tests/rules/test_mvn_unknown_lifecycle_phase.py
View File

@ -1,16 +1,16 @@
import pytest
from thefuck.rules.mvn_unknown_lifecycle_phase import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='mvn cle', stdout='[ERROR] Unknown lifecycle phase "cle". You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]')])
Command('mvn cle', '[ERROR] Unknown lifecycle phase "cle". You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='mvn clean', stdout="""
Command('mvn clean', """
[INFO] Scanning for projects...[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building test 0.2
@ -26,15 +26,15 @@ def test_match(command):
[INFO] Final Memory: 6M/240M
[INFO] ------------------------------------------------------------------------
"""), # noqa
Command(script='mvn --help'),
Command(script='mvn -v')
Command('mvn --help', ''),
Command('mvn -v', '')
])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command(script='mvn cle', stdout='[ERROR] Unknown lifecycle phase "cle". You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn clean', 'mvn compile']),
(Command(script='mvn claen package', stdout='[ERROR] Unknown lifecycle phase "claen". You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn clean package'])])
(Command('mvn cle', '[ERROR] Unknown lifecycle phase "cle". You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn clean', 'mvn compile']),
(Command('mvn claen package', '[ERROR] Unknown lifecycle phase "claen". You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy. -> [Help 1]'), ['mvn clean package'])])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

16
tests/rules/test_no_command.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.no_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture(autouse=True)
@ -17,25 +17,25 @@ def history_without_current(mocker):
@pytest.mark.usefixtures('no_memoize')
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('vom file.py', 'vom: not found'),
('fucck', 'fucck: not found'),
('got commit', 'got: command not found')])
def test_match(mocker, script, stderr):
def test_match(mocker, script, output):
mocker.patch('thefuck.rules.no_command.which', return_value=None)
assert match(Command(script, stderr=stderr))
assert match(Command(script, output))
@pytest.mark.usefixtures('no_memoize')
@pytest.mark.parametrize('script, stderr, which', [
@pytest.mark.parametrize('script, output, which', [
('qweqwe', 'qweqwe: not found', None),
('vom file.py', 'some text', None),
('vim file.py', 'vim: not found', 'vim')])
def test_not_match(mocker, script, stderr, which):
def test_not_match(mocker, script, output, which):
mocker.patch('thefuck.rules.no_command.which', return_value=which)
assert not match(Command(script, stderr=stderr))
assert not match(Command(script, output))
@pytest.mark.usefixtures('no_memoize')
@ -44,4 +44,4 @@ def test_not_match(mocker, script, stderr, which):
('fucck', ['fsck']),
('got commit', ['git commit', 'go commit'])])
def test_get_new_command(script, result):
assert get_new_command(Command(script)) == result
assert get_new_command(Command(script, '')) == result

14
tests/rules/test_no_such_file.py
View File

@ -1,27 +1,27 @@
import pytest
from thefuck.rules.no_such_file import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='mv foo bar/foo', stderr="mv: cannot move 'foo' to 'bar/foo': No such file or directory"),
Command(script='mv foo bar/', stderr="mv: cannot move 'foo' to 'bar/': No such file or directory"),
Command('mv foo bar/foo', "mv: cannot move 'foo' to 'bar/foo': No such file or directory"),
Command('mv foo bar/', "mv: cannot move 'foo' to 'bar/': No such file or directory"),
])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='mv foo bar/', stderr=""),
Command(script='mv foo bar/foo', stderr="mv: permission denied"),
Command('mv foo bar/', ""),
Command('mv foo bar/foo', "mv: permission denied"),
])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command(script='mv foo bar/foo', stderr="mv: cannot move 'foo' to 'bar/foo': No such file or directory"), 'mkdir -p bar && mv foo bar/foo'),
(Command(script='mv foo bar/', stderr="mv: cannot move 'foo' to 'bar/': No such file or directory"), 'mkdir -p bar && mv foo bar/'),
(Command('mv foo bar/foo', "mv: cannot move 'foo' to 'bar/foo': No such file or directory"), 'mkdir -p bar && mv foo bar/foo'),
(Command('mv foo bar/', "mv: cannot move 'foo' to 'bar/': No such file or directory"), 'mkdir -p bar && mv foo bar/'),
])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

28
tests/rules/test_npm_missing_script.py
View File

@ -1,9 +1,9 @@
import pytest
from io import BytesIO
from tests.utils import Command
from thefuck.types import Command
from thefuck.rules.npm_missing_script import match, get_new_command
stderr = '''
output = '''
npm ERR! Linux 4.4.0-31-generic
npm ERR! argv "/opt/node/bin/node" "/opt/node/bin/npm" "run" "dvelop"
npm ERR! node v4.4.7
@ -42,28 +42,28 @@ def run_script(mocker):
@pytest.mark.parametrize('command', [
Command('npm ru wach', stderr=stderr('wach')),
Command('npm run live-tes', stderr=stderr('live-tes')),
Command('npm run-script sahare', stderr=stderr('sahare'))])
Command('npm ru wach', output('wach')),
Command('npm run live-tes', output('live-tes')),
Command('npm run-script sahare', output('sahare'))])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('npm wach', stderr=stderr('wach')),
Command('vim live-tes', stderr=stderr('live-tes')),
Command('npm run-script sahare')])
Command('npm wach', output('wach')),
Command('vim live-tes', output('live-tes')),
Command('npm run-script sahare', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('script, stderr, result', [
('npm ru wach-tests', stderr('wach-tests'), 'npm ru watch-test'),
('npm -i run-script dvelop', stderr('dvelop'),
@pytest.mark.parametrize('script, output, result', [
('npm ru wach-tests', output('wach-tests'), 'npm ru watch-test'),
('npm -i run-script dvelop', output('dvelop'),
'npm -i run-script develop'),
('npm -i run-script buld -X POST', stderr('buld'),
('npm -i run-script buld -X POST', output('buld'),
'npm -i run-script build -X POST')])
def test_get_new_command(script, stderr, result):
command = Command(script, stderr=stderr)
def test_get_new_command(script, output, result):
command = Command(script, output)
assert get_new_command(command)[0] == result

12
tests/rules/test_npm_run_script.py
View File

@ -1,9 +1,9 @@
import pytest
from io import BytesIO
from thefuck.rules.npm_run_script import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
stdout = '''
output = '''
Usage: npm <command>
where <command> is one of:
@ -58,7 +58,7 @@ def run_script(mocker):
@pytest.mark.parametrize('script', [
'npm watch-test', 'npm develop'])
def test_match(script):
command = Command(script, stdout)
command = Command(script, output)
assert match(command)
@ -66,8 +66,8 @@ def test_match(script):
@pytest.mark.parametrize('command, run_script_out', [
(Command('npm test', 'TEST FAIL'), run_script_stdout),
(Command('npm watch-test', 'TEST FAIL'), run_script_stdout),
(Command('npm test', stdout), run_script_stdout),
(Command('vim watch-test', stdout), run_script_stdout)])
(Command('npm test', output), run_script_stdout),
(Command('vim watch-test', output), run_script_stdout)])
def test_not_match(run_script, command, run_script_out):
run_script.stdout = BytesIO(run_script_out)
assert not match(command)
@ -80,5 +80,5 @@ def test_not_match(run_script, command, run_script_out):
('npm -i watch-script --path ..',
'npm run-script -i watch-script --path ..')])
def test_get_new_command(script, result):
command = Command(script, stdout)
command = Command(script, output)
assert get_new_command(command) == result

20
tests/rules/test_npm_wrong_command.py
View File

@ -1,8 +1,8 @@
import pytest
from thefuck.rules.npm_wrong_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
stdout = '''
output = '''
Usage: npm <command>
where <command> is one of:
@ -38,16 +38,16 @@ npm@2.14.7 /opt/node/lib/node_modules/npm
'npm -f urgrade -g',
'npm urg'])
def test_match(script):
assert match(Command(script, stdout))
assert match(Command(script, output))
@pytest.mark.parametrize('script, stdout', [
@pytest.mark.parametrize('script, output', [
('npm urgrade', ''),
('npm', stdout),
('test urgrade', stdout),
('npm -e', stdout)])
def test_not_match(script, stdout):
assert not match(Command(script, stdout))
('npm', output),
('test urgrade', output),
('npm -e', output)])
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.parametrize('script, result', [
@ -55,4 +55,4 @@ def test_not_match(script, stdout):
('npm -g isntall gulp', 'npm -g install gulp'),
('npm isntall -g gulp', 'npm install -g gulp')])
def test_get_new_command(script, result):
assert get_new_command(Command(script, stdout)) == result
assert get_new_command(Command(script, output)) == result

16
tests/rules/test_open.py
View File

@ -1,10 +1,10 @@
import pytest
from thefuck.rules.open import is_arg_url, match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
def stderr(script):
def output(script):
return 'The file {} does not exist.\n'.format(script.split(' ', 1)[1])
@ -20,12 +20,12 @@ def stderr(script):
'open foo.se',
'open www.foo.ru'])
def test_is_arg_url(script):
assert is_arg_url(Command(script))
assert is_arg_url(Command(script, ''))
@pytest.mark.parametrize('script', ['open foo', 'open bar.txt', 'open egg.doc'])
def test_not_is_arg_url(script):
assert not is_arg_url(Command(script))
assert not is_arg_url(Command(script, ''))
@pytest.mark.parametrize('script', [
@ -34,8 +34,8 @@ def test_not_is_arg_url(script):
'gnome-open foo.com',
'kde-open foo.com',
'open nonest'])
def test_match(script, stderr):
assert match(Command(script, stderr=stderr))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script, new_command', [
@ -45,5 +45,5 @@ def test_match(script, stderr):
('kde-open foo.io', ['kde-open http://foo.io']),
('open nonest', ['touch nonest && open nonest',
'mkdir nonest && open nonest'])])
def test_get_new_command(script, new_command, stderr):
assert get_new_command(Command(script, stderr=stderr)) == new_command
def test_get_new_command(script, new_command, output):
assert get_new_command(Command(script, output)) == new_command

32
tests/rules/test_pacman.py
View File

@ -2,7 +2,7 @@ import pytest
from mock import patch
from thefuck.rules import pacman
from thefuck.rules.pacman import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
pacman_cmd = getattr(pacman, 'pacman', 'pacman')
@ -20,15 +20,15 @@ extra/vim-python3 7.4.712-1 \t/usr/bin/vim'''
@pytest.mark.skipif(not getattr(pacman, 'enabled_by_default', True),
reason='Skip if pacman is not available')
@pytest.mark.parametrize('command', [
Command(script='vim', stderr='vim: command not found'),
Command(script='sudo vim', stderr='sudo: vim: command not found')])
Command('vim', 'vim: command not found'),
Command('sudo vim', 'sudo: vim: command not found')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, return_value', [
(Command(script='vim', stderr='vim: command not found'), PKGFILE_OUTPUT_VIM),
(Command(script='sudo vim', stderr='sudo: vim: command not found'), PKGFILE_OUTPUT_VIM)])
(Command('vim', 'vim: command not found'), PKGFILE_OUTPUT_VIM),
(Command('sudo vim', 'sudo: vim: command not found'), PKGFILE_OUTPUT_VIM)])
@patch('thefuck.specific.archlinux.subprocess')
@patch.multiple(pacman, create=True, pacman=pacman_cmd)
def test_match_mocked(subp_mock, command, return_value):
@ -37,8 +37,8 @@ def test_match_mocked(subp_mock, command, return_value):
@pytest.mark.parametrize('command', [
Command(script='vim', stderr=''), Command(),
Command(script='sudo vim', stderr=''), Command()])
Command('vim', ''), Command('', ''),
Command('sudo vim', ''), Command('', '')])
def test_not_match(command):
assert not match(command)
@ -61,20 +61,20 @@ vim_possibilities = [s.format(pacman_cmd) for s in vim_possibilities]
@pytest.mark.skipif(not getattr(pacman, 'enabled_by_default', True),
reason='Skip if pacman is not available')
@pytest.mark.parametrize('command, new_command', [
(Command('vim'), vim_possibilities),
(Command('sudo vim'), sudo_vim_possibilities),
(Command('convert'), ['{} -S extra/imagemagick && convert'.format(pacman_cmd)]),
(Command('sudo convert'), ['{} -S extra/imagemagick && sudo convert'.format(pacman_cmd)])])
(Command('vim', ''), vim_possibilities),
(Command('sudo vim', ''), sudo_vim_possibilities),
(Command('convert', ''), ['{} -S extra/imagemagick && convert'.format(pacman_cmd)]),
(Command('sudo convert', ''), ['{} -S extra/imagemagick && sudo convert'.format(pacman_cmd)])])
def test_get_new_command(command, new_command, mocker):
assert get_new_command(command) == new_command
@pytest.mark.parametrize('command, new_command, return_value', [
(Command('vim'), vim_possibilities, PKGFILE_OUTPUT_VIM),
(Command('sudo vim'), sudo_vim_possibilities, PKGFILE_OUTPUT_VIM),
(Command('convert'), ['{} -S extra/imagemagick && convert'.format(pacman_cmd)], PKGFILE_OUTPUT_CONVERT),
(Command('sudo'), ['{} -S core/sudo && sudo'.format(pacman_cmd)], PKGFILE_OUTPUT_SUDO),
(Command('sudo convert'), ['{} -S extra/imagemagick && sudo convert'.format(pacman_cmd)], PKGFILE_OUTPUT_CONVERT)])
(Command('vim', ''), vim_possibilities, PKGFILE_OUTPUT_VIM),
(Command('sudo vim', ''), sudo_vim_possibilities, PKGFILE_OUTPUT_VIM),
(Command('convert', ''), ['{} -S extra/imagemagick && convert'.format(pacman_cmd)], PKGFILE_OUTPUT_CONVERT),
(Command('sudo', ''), ['{} -S core/sudo && sudo'.format(pacman_cmd)], PKGFILE_OUTPUT_SUDO),
(Command('sudo convert', ''), ['{} -S extra/imagemagick && sudo convert'.format(pacman_cmd)], PKGFILE_OUTPUT_CONVERT)])
@patch('thefuck.specific.archlinux.subprocess')
@patch.multiple(pacman, create=True, pacman=pacman_cmd)
def test_get_new_command_mocked(subp_mock, command, new_command, return_value):

26
tests/rules/test_pacman_not_found.py
View File

@ -2,7 +2,7 @@ import pytest
from mock import patch
from thefuck.rules import pacman_not_found
from thefuck.rules.pacman_not_found import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
PKGFILE_OUTPUT_LLC = '''extra/llvm 3.6.0-5 /usr/bin/llc
extra/llvm35 3.5.2-13/usr/bin/llc'''
@ -11,17 +11,17 @@ extra/llvm35 3.5.2-13/usr/bin/llc'''
@pytest.mark.skipif(not getattr(pacman_not_found, 'enabled_by_default', True),
reason='Skip if pacman is not available')
@pytest.mark.parametrize('command', [
Command(script='yaourt -S llc', stderr='error: target not found: llc'),
Command(script='pacman llc', stderr='error: target not found: llc'),
Command(script='sudo pacman llc', stderr='error: target not found: llc')])
Command('yaourt -S llc', 'error: target not found: llc'),
Command('pacman llc', 'error: target not found: llc'),
Command('sudo pacman llc', 'error: target not found: llc')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command(script='yaourt -S llc', stderr='error: target not found: llc'),
Command(script='pacman llc', stderr='error: target not found: llc'),
Command(script='sudo pacman llc', stderr='error: target not found: llc')])
Command('yaourt -S llc', 'error: target not found: llc'),
Command('pacman llc', 'error: target not found: llc'),
Command('sudo pacman llc', 'error: target not found: llc')])
@patch('thefuck.specific.archlinux.subprocess')
def test_match_mocked(subp_mock, command):
subp_mock.check_output.return_value = PKGFILE_OUTPUT_LLC
@ -31,17 +31,17 @@ def test_match_mocked(subp_mock, command):
@pytest.mark.skipif(not getattr(pacman_not_found, 'enabled_by_default', True),
reason='Skip if pacman is not available')
@pytest.mark.parametrize('command, fixed', [
(Command(script='yaourt -S llc', stderr='error: target not found: llc'), ['yaourt -S extra/llvm', 'yaourt -S extra/llvm35']),
(Command(script='pacman -S llc', stderr='error: target not found: llc'), ['pacman -S extra/llvm', 'pacman -S extra/llvm35']),
(Command(script='sudo pacman -S llc', stderr='error: target not found: llc'), ['sudo pacman -S extra/llvm', 'sudo pacman -S extra/llvm35'])])
(Command('yaourt -S llc', 'error: target not found: llc'), ['yaourt -S extra/llvm', 'yaourt -S extra/llvm35']),
(Command('pacman -S llc', 'error: target not found: llc'), ['pacman -S extra/llvm', 'pacman -S extra/llvm35']),
(Command('sudo pacman -S llc', 'error: target not found: llc'), ['sudo pacman -S extra/llvm', 'sudo pacman -S extra/llvm35'])])
def test_get_new_command(command, fixed):
assert get_new_command(command) == fixed
@pytest.mark.parametrize('command, fixed', [
(Command(script='yaourt -S llc', stderr='error: target not found: llc'), ['yaourt -S extra/llvm', 'yaourt -S extra/llvm35']),
(Command(script='pacman -S llc', stderr='error: target not found: llc'), ['pacman -S extra/llvm', 'pacman -S extra/llvm35']),
(Command(script='sudo pacman -S llc', stderr='error: target not found: llc'), ['sudo pacman -S extra/llvm', 'sudo pacman -S extra/llvm35'])])
(Command('yaourt -S llc', 'error: target not found: llc'), ['yaourt -S extra/llvm', 'yaourt -S extra/llvm35']),
(Command('pacman -S llc', 'error: target not found: llc'), ['pacman -S extra/llvm', 'pacman -S extra/llvm35']),
(Command('sudo pacman -S llc', 'error: target not found: llc'), ['sudo pacman -S extra/llvm', 'sudo pacman -S extra/llvm35'])])
@patch('thefuck.specific.archlinux.subprocess')
def test_get_new_command_mocked(subp_mock, command, fixed):
subp_mock.check_output.return_value = PKGFILE_OUTPUT_LLC

20
tests/rules/test_path_from_history.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.path_from_history import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture(autouse=True)
@ -18,26 +18,26 @@ def path_exists(mocker):
return exists_mock
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('ls project', 'no such file or directory: project'),
('cd project', "can't cd to project"),
])
def test_match(script, stderr):
assert match(Command(script, stderr=stderr))
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize('script, stderr', [
@pytest.mark.parametrize('script, output', [
('myapp cats', 'no such file or directory: project'),
('cd project', ""),
])
def test_not_match(script, stderr):
assert not match(Command(script, stderr=stderr))
def test_not_match(script, output):
assert not match(Command(script, output))
@pytest.mark.parametrize('script, stderr, result', [
@pytest.mark.parametrize('script, output, result', [
('ls project', 'no such file or directory: project', 'ls ~/work/project'),
('cd java', "can't cd to java", 'cd /opt/java'),
])
def test_get_new_command(script, stderr, result):
new_command = get_new_command(Command(script, stderr=stderr))
def test_get_new_command(script, output, result):
new_command = get_new_command(Command(script, output))
assert new_command[0] == result

8
tests/rules/test_pip_unknown_command.py
View File

@ -1,6 +1,6 @@
import pytest
from thefuck.rules.pip_unknown_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.fixture
@ -14,11 +14,11 @@ def pip_unknown_cmd_without_recommend():
def test_match(pip_unknown_cmd, pip_unknown_cmd_without_recommend):
assert match(Command('pip instatl', stderr=pip_unknown_cmd))
assert match(Command('pip instatl', pip_unknown_cmd))
assert not match(Command('pip i',
stderr=pip_unknown_cmd_without_recommend))
pip_unknown_cmd_without_recommend))
def test_get_new_command(pip_unknown_cmd):
assert get_new_command(Command('pip instatl',
stderr=pip_unknown_cmd)) == 'pip install'
pip_unknown_cmd)) == 'pip install'

16
tests/rules/test_port_already_in_use.py
View File

@ -2,7 +2,7 @@ from io import BytesIO
import pytest
from thefuck.rules.port_already_in_use import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
outputs = [
'''
@ -76,17 +76,17 @@ def lsof(mocker):
@pytest.mark.usefixtures('no_memoize')
@pytest.mark.parametrize(
'command',
[Command('./app', stdout=output) for output in outputs]
+ [Command('./app', stderr=output) for output in outputs])
[Command('./app', output) for output in outputs]
+ [Command('./app', output) for output in outputs])
def test_match(command):
assert match(command)
@pytest.mark.usefixtures('no_memoize')
@pytest.mark.parametrize('command, lsof_output', [
(Command('./app'), lsof_stdout),
(Command('./app', stdout=outputs[1]), b''),
(Command('./app', stderr=outputs[2]), b'')])
(Command('./app', ''), lsof_stdout),
(Command('./app', outputs[1]), b''),
(Command('./app', outputs[2]), b'')])
def test_not_match(lsof, command, lsof_output):
lsof.return_value.stdout = BytesIO(lsof_output)
@ -95,7 +95,7 @@ def test_not_match(lsof, command, lsof_output):
@pytest.mark.parametrize(
'command',
[Command('./app', stdout=output) for output in outputs]
+ [Command('./app', stderr=output) for output in outputs])
[Command('./app', output) for output in outputs]
+ [Command('./app', output) for output in outputs])
def test_get_new_command(command):
assert get_new_command(command) == 'kill 18233 && ./app'

8
tests/rules/test_python_command.py
View File

@ -1,12 +1,12 @@
from thefuck.rules.python_command import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
def test_match():
assert match(Command('temp.py', stderr='Permission denied'))
assert not match(Command())
assert match(Command('temp.py', 'Permission denied'))
assert not match(Command('', ''))
def test_get_new_command():
assert (get_new_command(Command('./test_sudo.py'))
assert (get_new_command(Command('./test_sudo.py', ''))
== 'python ./test_sudo.py')

10
tests/rules/test_python_execute.py
View File

@ -1,17 +1,17 @@
import pytest
from thefuck.rules.python_execute import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='python foo'),
Command(script='python bar')])
Command('python foo', ''),
Command('python bar', '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('python foo'), 'python foo.py'),
(Command('python bar'), 'python bar.py')])
(Command('python foo', ''), 'python foo.py'),
(Command('python bar', ''), 'python bar.py')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

14
tests/rules/test_quotation_marks.py
View File

@ -1,19 +1,19 @@
import pytest
from thefuck.rules.quotation_marks import match, get_new_command
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script="git commit -m \'My Message\""),
Command(script="git commit -am \"Mismatched Quotation Marks\'"),
Command(script="echo \"hello\'")])
Command("git commit -m \'My Message\"", ''),
Command("git commit -am \"Mismatched Quotation Marks\'", ''),
Command("echo \"hello\'", '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command("git commit -m \'My Message\""), "git commit -m \"My Message\""),
(Command("git commit -am \"Mismatched Quotation Marks\'"), "git commit -am \"Mismatched Quotation Marks\""),
(Command("echo \"hello\'"), "echo \"hello\"")])
(Command("git commit -m \'My Message\"", ''), "git commit -m \"My Message\""),
(Command("git commit -am \"Mismatched Quotation Marks\'", ''), "git commit -am \"Mismatched Quotation Marks\""),
(Command("echo \"hello\'", ''), "echo \"hello\"")])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

16
tests/rules/test_react_native_command_unrecognized.py
View File

@ -2,9 +2,9 @@ import pytest
from io import BytesIO
from thefuck.rules.react_native_command_unrecognized import match, \
get_new_command
from tests.utils import Command
from thefuck.types import Command
stderr = "Unrecognized command '{}'".format
output = "Unrecognized command '{}'".format
stdout = b'''
Scanning 615 folders for symlinks in /home/nvbn/work/zcho/BookkaWebView/node_modules (6ms)
@ -38,23 +38,23 @@ Scanning 615 folders for symlinks in /home/nvbn/work/zcho/BookkaWebView/node_mod
@pytest.mark.parametrize('command', [
Command('react-native star', stderr=stderr('star')),
Command('react-native android-logs', stderr=stderr('android-logs'))])
Command('react-native star', output('star')),
Command('react-native android-logs', output('android-logs'))])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command', [
Command('gradle star', stderr=stderr('star')),
Command('react-native start')])
Command('gradle star', output('star')),
Command('react-native start', '')])
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize('command, result', [
(Command('react-native star', stderr=stderr('star')),
(Command('react-native star', output('star')),
'react-native start'),
(Command('react-native logsandroid -f', stderr=stderr('logsandroid')),
(Command('react-native logsandroid -f', output('logsandroid')),
'react-native log-android -f')])
def test_get_new_command(mocker, command, result):
patch = mocker.patch(

10
tests/rules/test_remove_trailing_cedilla.py
View File

@ -1,17 +1,17 @@
import pytest
from thefuck.rules.remove_trailing_cedilla import match, get_new_command, CEDILLA
from tests.utils import Command
from thefuck.types import Command
@pytest.mark.parametrize('command', [
Command(script='wrong' + CEDILLA),
Command(script='wrong with args' + CEDILLA)])
Command('wrong' + CEDILLA, ''),
Command('wrong with args' + CEDILLA, '')])
def test_match(command):
assert match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('wrong' + CEDILLA), 'wrong'),
(Command('wrong with args' + CEDILLA), 'wrong with args')])
(Command('wrong' + CEDILLA, ''), 'wrong'),
(Command('wrong with args' + CEDILLA, ''), 'wrong with args')])
def test_get_new_command(command, new_command):
assert get_new_command(command) == new_command

Some files were not shown because too many files have changed in this diff Show More