def test_typeshed_default(self):
input_options = types.SimpleNamespace(typeshed=None,
precompiled_builtins=None)
config.Postprocessor({"typeshed", "precompiled_builtins"},
input_options, self.output_options).process()
# We only care that `None` was replaced.
self.assertIsNotNone(self.output_options.typeshed)
def test_io_pair_output(self):
input_options = types.SimpleNamespace(input=["in.py:out.pyi"])
config.Postprocessor({"output"}, input_options,
self.output_options).process()
with self.assertRaises(AttributeError):
_ = self.output_options.input
self.assertEqual(self.output_options.output, "out.pyi")
def test_disable_and_enable_only(self):
input_options = types.SimpleNamespace(
disable="import-error,attribute-error",
enable_only="bad-slots,bad-unpacking")
with self.assertRaises(config.PostprocessingError) as _:
config.Postprocessor({"disable", "enable_only"}, input_options,
self.output_options).process()
def test_dependency(self):
input_options = datatypes.SimpleNamespace(output="test.pyi",
check=None)
config.Postprocessor({"output", "check"}, input_options,
self.output_options).process()
self.assertEqual(self.output_options.output, "test.pyi")
self.assertIs(self.output_options.check, False)
def test_enable_only(self):
input_options = types.SimpleNamespace(
disable=None, enable_only="import-error,attribute-error")
config.Postprocessor({"disable", "enable_only"}, input_options,
self.output_options).process()
self.assertIn("python-compiler-error", self.output_options.disable)
self.assertNotIn("import-error", self.output_options.disable)
self.assertNotIn("attribute-error", self.output_options.disable)
def test_inplace(self):
input_options = datatypes.SimpleNamespace(
disable="import-error,attribute-error", python_version="3.4")
config.Postprocessor(
{"disable", "python_version"}, input_options).process()
self.assertSequenceEqual(
input_options.disable, ["import-error", "attribute-error"])
self.assertTupleEqual(input_options.python_version, (3, 4))
def test_subset(self):
input_options = datatypes.SimpleNamespace(
pythonpath=".", python_version="3.4")
config.Postprocessor(
{"python_version"}, input_options, self.output_options).process()
with self.assertRaises(AttributeError):
_ = self.output_options.pythonpath # not processed
self.assertTupleEqual(self.output_options.python_version, (3, 4))
def test_subset(self):
python_version = sys.version_info[:2]
input_options = types.SimpleNamespace(
pythonpath=".", python_version=utils.format_version(python_version))
config.Postprocessor(
{"python_version"}, input_options, self.output_options).process()
with self.assertRaises(AttributeError):
_ = self.output_options.pythonpath # not processed
self.assertTupleEqual(self.output_options.python_version, python_version)
def test_io_pair_input(self):
# The duplicate output is ignored, since we're only processing the input.
input_options = types.SimpleNamespace(input=["in.py:out.pyi"],
output="out2.pyi")
config.Postprocessor({"input"}, input_options,
self.output_options).process()
self.assertEqual(self.output_options.input, "in.py")
with self.assertRaises(AttributeError):
_ = self.output_options.output
def test_inplace(self):
python_version = sys.version_info[:2]
input_options = types.SimpleNamespace(
disable="import-error,attribute-error",
python_version=utils.format_version(python_version))
config.Postprocessor({"disable", "python_version"},
input_options).process()
self.assertSequenceEqual(input_options.disable,
["import-error", "attribute-error"])
self.assertTupleEqual(input_options.python_version, python_version)
def postprocess(self, args, from_strings=False):
"""Postprocesses the subset of pytype_single_names that appear in args.
Args:
args: an argparse.Namespace.
from_strings: Whether the args are all strings. If so, we'll do our best
to convert them to the right types.
"""
names = set()
for k in self.pytype_single_names:
if hasattr(args, k):
names.add(k)
if from_strings:
setattr(args, k, convert_string(getattr(args, k)))
pytype_config.Postprocessor(names, args).process()
def test_io_pair_multiple_output(self):
input_options = types.SimpleNamespace(input=["in.py:out.pyi"],
output="out2.pyi")
with self.assertRaises(config.PostprocessingError):
config.Postprocessor({"output"}, input_options,
self.output_options).process()
def test_python_version_default(self):
input_options = types.SimpleNamespace(python_version=None)
config.Postprocessor({"python_version"}, input_options,
self.output_options).process()
self.assertEqual(self.output_options.python_version,
(sys.version_info.major, sys.version_info.minor))
def test_input(self):
input_options = types.SimpleNamespace(input=["test.py"])
config.Postprocessor({"input"}, input_options,
self.output_options).process()
self.assertEqual(self.output_options.input, "test.py")
def test_io_pair(self):
input_options = types.SimpleNamespace(input=["in.py:out.pyi"])
config.Postprocessor({"input", "output"}, input_options,
self.output_options).process()
self.assertEqual(self.output_options.input, "in.py")
self.assertEqual(self.output_options.output, "out.pyi")
def test_typeshed(self):
input_options = types.SimpleNamespace(typeshed=False,
precompiled_builtins=None)
config.Postprocessor({"typeshed", "precompiled_builtins"},
input_options, self.output_options).process()
self.assertIs(self.output_options.typeshed, False)
def test_error(self):
input_options = types.SimpleNamespace(check=True, output="test.pyi")
with self.assertRaises(config.PostprocessingError):
config.Postprocessor({"check", "output"}, input_options,
self.output_options).process()
