Add inverse option with "--no-" prefix for store_true options (#267)

Fixes upstream issue: #6846.

Author: blueyed

src/_pytest/config/argparsing.py

@@ -110,6 +110,7 @@ def _getparser(self) -> "MyOptionParser":
 
         optparser = MyOptionParser(self, self.extra_info, prog=self.prog)
         groups = self._groups + [self._anonymous]
+        self._preprocess_options_for_no_prefix(groups)
         for group in groups:
             if group.options:
                 desc = group.description or group.name
@@ -124,6 +125,33 @@ def _getparser(self) -> "MyOptionParser":
         file_or_dir_arg.completer = filescompleter  # type: ignore
         return optparser
 
+    def _preprocess_options_for_no_prefix(self, groups: List["OptionGroup"]) -> None:
+        """Add "--no-"-prefixed option names for "store_true" actions."""
+        all_names = []
+        store_true_options = []
+        for option in [option for group in groups for option in group.options]:
+            names = option.names()
+            if option.attrs().get("action") == "store_true":
+                store_true_options.append((option, names))
+            all_names.extend(names)
+
+        for option, option_names in store_true_options:
+            new_option_strings = []
+            for option_string in option_names:
+                if option_string.startswith("--no-"):
+                    new = "--{}".format(option_string[5:])
+                elif option_string.startswith("--"):
+                    new = "--no-{}".format(option_string[2:])
+                else:
+                    continue
+                if new not in all_names:
+                    new_option_strings.append(new)
+
+            if new_option_strings:
+                option._long_opts.extend(new_option_strings)
+                assert option._attrs["action"] == "store_true", option
+                option._attrs["action"] = "store_true_with_no_prefix"
+
     def parse_setoption(
         self,
         args: Sequence[Union[str, py.path.local]],
@@ -377,6 +405,16 @@ def _addoption_instance(self, option: "Argument", shortupper: bool = False) -> N
         self.options.append(option)
 
 
+class StoreTrueWithNoPrefixAction(argparse._StoreTrueAction):
+    """Handle `--no-foo` for `--foo` options."""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        if option_string.startswith("--no-"):
+            setattr(namespace, self.dest, False)
+        else:
+            setattr(namespace, self.dest, True)
+
+
 class MyOptionParser(argparse.ArgumentParser):
     def __init__(
         self,
@@ -396,6 +434,9 @@ def __init__(
         # extra_info is a dict of (param -> value) to display if there's
         # an usage error to provide more contextual information to the user
         self.extra_info = extra_info if extra_info else {}
+        self.register(
+            "action", "store_true_with_no_prefix", StoreTrueWithNoPrefixAction
+        )
 
     def error(self, message: str) -> "NoReturn":
         """Transform argparse error message into UsageError."""
@@ -515,6 +556,19 @@ def _format_action_invocation(self, action: argparse.Action) -> str:
                 return_list.append(option)
             if option[2:] == short_long.get(option.replace("-", "")):
                 return_list.append(option.replace(" ", "=", 1))
+
+        if isinstance(action, StoreTrueWithNoPrefixAction):
+            # Collapse "--foo, --no-foo" into "--[no-]foo".
+            idx = 0
+            while idx < len(return_list):
+                option = return_list[idx]
+                if option.startswith("--"):
+                    other_idx = return_list.index("--no-{}".format(option[2:]))
+                    return_list.pop(other_idx)
+                    option = "--[no-]" + option[2:]
+                    return_list = return_list[:idx] + [option] + return_list[idx + 1 :]
+                idx += 1
+
         formatted_action_invocation = ", ".join(return_list)
         action._formatted_action_invocation = formatted_action_invocation  # type: ignore
         return formatted_action_invocation

src/_pytest/helpconfig.py

@@ -49,7 +49,8 @@ def pytest_addoption(parser):
     group.addoption(
         "--version",
         "-V",
-        action="store_true",
+        action="store_const",
+        const=True,
         help="display pytest version and information about plugins.",
     )
     group._addoption(

src/_pytest/pytester.py

@@ -17,6 +17,7 @@
 from typing import Generator
 from typing import Iterable
 from typing import List
+from typing import Mapping
 from typing import Optional
 from typing import Sequence
 from typing import Tuple
@@ -654,25 +655,34 @@ def chdir(self):
         """
         self.tmpdir.chdir()
 
-    def _makefile(self, ext, lines, files, encoding="utf-8"):
+    def _makefile(
+        self,
+        ext: str,
+        lines: Sequence[Union[bytes, str]],
+        files: Mapping[str, Sequence[Union[bytes, str]]],
+        encoding="utf-8",
+    ) -> py.path.local:
         items = list(files.items())
 
         def to_text(s):
             return s.decode(encoding) if isinstance(s, bytes) else str(s)
 
         if lines:
-            source = "\n".join(to_text(x) for x in lines)
-            basename = self.request.function.__name__
-            items.insert(0, (basename, source))
+            funcname = self.request.function.__name__  # type: str
+            lines = "\n".join(to_text(x) for x in lines)
+            items.insert(0, (funcname, lines))
+
+        if not items:
+            raise ValueError("no files to create")
 
-        ret = None
+        first_p = True
         for basename, value in items:
             p = self.tmpdir.join(basename).new(ext=ext)
             p.dirpath().ensure_dir()
-            source = Source(value)
-            source = "\n".join(to_text(line) for line in source.lines)
+            source = "\n".join(to_text(x) for x in Source(value).lines)
             p.write(source.strip().encode(encoding), "wb")
-            if ret is None:
+            if first_p:
+                first_p = False
                 ret = p
         return ret
 
@@ -710,7 +720,7 @@ def getinicfg(self, source):
         p = self.makeini(source)
         return py.iniconfig.IniConfig(p)["pytest"]
 
-    def makepyfile(self, *args, **kwargs):
+    def makepyfile(self, *args, **kwargs) -> py.path.local:
         """Shortcut for .makefile() with a .py extension."""
         return self._makefile(".py", args, kwargs)
 

testing/test_conftest.py

@@ -1,12 +1,13 @@
 import os
 import textwrap
 
-import py
+import py.path
 
 import pytest
 from _pytest.config import ExitCode
 from _pytest.config import PytestPluginManager
 from _pytest.pathlib import Path
+from _pytest.pytester import Testdir
 
 
 def ConftestWithSetinitial(path):
@@ -174,19 +175,25 @@ def test_setinitial_conftest_subdirs(testdir, name):
         assert len(conftest._conftestpath2mod) == 0
 
 
-def test_conftest_confcutdir(testdir):
-    testdir.makeconftest("assert 0")
-    x = testdir.mkdir("x")
-    x.join("conftest.py").write(
-        textwrap.dedent(
-            """\
-            def pytest_addoption(parser):
-                parser.addoption("--xyz", action="store_true")
-            """
-        )
+@pytest.fixture
+def conftest_in_tests(testdir: Testdir) -> py.path.local:
+    return testdir.makepyfile(
+        **{
+            "tests/conftest": """
+        def pytest_addoption(parser):
+            parser.addoption("--xyz", action="store_const", const=True)
+        """
+        }
     )
+
+
+def test_conftest_confcutdir(
+    testdir: Testdir, conftest_in_tests: py.path.local
+) -> None:
+    testdir.makeconftest("assert 0")
+    x = conftest_in_tests.dirpath()
     result = testdir.runpytest("-h", "--confcutdir=%s" % x, x)
-    result.stdout.fnmatch_lines(["*--xyz*"])
+    result.stdout.fnmatch_lines(["custom options:", "  --xyz"])
     result.stdout.no_fnmatch_line("*warning: could not load initial*")
 
 
@@ -319,31 +326,17 @@ def test_no_conftest(testdir):
     assert result.ret == ExitCode.USAGE_ERROR
 
 
-def test_conftest_existing_resultlog(testdir):
-    x = testdir.mkdir("tests")
-    x.join("conftest.py").write(
-        textwrap.dedent(
-            """\
-            def pytest_addoption(parser):
-                parser.addoption("--xyz", action="store_true")
-            """
-        )
-    )
+def test_conftest_existing_resultlog(
+    testdir: Testdir, conftest_in_tests: py.path.local
+) -> None:
     testdir.makefile(ext=".log", result="")  # Writes result.log
     result = testdir.runpytest("-h", "--resultlog", "result.log")
     result.stdout.fnmatch_lines(["*--xyz*"])
 
 
-def test_conftest_existing_junitxml(testdir):
-    x = testdir.mkdir("tests")
-    x.join("conftest.py").write(
-        textwrap.dedent(
-            """\
-            def pytest_addoption(parser):
-                parser.addoption("--xyz", action="store_true")
-            """
-        )
-    )
+def test_conftest_existing_junitxml(
+    testdir: Testdir, conftest_in_tests: py.path.local
+) -> None:
     testdir.makefile(ext=".xml", junit="")  # Writes junit.xml
     result = testdir.runpytest("-h", "--junitxml", "junit.xml")
     result.stdout.fnmatch_lines(["*--xyz*"])
@@ -409,24 +402,13 @@ def test_event_fixture(bar):
     result.stdout.fnmatch_lines(["*1 passed*"])
 
 
-def test_conftest_found_with_double_dash(testdir):
-    sub = testdir.mkdir("sub")
-    sub.join("conftest.py").write(
-        textwrap.dedent(
-            """\
-            def pytest_addoption(parser):
-                parser.addoption("--hello-world", action="store_true")
-            """
-        )
-    )
-    p = sub.join("test_hello.py")
+def test_conftest_found_with_double_dash_in_arg(
+    testdir: Testdir, conftest_in_tests: py.path.local
+) -> None:
+    p = conftest_in_tests.dirpath().join("test_hello.py")
     p.write("def test_hello(): pass")
     result = testdir.runpytest(str(p) + "::test_hello", "-h")
-    result.stdout.fnmatch_lines(
-        """
-        *--hello-world*
-    """
-    )
+    result.stdout.fnmatch_lines(["*--xyz*"])
 
 
 class TestConftestVisibility:
@@ -643,17 +625,13 @@ def pytest_ignore_collect(path, config):
     )
 
 
-def test_required_option_help(testdir):
-    testdir.makeconftest("assert 0")
-    x = testdir.mkdir("x")
-    x.join("conftest.py").write(
-        textwrap.dedent(
-            """\
-            def pytest_addoption(parser):
-                parser.addoption("--xyz", action="store_true", required=True)
-            """
-        )
+def test_required_option_help(testdir: Testdir) -> None:
+    testdir.makeconftest(
+        """
+        def pytest_addoption(parser):
+            parser.addoption("--xyz", action="store_true", required=True)
+        """
     )
-    result = testdir.runpytest("-h", x)
+    result = testdir.runpytest("-h")
     result.stdout.no_fnmatch_line("*argument --xyz is required*")
-    assert "general:" in result.stdout.str()
+    result.stdout.fnmatch_lines(["general:", "custom options:", "  --[no-]xyz"])

testing/test_helpconfig.py

@@ -1,5 +1,6 @@
 import pytest
 from _pytest.config import ExitCode
+from _pytest.pytester import Testdir
 
 
 def test_version(testdir, pytestconfig):
@@ -14,15 +15,28 @@ def test_version(testdir, pytestconfig):
         result.stderr.fnmatch_lines(["*setuptools registered plugins:", "*at*"])
 
 
-def test_help(testdir):
+def test_help(testdir: Testdir) -> None:
     result = testdir.runpytest("--help", "-p", "no:[defaults]")
     assert result.ret == 0
     result.stdout.fnmatch_lines(
         """
+        usage: * [[]options[]] [[]file_or_dir[]] [[]file_or_dir[]] [[]...[]]
+
+        positional arguments:
+          file_or_dir
+
           -m MARKEXPR           only run tests matching given mark expression.
                                 For example: -m 'mark1 and not mark2'.
         reporting:
           --durations=N *
+
+        collection:
+          --[[]no-[]]collect-only, --[[]no-[]]co
+
+        test session debugging and configuration:
+          -V, --version         display pytest version and information about plugins.
+          -h, --help            show help message and configuration info
+
         *setup.cfg*
         *minversion*
         *to see*markers*pytest --markers*