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