Refine tests

tests/test_main.py

@@ -1,51 +1,56 @@
+import pytest
 from subprocess import PIPE
 from pathlib import PosixPath, Path
-from mock import patch, Mock
+from mock import Mock
 from thefuck import main, conf, types
 from tests.utils import Rule, Command
 
 
-def test_load_rule():
+def test_load_rule(monkeypatch):
     match = object()
     get_new_command = object()
-    with patch('thefuck.main.load_source',
-               return_value=Mock(
-                   match=match,
-                   get_new_command=get_new_command,
-                   enabled_by_default=True)) as load_source:
-        assert main.load_rule(Path('/rules/bash.py')) \
-               == Rule('bash', match, get_new_command)
-        load_source.assert_called_once_with('bash', '/rules/bash.py')
+    load_source = Mock()
+    load_source.return_value = Mock(match=match,
+                                    get_new_command=get_new_command,
+                                    enabled_by_default=True)
+    monkeypatch.setattr('thefuck.main.load_source', load_source)
+    assert main.load_rule(Path('/rules/bash.py')) \
+           == Rule('bash', match, get_new_command)
+    load_source.assert_called_once_with('bash', '/rules/bash.py')
 
 
-def test_get_rules():
-    with patch('thefuck.main.Path.glob') as glob, \
-            patch('thefuck.main.load_source',
-                  lambda x, _: Mock(match=x, get_new_command=x,
-                                    enabled_by_default=True)):
-        glob.return_value = [PosixPath('bash.py'), PosixPath('lisp.py')]
-        assert list(main.get_rules(
-            Path('~'),
-            Mock(rules=conf.DEFAULT_RULES))) \
-               == [Rule('bash', 'bash', 'bash'),
-                   Rule('lisp', 'lisp', 'lisp'),
-                   Rule('bash', 'bash', 'bash'),
-                   Rule('lisp', 'lisp', 'lisp')]
-        assert list(main.get_rules(
-            Path('~'),
-            Mock(rules=types.RulesNamesList(['bash'])))) \
-               == [Rule('bash', 'bash', 'bash'),
-                   Rule('bash', 'bash', 'bash')]
+@pytest.mark.parametrize('conf_rules, rules', [
+    (conf.DEFAULT_RULES, [Rule('bash', 'bash', 'bash'),
+                          Rule('lisp', 'lisp', 'lisp'),
+                          Rule('bash', 'bash', 'bash'),
+                          Rule('lisp', 'lisp', 'lisp')]),
+    (types.RulesNamesList(['bash']), [Rule('bash', 'bash', 'bash'),
+                                      Rule('bash', 'bash', 'bash')])])
+def test_get_rules(monkeypatch, conf_rules, rules):
+    monkeypatch.setattr(
+        'thefuck.main.Path.glob',
+        lambda *_: [PosixPath('bash.py'), PosixPath('lisp.py')])
+    monkeypatch.setattr('thefuck.main.load_source',
+                        lambda x, _: Mock(match=x, get_new_command=x,
+                                          enabled_by_default=True))
+    assert list(main.get_rules(Path('~'), Mock(rules=conf_rules))) == rules
 
 
-def test_get_command():
-    with patch('thefuck.main.Popen') as Popen, \
-            patch('thefuck.main.os.environ',
-                  new_callable=lambda: {}), \
-            patch('thefuck.main.wait_output',
-                  return_value=True):
+class TestGetCommand(object):
+    @pytest.fixture(autouse=True)
+    def Popen(self, monkeypatch):
+        Popen = Mock()
         Popen.return_value.stdout.read.return_value = b'stdout'
         Popen.return_value.stderr.read.return_value = b'stderr'
+        monkeypatch.setattr('thefuck.main.Popen', Popen)
+        return Popen
+
+    @pytest.fixture(autouse=True)
+    def prepare(self, monkeypatch):
+        monkeypatch.setattr('thefuck.main.os.environ', {})
+        monkeypatch.setattr('thefuck.main.wait_output', lambda *_: True)
+
+    def test_get_command_calls(self, Popen):
         assert main.get_command(Mock(), Mock(),
             ['thefuck', 'apt-get', 'search', 'vim']) \
                == Command('apt-get search vim', 'stdout', 'stderr')
@@ -54,81 +59,113 @@ def test_get_command():
                                       stdout=PIPE,
                                       stderr=PIPE,
                                       env={'LANG': 'C'})
-        assert main.get_command(Mock(), Mock(), ['']) is None
-        # When command is `fuck`:
-        assert main.get_command(
-            Mock(),
-            Mock(last_script='ls', last_fixed_script='ls -la'),
-            ['thefuck', 'fuck']).script == 'ls -la'
-        # When command equals to last command:
-        assert main.get_command(
-            Mock(),
-            Mock(last_script='ls', last_fixed_script='ls -la'),
-            ['thefuck', 'ls']).script == 'ls -la'
-        # When last command is `fuck` and no last fixed script:
-        assert main.get_command(
-            Mock(),
-            Mock(last_script='ls', last_fixed_script=''),
-            ['thefuck', 'ls']).script == 'ls'
+
+    @pytest.mark.parametrize('history, args, result', [
+        (Mock(), [''], None),
+        (Mock(last_script='ls', last_fixed_script='ls -la'),
+         ['thefuck', 'fuck'], 'ls -la'),
+        (Mock(last_script='ls', last_fixed_script='ls -la'),
+         ['thefuck', 'ls'], 'ls -la'),
+        (Mock(last_script='ls', last_fixed_script=''),
+         ['thefuck', 'ls'], 'ls'),
+        (Mock(last_script='ls', last_fixed_script=''),
+         ['thefuck', 'fuck'], 'ls')])
+    def test_get_command_script(self, history, args, result):
+        if result:
+            assert main.get_command(Mock(), history, args).script == result
+        else:
+            assert main.get_command(Mock(), history, args) is None
 
 
-def test_get_matched_rule(capsys):
-    rules = [Rule('', lambda x, _: x.script == 'cd ..'),
-             Rule('', lambda *_: False),
-             Rule('rule', Mock(side_effect=OSError('Denied')))]
-    assert main.get_matched_rule(Command('ls'),
-                                 rules, Mock(no_colors=True)) is None
-    assert main.get_matched_rule(Command('cd ..'),
-                                 rules, Mock(no_colors=True)) == rules[0]
-    assert capsys.readouterr()[1].split('\n')[0] \
-           == '[WARN] Rule rule:'
+class TestGetMatchedRule(object):
+    @pytest.fixture
+    def rules(self):
+        return [Rule('', lambda x, _: x.script == 'cd ..'),
+                Rule('', lambda *_: False),
+                Rule('rule', Mock(side_effect=OSError('Denied')))]
+
+    def test_no_match(self):
+        assert main.get_matched_rule(
+            Command('ls'), [Rule('', lambda *_: False)],
+            Mock(no_colors=True)) is None
+
+    def test_match(self):
+        rule = Rule('', lambda x, _: x.script == 'cd ..')
+        assert main.get_matched_rule(
+            Command('cd ..'), [rule], Mock(no_colors=True)) == rule
+
+    def test_when_rule_failed(self, capsys):
+        main.get_matched_rule(
+            Command('ls'), [Rule('test', Mock(side_effect=OSError('Denied')))],
+            Mock(no_colors=True))
+        assert capsys.readouterr()[1].split('\n')[0] == '[WARN] Rule test:'
 
 
-def test_run_rule(capsys):
-    with patch('thefuck.main.confirm', return_value=True):
+class TestRunRule(object):
+    @pytest.fixture(autouse=True)
+    def confirm(self, monkeypatch):
+        mock = Mock(return_value=True)
+        monkeypatch.setattr('thefuck.main.confirm', mock)
+        return mock
+
+    def test_run_rule(self, capsys):
         main.run_rule(Rule(get_new_command=lambda *_: 'new-command'),
                       Command(), Mock(), None)
         assert capsys.readouterr() == ('new-command\n', '')
-        # With side effect:
+
+    def test_run_rule_with_side_effect(self, capsys):
         side_effect = Mock()
         settings = Mock()
-        command = Mock(script='ls')
-        history = Mock()
+        command = Command()
         main.run_rule(Rule(get_new_command=lambda *_: 'new-command',
                            side_effect=side_effect),
-                      command, history, settings)
+                      command, Mock(), settings)
         assert capsys.readouterr() == ('new-command\n', '')
         side_effect.assert_called_once_with(command, settings)
-        # Ensure that history updated:
+
+    def test_hisotry_updated(self):
+        history = Mock()
+        main.run_rule(Rule(get_new_command=lambda *_: 'ls -lah'),
+                      Command('ls'), history, None)
         history.update.assert_called_once_with(last_script='ls',
-                                               last_fixed_script='new-command')
-    with patch('thefuck.main.confirm', return_value=False):
+                                               last_fixed_script='ls -lah')
+
+    def test_when_not_comfirmed(self, capsys, confirm):
+        confirm.return_value = False
         main.run_rule(Rule(get_new_command=lambda *_: 'new-command'),
                       Command(), Mock(), None)
         assert capsys.readouterr() == ('', '')
 
 
-def test_confirm(capsys):
-    # When confirmation not required:
-    assert main.confirm('command', None, Mock(require_confirmation=False))
-    assert capsys.readouterr() == ('', 'command\n')
-    # With side effect and without confirmation:
-    assert main.confirm('command', Mock(), Mock(require_confirmation=False))
-    assert capsys.readouterr() == ('', 'command*\n')
-    # When confirmation required and confirmed:
-    with patch('thefuck.main.sys.stdin.read', return_value='\n'):
-        assert main.confirm(
-            'command', None, Mock(require_confirmation=True,
-                                  no_colors=True))
+class TestConfirm(object):
+    @pytest.fixture
+    def stdin(self, monkeypatch):
+        mock = Mock(return_value='\n')
+        monkeypatch.setattr('sys.stdin.read', mock)
+        return mock
+
+    def test_when_not_required(self, capsys):
+        assert main.confirm('command', None, Mock(require_confirmation=False))
+        assert capsys.readouterr() == ('', 'command\n')
+
+    def test_with_side_effect_and_without_confirmation(self, capsys):
+        assert main.confirm('command', Mock(), Mock(require_confirmation=False))
+        assert capsys.readouterr() == ('', 'command*\n')
+
+    # `stdin` fixture should be applied after `capsys`
+    def test_when_confirmation_required_and_confirmed(self, capsys, stdin):
+        assert main.confirm('command', None, Mock(require_confirmation=True,
+                                                  no_colors=True))
         assert capsys.readouterr() == ('', 'command [enter/ctrl+c]')
-        # With side effect:
-        assert main.confirm(
-            'command', Mock(), Mock(require_confirmation=True,
-                                    no_colors=True))
+
+    # `stdin` fixture should be applied after `capsys`
+    def test_when_confirmation_required_and_confirmed_with_side_effect(self, capsys, stdin):
+        assert main.confirm('command', Mock(), Mock(require_confirmation=True,
+                                                    no_colors=True))
         assert capsys.readouterr() == ('', 'command* [enter/ctrl+c]')
-    # When confirmation required and ctrl+c:
-    with patch('thefuck.main.sys.stdin.read', side_effect=KeyboardInterrupt):
-        assert not main.confirm('command', None,
-                                Mock(require_confirmation=True,
-                                     no_colors=True))
+
+    def test_when_confirmation_required_and_aborted(self, capsys, stdin):
+        stdin.side_effect = KeyboardInterrupt
+        assert not main.confirm('command', None, Mock(require_confirmation=True,
+                                                      no_colors=True))
         assert capsys.readouterr() == ('', 'command [enter/ctrl+c]Aborted\n')