Spaces:
Sleeping
Sleeping
"""Tests for distutils.command.register.""" | |
import os | |
import unittest | |
import getpass | |
import urllib | |
import warnings | |
from test.support import run_unittest | |
from test.support.warnings_helper import check_warnings | |
from distutils.command import register as register_module | |
from distutils.command.register import register | |
from distutils.errors import DistutilsSetupError | |
from distutils.log import INFO | |
from distutils.tests.test_config import BasePyPIRCCommandTestCase | |
try: | |
import docutils | |
except ImportError: | |
docutils = None | |
PYPIRC_NOPASSWORD = """\ | |
[distutils] | |
index-servers = | |
server1 | |
[server1] | |
username:me | |
""" | |
WANTED_PYPIRC = """\ | |
[distutils] | |
index-servers = | |
pypi | |
[pypi] | |
username:tarek | |
password:password | |
""" | |
class Inputs(object): | |
"""Fakes user inputs.""" | |
def __init__(self, *answers): | |
self.answers = answers | |
self.index = 0 | |
def __call__(self, prompt=''): | |
try: | |
return self.answers[self.index] | |
finally: | |
self.index += 1 | |
class FakeOpener(object): | |
"""Fakes a PyPI server""" | |
def __init__(self): | |
self.reqs = [] | |
def __call__(self, *args): | |
return self | |
def open(self, req, data=None, timeout=None): | |
self.reqs.append(req) | |
return self | |
def read(self): | |
return b'xxx' | |
def getheader(self, name, default=None): | |
return { | |
'content-type': 'text/plain; charset=utf-8', | |
}.get(name.lower(), default) | |
class RegisterTestCase(BasePyPIRCCommandTestCase): | |
def setUp(self): | |
super(RegisterTestCase, self).setUp() | |
# patching the password prompt | |
self._old_getpass = getpass.getpass | |
def _getpass(prompt): | |
return 'password' | |
getpass.getpass = _getpass | |
urllib.request._opener = None | |
self.old_opener = urllib.request.build_opener | |
self.conn = urllib.request.build_opener = FakeOpener() | |
def tearDown(self): | |
getpass.getpass = self._old_getpass | |
urllib.request._opener = None | |
urllib.request.build_opener = self.old_opener | |
super(RegisterTestCase, self).tearDown() | |
def _get_cmd(self, metadata=None): | |
if metadata is None: | |
metadata = {'url': 'xxx', 'author': 'xxx', | |
'author_email': 'xxx', | |
'name': 'xxx', 'version': 'xxx'} | |
pkg_info, dist = self.create_dist(**metadata) | |
return register(dist) | |
def test_create_pypirc(self): | |
# this test makes sure a .pypirc file | |
# is created when requested. | |
# let's create a register instance | |
cmd = self._get_cmd() | |
# we shouldn't have a .pypirc file yet | |
self.assertFalse(os.path.exists(self.rc)) | |
# patching input and getpass.getpass | |
# so register gets happy | |
# | |
# Here's what we are faking : | |
# use your existing login (choice 1.) | |
# Username : 'tarek' | |
# Password : 'password' | |
# Save your login (y/N)? : 'y' | |
inputs = Inputs('1', 'tarek', 'y') | |
register_module.input = inputs.__call__ | |
# let's run the command | |
try: | |
cmd.run() | |
finally: | |
del register_module.input | |
# we should have a brand new .pypirc file | |
self.assertTrue(os.path.exists(self.rc)) | |
# with the content similar to WANTED_PYPIRC | |
f = open(self.rc) | |
try: | |
content = f.read() | |
self.assertEqual(content, WANTED_PYPIRC) | |
finally: | |
f.close() | |
# now let's make sure the .pypirc file generated | |
# really works : we shouldn't be asked anything | |
# if we run the command again | |
def _no_way(prompt=''): | |
raise AssertionError(prompt) | |
register_module.input = _no_way | |
cmd.show_response = 1 | |
cmd.run() | |
# let's see what the server received : we should | |
# have 2 similar requests | |
self.assertEqual(len(self.conn.reqs), 2) | |
req1 = dict(self.conn.reqs[0].headers) | |
req2 = dict(self.conn.reqs[1].headers) | |
self.assertEqual(req1['Content-length'], '1374') | |
self.assertEqual(req2['Content-length'], '1374') | |
self.assertIn(b'xxx', self.conn.reqs[1].data) | |
def test_password_not_in_file(self): | |
self.write_file(self.rc, PYPIRC_NOPASSWORD) | |
cmd = self._get_cmd() | |
cmd._set_config() | |
cmd.finalize_options() | |
cmd.send_metadata() | |
# dist.password should be set | |
# therefore used afterwards by other commands | |
self.assertEqual(cmd.distribution.password, 'password') | |
def test_registering(self): | |
# this test runs choice 2 | |
cmd = self._get_cmd() | |
inputs = Inputs('2', 'tarek', 'tarek@ziade.org') | |
register_module.input = inputs.__call__ | |
try: | |
# let's run the command | |
cmd.run() | |
finally: | |
del register_module.input | |
# we should have send a request | |
self.assertEqual(len(self.conn.reqs), 1) | |
req = self.conn.reqs[0] | |
headers = dict(req.headers) | |
self.assertEqual(headers['Content-length'], '608') | |
self.assertIn(b'tarek', req.data) | |
def test_password_reset(self): | |
# this test runs choice 3 | |
cmd = self._get_cmd() | |
inputs = Inputs('3', 'tarek@ziade.org') | |
register_module.input = inputs.__call__ | |
try: | |
# let's run the command | |
cmd.run() | |
finally: | |
del register_module.input | |
# we should have send a request | |
self.assertEqual(len(self.conn.reqs), 1) | |
req = self.conn.reqs[0] | |
headers = dict(req.headers) | |
self.assertEqual(headers['Content-length'], '290') | |
self.assertIn(b'tarek', req.data) | |
def test_strict(self): | |
# testing the script option | |
# when on, the register command stops if | |
# the metadata is incomplete or if | |
# long_description is not reSt compliant | |
# empty metadata | |
cmd = self._get_cmd({}) | |
cmd.ensure_finalized() | |
cmd.strict = 1 | |
self.assertRaises(DistutilsSetupError, cmd.run) | |
# metadata are OK but long_description is broken | |
metadata = {'url': 'xxx', 'author': 'xxx', | |
'author_email': 'éxéxé', | |
'name': 'xxx', 'version': 'xxx', | |
'long_description': 'title\n==\n\ntext'} | |
cmd = self._get_cmd(metadata) | |
cmd.ensure_finalized() | |
cmd.strict = 1 | |
self.assertRaises(DistutilsSetupError, cmd.run) | |
# now something that works | |
metadata['long_description'] = 'title\n=====\n\ntext' | |
cmd = self._get_cmd(metadata) | |
cmd.ensure_finalized() | |
cmd.strict = 1 | |
inputs = Inputs('1', 'tarek', 'y') | |
register_module.input = inputs.__call__ | |
# let's run the command | |
try: | |
cmd.run() | |
finally: | |
del register_module.input | |
# strict is not by default | |
cmd = self._get_cmd() | |
cmd.ensure_finalized() | |
inputs = Inputs('1', 'tarek', 'y') | |
register_module.input = inputs.__call__ | |
# let's run the command | |
try: | |
cmd.run() | |
finally: | |
del register_module.input | |
# and finally a Unicode test (bug #12114) | |
metadata = {'url': 'xxx', 'author': '\u00c9ric', | |
'author_email': 'xxx', 'name': 'xxx', | |
'version': 'xxx', | |
'description': 'Something about esszet \u00df', | |
'long_description': 'More things about esszet \u00df'} | |
cmd = self._get_cmd(metadata) | |
cmd.ensure_finalized() | |
cmd.strict = 1 | |
inputs = Inputs('1', 'tarek', 'y') | |
register_module.input = inputs.__call__ | |
# let's run the command | |
try: | |
cmd.run() | |
finally: | |
del register_module.input | |
def test_register_invalid_long_description(self): | |
description = ':funkie:`str`' # mimic Sphinx-specific markup | |
metadata = {'url': 'xxx', 'author': 'xxx', | |
'author_email': 'xxx', | |
'name': 'xxx', 'version': 'xxx', | |
'long_description': description} | |
cmd = self._get_cmd(metadata) | |
cmd.ensure_finalized() | |
cmd.strict = True | |
inputs = Inputs('2', 'tarek', 'tarek@ziade.org') | |
register_module.input = inputs | |
self.addCleanup(delattr, register_module, 'input') | |
self.assertRaises(DistutilsSetupError, cmd.run) | |
def test_check_metadata_deprecated(self): | |
# makes sure make_metadata is deprecated | |
cmd = self._get_cmd() | |
with check_warnings() as w: | |
warnings.simplefilter("always") | |
cmd.check_metadata() | |
self.assertEqual(len(w.warnings), 1) | |
def test_list_classifiers(self): | |
cmd = self._get_cmd() | |
cmd.list_classifiers = 1 | |
cmd.run() | |
results = self.get_logs(INFO) | |
self.assertEqual(results, ['running check', 'xxx']) | |
def test_show_response(self): | |
# test that the --show-response option return a well formatted response | |
cmd = self._get_cmd() | |
inputs = Inputs('1', 'tarek', 'y') | |
register_module.input = inputs.__call__ | |
cmd.show_response = 1 | |
try: | |
cmd.run() | |
finally: | |
del register_module.input | |
results = self.get_logs(INFO) | |
self.assertEqual(results[3], 75 * '-' + '\nxxx\n' + 75 * '-') | |
def test_suite(): | |
return unittest.TestLoader().loadTestsFromTestCase(RegisterTestCase) | |
if __name__ == "__main__": | |
run_unittest(test_suite()) | |