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

tests/rules/test_ag_literal.py

@@ -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):
+def test_match(script, output):
-    assert match(Command(script=script, stderr=stderr))
+    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):
+def test_get_new_command(script, new_cmd, output):
-    assert get_new_command((Command(script=script, stderr=stderr))) == new_cmd
+    assert get_new_command((Command(script, output))) == new_cmd

tests/rules/test_apt_get.py

@@ -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('vim', ''), [], None),
-    (Command(), [], None),
+    (Command('', ''), [], None),
-    (Command(script='vim', stderr='vim: command not found'),
+    (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):

tests/rules/test_apt_get_search.py

@@ -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('apt-cache search foo', ''),
-    Command('aptitude search foo'),
+    Command('aptitude search foo', ''),
-    Command('apt search foo'),
+    Command('apt search foo', ''),
-    Command('apt-get install foo'),
+    Command('apt-get install foo', ''),
-    Command('apt-get source foo'),
+    Command('apt-get source foo', ''),
-    Command('apt-get clean'),
+    Command('apt-get clean', ''),
-    Command('apt-get remove'),
+    Command('apt-get remove', ''),
-    Command('apt-get update')
+    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'

tests/rules/test_apt_invalid_operation.py

@@ -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):
+def test_match(script, output):
-    assert match(Command(script, stderr=stderr))
+    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):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    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

tests/rules/test_aws_cli.py

@@ -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 dynamdb scan', misspelled_command),
-    Command('aws dynamodb scn', stderr=misspelled_subcommand),
+    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

tests/rules/test_brew_install.py

@@ -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))
+                             brew_already_installed))
-    assert not match(Command('brew install', stderr=brew_install_no_argument))
+    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'

tests/rules/test_brew_link.py

@@ -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):
+def test_match(output, script):
-    assert match(Command(script=script, stderr=stderr))
+    assert match(Command(script, output))
 
 
 @pytest.mark.parametrize('script', ['brew link coreutils'])
 def test_not_match(script):
-    stderr = ''
+    assert not match(Command(script, ''))
-    assert not match(Command(script=script, stderr=stderr))
 
 
 @pytest.mark.parametrize('script, formula, ', [('brew link coreutils', 'coreutils')])
-def test_get_new_command(stderr, new_command, script, formula):
+def test_get_new_command(output, new_command, script, formula):
-    assert get_new_command(Command(script=script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_brew_uninstall.py

@@ -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):
+def test_match(output, script):
-    assert match(Command(script=script, stdout=stdout))
+    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'
+    output = 'Uninstalling /usr/local/Cellar/gnuplot/5.0.4_1... (44 files, 2.3M)\n'
-    assert not match(Command(script=script, stdout=stdout))
+    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):
+def test_get_new_command(output, new_command, script, formula):
-    assert get_new_command(Command(script=script, stdout=stdout)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_brew_unknown_command.py

@@ -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

tests/rules/test_brew_update_formula.py

@@ -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):
+def test_match(output, script):
-    assert match(Command(script=script, stderr=stderr))
+    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):
+def test_get_new_command(output, new_command, script, formula):
-    assert get_new_command(Command(script=script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_brew_upgrade.py

@@ -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

tests/rules/test_cargo_no_command.py

@@ -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('cargo buid', no_such_subcommand_old),
-    Command(script='cargo buils', stderr=no_such_subcommand)])
+    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 buid', no_such_subcommand_old), 'cargo build'),
-    (Command('cargo buils', stderr=no_such_subcommand), '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

tests/rules/test_cd_mkdir.py

@@ -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('cd foo', 'cd: foo: No such file or directory'),
-    Command(script='cd foo/bar/baz',
+    Command('cd foo/bar/baz',
-            stderr='cd: foo: No such file or directory'),
+            '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/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', ''), 'mkdir -p foo && cd foo'),
-    (Command('cd foo/bar/baz'), 'mkdir -p foo/bar/baz && cd foo/bar/baz')])
+    (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

tests/rules/test_cd_parent.py

@@ -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 match(Command('cd..', 'cd..: command not found'))
-    assert not match(Command())
+    assert not match(Command('', ''))
 
 
 def test_get_new_command():
-    assert get_new_command(
+    assert get_new_command(Command('cd..', '')) == 'cd ..'
-        Command('cd..')) == 'cd ..'

tests/rules/test_chmod_x.py

@@ -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):
+def test_match(script, output):
-    assert match(Command(script, stderr=stderr))
+    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

tests/rules/test_composer_not_command.py

@@ -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))
+                         composer_not_command_one_of_this))
-    assert not match(Command('ls update', stderr=composer_not_command))
+    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')

tests/rules/test_cp_omitting_directory.py

@@ -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):
+def test_match(script, output):
-    assert match(Command(script, stderr=stderr))
+    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):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    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'

tests/rules/test_dirty_untar.py

@@ -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)))

tests/rules/test_dirty_unzip.py

@@ -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

tests/rules/test_django_south_ghost.py

@@ -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):
+def test_match(output):
-    assert match(Command('./manage.py migrate', stderr=stderr))
+    assert match(Command('./manage.py migrate', output))
-    assert match(Command('python manage.py migrate', stderr=stderr))
+    assert match(Command('python manage.py migrate', output))
-    assert not match(Command('./manage.py migrate'))
+    assert not match(Command('./manage.py migrate', ''))
-    assert not match(Command('app migrate', stderr=stderr))
+    assert not match(Command('app migrate', output))
-    assert not match(Command('./manage.py test', stderr=stderr))
+    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'

tests/rules/test_django_south_merge.py

@@ -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):
+def test_match(output):
-    assert match(Command('./manage.py migrate', stderr=stderr))
+    assert match(Command('./manage.py migrate', output))
-    assert match(Command('python manage.py migrate', stderr=stderr))
+    assert match(Command('python manage.py migrate', output))
-    assert not match(Command('./manage.py migrate'))
+    assert not match(Command('./manage.py migrate', ''))
-    assert not match(Command('app migrate', stderr=stderr))
+    assert not match(Command('app migrate', output))
-    assert not match(Command('./manage.py test', stderr=stderr))
+    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')

tests/rules/test_docker_not_command.py

@@ -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'))])
+    ('cat pes', output('pes'))])
-def test_not_match(script, stderr):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    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]

tests/rules/test_dry.py

@@ -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('cd cd foo', ''),
-    Command(script='git git push origin/master')])
+    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('cd cd foo', ''), 'cd foo'),
-    (Command('git git push origin/master'), 'git push origin/master')])
+    (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

tests/rules/test_fab_command_not_found.py

@@ -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 extenson', output),
-    Command('fab deloyp', stderr=stderr),
+    Command('fab deloyp', output),
-    Command('fab extenson deloyp', stderr=stderr)])
+    Command('fab extenson deloyp', output)])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command', [
-    Command('gulp extenson', stderr=stderr),
+    Command('gulp extenson', output),
-    Command('fab deloyp')])
+    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

tests/rules/test_fix_alt_space.py

@@ -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'))
+                         u'-bash:  grep: command not found'))
-    assert not match(Command('ps -ef | grep foo'))
+    assert not match(Command('ps -ef | grep foo', ''))
-    assert not match(Command())
+    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')

tests/rules/test_fix_file.py

@@ -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]:

tests/rules/test_gem_unknown_command.py

@@ -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'))])
+    ('git log', output.format('log'))])
-def test_not_match(script, stderr):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    assert not match(Command(script, output))
 
 
-@pytest.mark.parametrize('script, stderr, result', [
+@pytest.mark.parametrize('script, output, result', [
-    ('gem isntall jekyll', stderr.format('isntall'), 'gem install jekyll'),
+    ('gem isntall jekyll', output.format('isntall'), 'gem install jekyll'),
-    ('gem last --local', stderr.format('last'), 'gem list --local')])
+    ('gem last --local', output.format('last'), 'gem list --local')])
-def test_get_new_command(script, stderr, result):
+def test_get_new_command(script, output, result):
-    new_command = get_new_command(Command(script, stderr=stderr))
+    new_command = get_new_command(Command(script, output))
     assert new_command[0] == result

tests/rules/test_git_add.py

@@ -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):
+def test_match(output, script, target):
-    assert match(Command(script=script, stderr=stderr))
+    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)])
+    ('git submodule update known', output, False)])
-def test_not_match(path_exists, stderr, script, target, exists):
+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):
+def test_get_new_command(output, script, target, new_command):
-    assert get_new_command(Command(script=script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_git_add_force.py

@@ -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):
+def test_match(output):
-    assert match(Command('git add dist/*.js', stderr=stderr))
+    assert match(Command('git add dist/*.js', output))
-    assert not match(Command('git add dist/*.js'))
+    assert not match(Command('git add dist/*.js', ''))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert (get_new_command(Command('git add dist/*.js', stderr=stderr))
+    assert (get_new_command(Command('git add dist/*.js', output))
             == "git add --force dist/*.js")

tests/rules/test_git_bisect_usage.py

@@ -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):
+def test_match(output, script):
-    assert match(Command(script=script, stderr=stderr))
+    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

tests/rules/test_git_branch_delete.py

@@ -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):
+def test_match(output):
-    assert match(Command('git branch -d branch', stderr=stderr))
+    assert match(Command('git branch -d branch', output))
-    assert not match(Command('git branch -d branch'))
+    assert not match(Command('git branch -d branch', ''))
-    assert not match(Command('ls', stderr=stderr))
+    assert not match(Command('ls', output))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert get_new_command(Command('git branch -d branch', stderr=stderr))\
+    assert get_new_command(Command('git branch -d branch', output))\
         == "git branch -D branch"

tests/rules/test_git_branch_exists.py

@@ -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):
+def test_match(output, script, branch_name):
-    assert match(Command(script=script, stderr=stderr))
+    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):
+def test_get_new_command(output, new_command, script, branch_name):
-    assert get_new_command(Command(script=script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_git_branch_list.py

@@ -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('', ''))
-    assert not match(Command('git commit'))
+    assert not match(Command('git commit', ''))
-    assert not match(Command('git branch'))
+    assert not match(Command('git branch', ''))
-    assert not match(Command('git stash list'))
+    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'))

tests/rules/test_git_checkout.py

@@ -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('git checkout unknown', did_not_match('unknown')),
-    Command(script='git commit unknown', stderr=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',
+    Command('git submodule update unknown',
-            stderr=did_not_match('unknown', True)),
+            did_not_match('unknown', True)),
-    Command(script='git checkout known', stderr=('')),
+    Command('git checkout known', ''),
-    Command(script='git commit known', stderr=(''))])
+    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',
+     Command('git checkout tst-rdm-brnch-123',
-             stderr=did_not_match('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',
+     Command('git commit tst-rdm-brnch-123',
-             stderr=did_not_match('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)

tests/rules/test_git_diff_no_index.py

@@ -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('git diff --no-index foo bar', ''),
-    Command(script='git diff foo'),
+    Command('git diff foo', ''),
-    Command(script='git diff foo bar baz')])
+    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

tests/rules/test_git_diff_staged.py

@@ -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('git diff foo', ''),
-    Command(script='git diff')])
+    Command('git diff', '')])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command', [
-    Command(script='git diff --staged'),
+    Command('git diff --staged', ''),
-    Command(script='git tag'),
+    Command('git tag', ''),
-    Command(script='git branch'),
+    Command('git branch', ''),
-    Command(script='git log')])
+    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', ''), 'git diff --staged'),
-    (Command('git diff foo'), 'git diff --staged foo')])
+    (Command('git diff foo', ''), 'git diff --staged foo')])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_git_fix_stash.py

@@ -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

tests/rules/test_git_flag_after_filename.py

@@ -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 README.md', ''),
-    Command('git log -p README.md')])
+    Command('git log -p README.md', '')])
 def test_not_match(command):
     assert not match(command)
 

tests/rules/test_git_help_aliased.py

@@ -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):
+def test_match(script, output):
-    assert match(Command(script=script, stdout=stdout))
+    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):
+def test_not_match(script, output):
-    assert not match(Command(script=script, stdout=stdout))
+    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):
+def test_get_new_command(script, output, new_command):
-    assert get_new_command(Command(script=script, stdout=stdout)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_git_not_command.py

@@ -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 brnch', git_not_command))
-    assert match(Command('git st', stderr=git_not_command_one_of_this))
+    assert match(Command('git st', git_not_command_one_of_this))
-    assert not match(Command('ls brnch', stderr=git_not_command))
+    assert not match(Command('ls brnch', git_not_command))
-    assert not match(Command('git branch', stderr=git_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'])

tests/rules/test_git_pull.py

@@ -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):
+def test_match(output):
-    assert match(Command('git pull', stderr=stderr))
+    assert match(Command('git pull', output))
-    assert not match(Command('git pull'))
+    assert not match(Command('git pull', ''))
-    assert not match(Command('ls', stderr=stderr))
+    assert not match(Command('ls', output))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert (get_new_command(Command('git pull', stderr=stderr))
+    assert (get_new_command(Command('git pull', output))
             == "git branch --set-upstream-to=origin/master master && git pull")

tests/rules/test_git_pull_clone.py

@@ -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

tests/rules/test_git_pull_uncommitted_changes.py

@@ -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):
+def test_match(output):
-    assert match(Command('git pull', stderr=stderr))
+    assert match(Command('git pull', output))
-    assert not match(Command('git pull'))
+    assert not match(Command('git pull', ''))
-    assert not match(Command('ls', stderr=stderr))
+    assert not match(Command('ls', output))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert (get_new_command(Command('git pull', stderr=stderr))
+    assert (get_new_command(Command('git pull', output))
             == "git stash && git pull && git stash pop")

tests/rules/test_git_pull_unstaged_changes.py

@@ -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):
+def test_match(output):
-    assert match(Command('git pull', stderr=stderr))
+    assert match(Command('git pull', output))
-    assert not match(Command('git pull'))
+    assert not match(Command('git pull', ''))
-    assert not match(Command('ls', stderr=stderr))
+    assert not match(Command('ls', output))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert (get_new_command(Command('git pull', stderr=stderr))
+    assert (get_new_command(Command('git pull', output))
             == "git stash && git pull && git stash pop")

tests/rules/test_git_push.py

@@ -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):
+def test_match(output):
-    assert match(Command('git push', stderr=stderr))
+    assert match(Command('git push', output))
-    assert match(Command('git push master', stderr=stderr))
+    assert match(Command('git push master', output))
-    assert not match(Command('git push master'))
+    assert not match(Command('git push master', ''))
-    assert not match(Command('ls', stderr=stderr))
+    assert not match(Command('ls', output))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert get_new_command(Command('git push', stderr=stderr))\
+    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"

tests/rules/test_git_push_force.py

@@ -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('git push', git_err),
-    Command(script='git push nvbn', stderr=git_err),
+    Command('git push nvbn', git_err),
-    Command(script='git push nvbn master', stderr=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('git push', git_ok),
-    Command(script='git push', stderr=git_uptodate),
+    Command('git push', git_uptodate),
-    Command(script='git push nvbn', stderr=git_ok),
+    Command('git push nvbn', git_ok),
-    Command(script='git push nvbn master', stderr=git_uptodate),
+    Command('git push nvbn master', git_uptodate),
-    Command(script='git push nvbn', stderr=git_ok),
+    Command('git push nvbn', git_ok),
-    Command(script='git push nvbn master', stderr=git_uptodate)])
+    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('git push', git_err), 'git push --force-with-lease'),
-    (Command(script='git push nvbn', stderr=git_err), 'git push --force-with-lease nvbn'),
+    (Command('git push nvbn', 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 nvbn master', git_err), 'git push --force-with-lease nvbn master')])
 def test_get_new_command(command, output):
     assert get_new_command(command) == output

tests/rules/test_git_push_pull.py

@@ -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('git push', git_err),
-    Command(script='git push nvbn', stderr=git_err),
+    Command('git push nvbn', git_err),
-    Command(script='git push nvbn master', stderr=git_err),
+    Command('git push nvbn master', git_err),
-    Command(script='git push', stderr=git_err2),
+    Command('git push', git_err2),
-    Command(script='git push nvbn', stderr=git_err2),
+    Command('git push nvbn', git_err2),
-    Command(script='git push nvbn master', stderr=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('git push', git_ok),
-    Command(script='git push', stderr=git_uptodate),
+    Command('git push', git_uptodate),
-    Command(script='git push nvbn', stderr=git_ok),
+    Command('git push nvbn', git_ok),
-    Command(script='git push nvbn master', stderr=git_uptodate),
+    Command('git push nvbn master', git_uptodate),
-    Command(script='git push nvbn', stderr=git_ok),
+    Command('git push nvbn', git_ok),
-    Command(script='git push nvbn master', stderr=git_uptodate)])
+    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('git push', git_err), 'git pull && git push'),
-    (Command(script='git push nvbn', stderr=git_err),
+    (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('git push', git_err2), 'git pull && git push'),
-    (Command(script='git push nvbn', stderr=git_err2),
+    (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

tests/rules/test_git_push_without_commits.py

@@ -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):

tests/rules/test_git_rebase_merge_dir.py

@@ -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')])
+    'git rebase master',
-def test_match(stderr, script):
+    'git rebase -skip',
-    assert match(Command(script=script, stderr=stderr))
+    '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):
+def test_get_new_command(output, script, result):
-    assert get_new_command(Command(script=script, stderr=stderr)) == result
+    assert get_new_command(Command(script, output)) == result

tests/rules/test_git_rebase_no_changes.py

@@ -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):
+def test_match(output):
-    assert match(Command('git rebase --continue', stdout=stdout))
+    assert match(Command('git rebase --continue', output))
-    assert not match(Command('git rebase --continue'))
+    assert not match(Command('git rebase --continue', ''))
-    assert not match(Command('git rebase --skip'))
+    assert not match(Command('git rebase --skip', ''))
 
 
-def test_get_new_command(stdout):
+def test_get_new_command(output):
-    assert (get_new_command(Command('git rebase --continue', stdout=stdout)) ==
+    assert (get_new_command(Command('git rebase --continue', output)) ==
             'git rebase --skip')

tests/rules/test_git_remote_seturl_add.py

@@ -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 set-url origin url', ""),
-    Command('git remote add origin url'),
+    Command('git remote add origin url', ''),
-    Command('git remote remove origin'),
+    Command('git remote remove origin', ''),
-    Command('git remote prune origin'),
+    Command('git remote prune origin', ''),
-    Command('git remote set-branches origin branch')])
+    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

tests/rules/test_git_rm_local_modifications.py

@@ -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):
+def test_match(output, script, target):
-    assert match(Command(script=script, stderr=stderr))
+    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):
+def test_get_new_command(output, script, target, new_command):
-    assert get_new_command(Command(script=script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_git_rm_recursive.py

@@ -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):
+def test_match(output, script, target):
-    assert match(Command(script=script, stderr=stderr))
+    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):
+def test_get_new_command(output, script, target, new_command):
-    assert get_new_command(Command(script=script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_git_rm_staged.py

@@ -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):
+def test_match(output, script, target):
-    assert match(Command(script=script, stderr=stderr))
+    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):
+def test_get_new_command(output, script, target, new_command):
-    assert get_new_command(Command(script=script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_git_stash.py

@@ -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('git cherry-pick a1b2c3d', cherry_pick_error),
-    Command(script='git rebase -i HEAD~7', stderr=rebase_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('git cherry-pick a1b2c3d', ''),
-    Command(script='git rebase -i HEAD~7', stderr=(''))])
+    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

tests/rules/test_git_stash_pop.py

@@ -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):
+def test_match(output):
-    assert match(Command('git stash pop', stderr=stderr))
+    assert match(Command('git stash pop', output))
-    assert not match(Command('git stash'))
+    assert not match(Command('git stash', ''))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert (get_new_command(Command('git stash pop', stderr=stderr))
+    assert (get_new_command(Command('git stash pop', output))
             == "git add --update && git stash pop && git reset .")

tests/rules/test_git_tag_force.py

@@ -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):
+def test_match(output):
-    assert match(Command('git tag alert', stderr=stderr))
+    assert match(Command('git tag alert', output))
-    assert not match(Command('git tag alert'))
+    assert not match(Command('git tag alert', ''))
 
 
-def test_get_new_command(stderr):
+def test_get_new_command(output):
-    assert (get_new_command(Command('git tag alert', stderr=stderr))
+    assert (get_new_command(Command('git tag alert', output))
             == "git tag --force alert")

tests/rules/test_git_two_dashes.py

@@ -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
+output = 'error: did you mean `{}` (with two dashes ?)'.format
-def stderr(meant):
-    return 'error: did you mean `%s` (with two dashes ?)' % meant
 
 
 @pytest.mark.parametrize('command', [
-    Command(script='git add -patch', stderr=stderr('--patch')),
+    Command('git add -patch', output('--patch')),
-    Command(script='git checkout -patch', stderr=stderr('--patch')),
+    Command('git checkout -patch', output('--patch')),
-    Command(script='git commit -amend', stderr=stderr('--amend')),
+    Command('git commit -amend', output('--amend')),
-    Command(script='git push -tags', stderr=stderr('--tags')),
+    Command('git push -tags', output('--tags')),
-    Command(script='git rebase -continue', stderr=stderr('--continue'))])
+    Command('git rebase -continue', output('--continue'))])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command', [
-    Command(script='git add --patch'),
+    Command('git add --patch', ''),
-    Command(script='git checkout --patch'),
+    Command('git checkout --patch', ''),
-    Command(script='git commit --amend'),
+    Command('git commit --amend', ''),
-    Command(script='git push --tags'),
+    Command('git push --tags', ''),
-    Command(script='git rebase --continue')])
+    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

tests/rules/test_go_run.py

@@ -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('go run foo', ''),
-    Command(script='go run bar')])
+    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 foo', ''), 'go run foo.go'),
-    (Command('go run bar'), 'go run bar.go')])
+    (Command('go run bar', ''), 'go run bar.go')])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_gradle_not_task.py

@@ -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 assembler', output_ambiguous('assembler')),
-    Command('./gradlew instar', stderr=stderr_not_found('instar')),
+    Command('./gradlew instar', output_not_found('instar')),
-    Command('gradle assembler', stderr=stderr_ambiguous('assembler')),
+    Command('gradle assembler', output_ambiguous('assembler')),
-    Command('gradle instar', stderr=stderr_not_found('instar'))])
+    Command('gradle instar', output_not_found('instar'))])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command', [
-    Command('./gradlew assemble'),
+    Command('./gradlew assemble', ''),
-    Command('gradle assemble'),
+    Command('gradle assemble', ''),
-    Command('npm assembler', stderr=stderr_ambiguous('assembler')),
+    Command('npm assembler', output_ambiguous('assembler')),
-    Command('npm instar', stderr=stderr_not_found('instar'))])
+    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

tests/rules/test_gradle_wrapper.py

@@ -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 tasks', 'gradle: not found'),
-    Command('gradle build', stderr='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', 'gradle: not found'), False, None),
-    (Command('gradle tasks', stderr='command not found'), True, '/usr/bin/gradle'),
+    (Command('gradle tasks', 'command not found'), True, '/usr/bin/gradle'),
-    (Command('npm tasks', stderr='npm: not found'), True, None)])
+    (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

tests/rules/test_grep_arguments_order.py

@@ -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', [
+@pytest.mark.parametrize('script, output', [
-    ('cat test.py', stderr('test')),
+    ('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):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    assert not match(Command(script, output))
 
 
-@pytest.mark.parametrize('script, stderr, result', [
+@pytest.mark.parametrize('script, output, result', [
-    ('grep test.py test', stderr('test'), 'grep test test.py'),
+    ('grep test.py test', output('test'), 'grep test test.py'),
-    ('grep -lir . test', stderr('test'), 'grep -lir test .'),
+    ('grep -lir . test', output('test'), 'grep -lir test .'),
-    ('grep . test -lir', stderr('test'), 'grep test -lir .'),
+    ('grep . test -lir', output('test'), 'grep test -lir .'),
-    ('egrep test.py test', stderr('test'), 'egrep test test.py'),
+    ('egrep test.py test', output('test'), 'egrep test test.py'),
-    ('egrep -lir . test', stderr('test'), 'egrep -lir test .'),
+    ('egrep -lir . test', output('test'), 'egrep -lir test .'),
-    ('egrep . test -lir', stderr('test'), 'egrep test -lir .')])
+    ('egrep . test -lir', output('test'), 'egrep test -lir .')])
-def test_get_new_command(script, stderr, result):
+def test_get_new_command(script, output, result):
-    assert get_new_command(Command(script, stderr=stderr)) == result
+    assert get_new_command(Command(script, output)) == result

tests/rules/test_grep_recursive.py

@@ -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('grep blah .', 'grep: .: Is a directory'))
-    assert match(Command(u'grep café .', stderr='grep: .: Is a directory'))
+    assert match(Command(u'grep café .', 'grep: .: Is a directory'))
-    assert not match(Command())
+    assert not match(Command('', ''))
 
 
 def test_get_new_command():
-    assert get_new_command(Command('grep blah .')) == 'grep -r blah .'
+    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(u'grep café .', '')) == u'grep -r café .'

tests/rules/test_grunt_task_not_found.py

@@ -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 defualt', output('defualt')),
-    Command('grunt buld:css', stdout('buld:css'))])
+    Command('grunt buld:css', output('buld:css'))])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command', [
-    Command('npm nuild', stdout('nuild')),
+    Command('npm nuild', output('nuild')),
-    Command('grunt rm')])
+    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 defualt', output('defualt')), 'grunt default'),
-    (Command('grunt cmpass:all', stdout('cmpass:all')), 'grunt compass:all'),
+    (Command('grunt cmpass:all', output('cmpass:all')), 'grunt compass:all'),
-    (Command('grunt cmpass:all --color', stdout('cmpass: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

tests/rules/test_gulp_not_task.py

@@ -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']

tests/rules/test_has_exists_script.py

@@ -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('main', 'main: command not found'))
-        assert match(Command(script='main --help',
+        assert match(Command('main --help',
-                             stderr='main: command not found'))
+                             'main: command not found'))
-        assert not match(Command(script='main', stderr=''))
+        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'

tests/rules/test_heroku_not_command.py

@@ -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', [
+@pytest.mark.parametrize('script, output', [
-    ('cat log', suggest_stderr)])
+    ('cat log', suggest_output)])
-def test_not_match(script, stderr):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    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

tests/rules/test_history.py

@@ -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

tests/rules/test_hostscli.py

@@ -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',
+    Command('hostscli block a_website_that_does_not_exist', no_website_long)])
-            stderr=no_website_long)])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command, result', [(
-    Command('hostscli block a_website_that_does_not_exist',
+    Command('hostscli block a_website_that_does_not_exist', no_website_long),
-            stderr=no_website_long),
     ['hostscli websites'])])
 def test_get_new_command(command, result):
     assert get_new_command(command) == result

tests/rules/test_ifconfig_device_not_found.py

@@ -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', [
+@pytest.mark.parametrize('script, output', [
-    ('ifconfig wlan0', stderr.format('wlan0')),
+    ('ifconfig wlan0', output.format('wlan0')),
-    ('ifconfig -s eth0', stderr.format('eth0')),
+    ('ifconfig -s eth0', output.format('eth0')),
 ])
-def test_match(script, stderr):
+def test_match(script, output):
-    assert match(Command(script, stderr=stderr))
+    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):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    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

tests/rules/test_java.py

@@ -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('java foo.java', ''),
-    Command(script='java bar.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 foo.java', ''), 'java foo'),
-    (Command('java bar.java'), 'java bar')])
+    (Command('java bar.java', ''), 'java bar')])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_javac.py

@@ -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('javac foo', ''),
-    Command(script='javac bar')])
+    Command('javac bar', '')])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command, new_command', [
-    (Command('javac foo'), 'javac foo.java'),
+    (Command('javac foo', ''), 'javac foo.java'),
-    (Command('javac bar'), 'javac bar.java')])
+    (Command('javac bar', ''), 'javac bar.java')])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_lein_not_task.py

@@ -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 match(Command('lein rpl', is_not_task))
-    assert not match(Command(script='ls', stderr=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'])

tests/rules/test_ln_no_hard_link.py

@@ -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):
+def test_match(script, output):
-    command = Command(script, stderr=stderr.format(error))
+    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):
+def test_not_match(script, output):
-    command = Command(script, stderr=stderr)
+    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

tests/rules/test_ln_s_order.py

@@ -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', [
+@pytest.mark.parametrize('script, output, exists', [
-    ('ln dest source', get_stderr('source'), True),
+    ('ln dest source', get_output('source'), True),
-    ('ls -s dest source', get_stderr('source'), True),
+    ('ls -s dest source', get_output('source'), True),
     ('ln -s dest source', '', True),
-    ('ln -s dest source', get_stderr('source'), False)])
+    ('ln -s dest source', get_output('source'), False)])
-def test_not_match(file_exists, script, stderr, exists):
+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')
+    output = get_output('source')
-    assert match(Command(script, stderr=stderr))
+    assert match(Command(script, output))
-    assert get_new_command(Command(script, stderr=stderr)) == result
+    assert get_new_command(Command(script, output)) == result

tests/rules/test_ls_all.py

@@ -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 match(Command('ls', ''))
-    assert not match(Command(script='ls', stdout='file.py\n'))
+    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('ls empty_dir', '')) == 'ls -A empty_dir'
-    assert get_new_command(Command(script='ls')) == 'ls -A'
+    assert get_new_command(Command('ls', '')) == 'ls -A'

tests/rules/test_ls_lah.py

@@ -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('ls', ''))
-    assert match(Command(script='ls file.py'))
+    assert match(Command('ls file.py', ''))
-    assert match(Command(script='ls /opt'))
+    assert match(Command('ls /opt', ''))
-    assert not match(Command(script='ls -lah /opt'))
+    assert not match(Command('ls -lah /opt', ''))
-    assert not match(Command(script='pacman -S binutils'))
+    assert not match(Command('pacman -S binutils', ''))
-    assert not match(Command(script='lsof'))
+    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('ls file.py', '')) == 'ls -lah file.py'
-    assert get_new_command(Command(script='ls')) == 'ls -lah'
+    assert get_new_command(Command('ls', '')) == 'ls -lah'

tests/rules/test_man.py

@@ -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 read', ''),
-    Command('man 2 read'),
+    Command('man 2 read', ''),
-    Command('man 3 read'),
+    Command('man 3 read', ''),
-    Command('man -s2 read'),
+    Command('man -s2 read', ''),
-    Command('man -s3 read'),
+    Command('man -s3 read', ''),
-    Command('man -s 2 read'),
+    Command('man -s 2 read', ''),
-    Command('man -s 3 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 read', ''), ['man 3 read', 'man 2 read', 'read --help']),
-    (Command('man missing', stderr="No manual entry for missing\n"), ['missing --help']),
+    (Command('man missing', "No manual entry for missing\n"), ['missing --help']),
-    (Command('man 2 read'), 'man 3 read'),
+    (Command('man 2 read', ''), 'man 3 read'),
-    (Command('man 3 read'), 'man 2 read'),
+    (Command('man 3 read', ''), 'man 2 read'),
-    (Command('man -s2 read'), 'man -s3 read'),
+    (Command('man -s2 read', ''), 'man -s3 read'),
-    (Command('man -s3 read'), 'man -s2 read'),
+    (Command('man -s3 read', ''), 'man -s2 read'),
-    (Command('man -s 2 read'), 'man -s 3 read'),
+    (Command('man -s 2 read', ''), 'man -s 3 read'),
-    (Command('man -s 3 read'), 'man -s 2 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

tests/rules/test_man_no_space.py

@@ -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 match(Command('mandiff', 'mandiff: command not found'))
-    assert not match(Command())
+    assert not match(Command('', ''))
 
 
 def test_get_new_command():
-    assert get_new_command(
+    assert get_new_command(Command('mandiff', '')) == 'man diff'
-        Command('mandiff')) == 'man diff'

tests/rules/test_mercurial.py

@@ -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'),

tests/rules/test_missing_space_before_subcommand.py

@@ -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

tests/rules/test_mkdir_p.py

@@ -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('mkdir foo/bar/baz', '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('./bin/hdfs dfs -mkdir foo/bar/baz', '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('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', ''),
-    Command('mkdir foo/bar/baz', stderr='foo bar baz'),
+    Command('mkdir foo/bar/baz', 'foo bar baz'),
-    Command('hdfs dfs -mkdir foo/bar/baz'),
+    Command('hdfs dfs -mkdir foo/bar/baz', ''),
-    Command('./bin/hdfs dfs -mkdir foo/bar/baz'),
+    Command('./bin/hdfs dfs -mkdir foo/bar/baz', ''),
-    Command(),
+    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('mkdir foo/bar/baz', ''), 'mkdir -p foo/bar/baz'),
-    (Command('hdfs dfs -mkdir foo/bar/baz'), 'hdfs dfs -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('./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

tests/rules/test_mvn_no_command.py

@@ -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('mvn --help', ''),
-    Command(script='mvn -v')
+    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('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(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 -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

tests/rules/test_mvn_unknown_lifecycle_phase.py

@@ -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('mvn --help', ''),
-    Command(script='mvn -v')
+    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('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(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 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

tests/rules/test_no_command.py

@@ -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

tests/rules/test_no_such_file.py

@@ -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('mv foo bar/foo', "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/', "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('mv foo bar/', ""),
-    Command(script='mv foo bar/foo', stderr="mv: permission denied"),
+    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('mv foo bar/foo', "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/', "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

tests/rules/test_npm_missing_script.py

@@ -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 ru wach', output('wach')),
-    Command('npm run live-tes', stderr=stderr('live-tes')),
+    Command('npm run live-tes', output('live-tes')),
-    Command('npm run-script sahare', stderr=stderr('sahare'))])
+    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('npm wach', output('wach')),
-    Command('vim live-tes', stderr=stderr('live-tes')),
+    Command('vim live-tes', output('live-tes')),
-    Command('npm run-script sahare')])
+    Command('npm run-script sahare', '')])
 def test_not_match(command):
     assert not match(command)
 
 
-@pytest.mark.parametrize('script, stderr, result', [
+@pytest.mark.parametrize('script, output, result', [
-    ('npm ru wach-tests', stderr('wach-tests'), 'npm ru watch-test'),
+    ('npm ru wach-tests', output('wach-tests'), 'npm ru watch-test'),
-    ('npm -i run-script dvelop', stderr('dvelop'),
+    ('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):
+def test_get_new_command(script, output, result):
-    command = Command(script, stderr=stderr)
+    command = Command(script, output)
 
     assert get_new_command(command)[0] == result

tests/rules/test_npm_run_script.py

@@ -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('npm test', output), run_script_stdout),
-    (Command('vim watch-test', stdout), 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

tests/rules/test_npm_wrong_command.py

@@ -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),
+    ('npm', output),
-    ('test urgrade', stdout),
+    ('test urgrade', output),
-    ('npm -e', stdout)])
+    ('npm -e', output)])
-def test_not_match(script, stdout):
+def test_not_match(script, output):
-    assert not match(Command(script, stdout))
+    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

tests/rules/test_open.py

@@ -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):
+def test_match(script, output):
-    assert match(Command(script, stderr=stderr))
+    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):
+def test_get_new_command(script, new_command, output):
-    assert get_new_command(Command(script, stderr=stderr)) == new_command
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_pacman.py

@@ -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('vim', 'vim: command not found'),
-    Command(script='sudo vim', stderr='sudo: 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('vim', 'vim: command not found'), PKGFILE_OUTPUT_VIM),
-    (Command(script='sudo vim', stderr='sudo: 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('vim', ''), Command('', ''),
-    Command(script='sudo vim', stderr=''), 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('vim', ''), vim_possibilities),
-    (Command('sudo vim'), sudo_vim_possibilities),
+    (Command('sudo vim', ''), sudo_vim_possibilities),
-    (Command('convert'), ['{} -S extra/imagemagick && convert'.format(pacman_cmd)]),
+    (Command('convert', ''), ['{} -S extra/imagemagick && convert'.format(pacman_cmd)]),
-    (Command('sudo convert'), ['{} -S extra/imagemagick && sudo 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('vim', ''), vim_possibilities, PKGFILE_OUTPUT_VIM),
-    (Command('sudo vim'), sudo_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('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', ''), ['{} -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('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):

tests/rules/test_pacman_not_found.py

@@ -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('yaourt -S llc', 'error: target not found: llc'),
-    Command(script='pacman llc', stderr='error: target not found: llc'),
+    Command('pacman llc', 'error: target not found: llc'),
-    Command(script='sudo pacman llc', stderr='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('yaourt -S llc', 'error: target not found: llc'),
-    Command(script='pacman llc', stderr='error: target not found: llc'),
+    Command('pacman llc', 'error: target not found: llc'),
-    Command(script='sudo pacman llc', stderr='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('yaourt -S llc', '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('pacman -S llc', '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('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('yaourt -S llc', '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('pacman -S llc', '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('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

tests/rules/test_path_from_history.py

@@ -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):
+def test_match(script, output):
-    assert match(Command(script, stderr=stderr))
+    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):
+def test_not_match(script, output):
-    assert not match(Command(script, stderr=stderr))
+    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):
+def test_get_new_command(script, output, result):
-    new_command = get_new_command(Command(script, stderr=stderr))
+    new_command = get_new_command(Command(script, output))
     assert new_command[0] == result

tests/rules/test_pip_unknown_command.py

@@ -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'

tests/rules/test_port_already_in_use.py

@@ -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', output) for output in outputs]
-    + [Command('./app', stderr=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', ''), lsof_stdout),
-    (Command('./app', stdout=outputs[1]), b''),
+    (Command('./app', outputs[1]), b''),
-    (Command('./app', stderr=outputs[2]), 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', output) for output in outputs]
-    + [Command('./app', stderr=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'

tests/rules/test_python_command.py

@@ -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 match(Command('temp.py', 'Permission denied'))
-    assert not match(Command())
+    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')

tests/rules/test_python_execute.py

@@ -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('python foo', ''),
-    Command(script='python bar')])
+    Command('python bar', '')])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command, new_command', [
-    (Command('python foo'), 'python foo.py'),
+    (Command('python foo', ''), 'python foo.py'),
-    (Command('python bar'), 'python bar.py')])
+    (Command('python bar', ''), 'python bar.py')])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_quotation_marks.py

@@ -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("git commit -m \'My Message\"", ''),
-    Command(script="git commit -am \"Mismatched Quotation Marks\'"),
+    Command("git commit -am \"Mismatched Quotation Marks\'", ''),
-    Command(script="echo \"hello\'")])
+    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 -m \'My Message\"", ''), "git commit -m \"My Message\""),
-    (Command("git commit -am \"Mismatched Quotation Marks\'"), "git commit -am \"Mismatched Quotation Marks\""),
+    (Command("git commit -am \"Mismatched Quotation Marks\'", ''), "git commit -am \"Mismatched Quotation Marks\""),
-    (Command("echo \"hello\'"), "echo \"hello\"")])
+    (Command("echo \"hello\'", ''), "echo \"hello\"")])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_react_native_command_unrecognized.py

@@ -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 star', output('star')),
-    Command('react-native android-logs', stderr=stderr('android-logs'))])
+    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('gradle star', output('star')),
-    Command('react-native start')])
+    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(

tests/rules/test_remove_trailing_cedilla.py

@@ -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('wrong' + CEDILLA, ''),
-    Command(script='wrong with args' + 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' + CEDILLA, ''), 'wrong'),
-    (Command('wrong with args' + CEDILLA), 'wrong with args')])
+    (Command('wrong with args' + CEDILLA, ''), 'wrong with args')])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command