def test_expanduser_pwd(self): pwd = support.import_module('pwd') self.assertIsInstance(posixpath.expanduser("~/"), str) # if home directory == root directory, this test makes no sense if posixpath.expanduser("~") != '/': self.assertEqual( posixpath.expanduser("~") + "/", posixpath.expanduser("~/")) self.assertIsInstance(posixpath.expanduser("~root/"), str) self.assertIsInstance(posixpath.expanduser("~foo/"), str) with support.EnvironmentVarGuard() as env: # expanduser should fall back to using the password database del env['HOME'] home = pwd.getpwuid(os.getuid()).pw_dir # $HOME can end with a trailing /, so strip it (see #17809) home = home.rstrip("/") or '/' self.assertEqual(posixpath.expanduser("~"), home) # bpo-10496: If the HOME environment variable is not set and the # user (current identifier or name in the path) doesn't exist in # the password database (pwd.getuid() or pwd.getpwnam() fail), # expanduser() must return the path unchanged. def raise_keyerror(*args): raise KeyError with support.swap_attr(pwd, 'getpwuid', raise_keyerror), \ support.swap_attr(pwd, 'getpwnam', raise_keyerror): for path in ('~', '~/.local', '~vstinner/'): self.assertEqual(posixpath.expanduser(path), path)
def testLoadWithUNC(self): # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': self.skipTest('unusable path: %r' % fullname) unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) with test_support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") cmd = '%s -c "import Tkinter; print Tkinter"' % (unc_name, ) try: p = Popen(cmd, stdout=PIPE, stderr=PIPE) except WindowsError as e: if e.winerror == 5 or e.winerror == 2: self.skipTest('Not permitted to start the child process') else: raise out_data, err_data = p.communicate() msg = '\n\n'.join([ '"Tkinter.py" not in output', 'Command:', cmd, 'stdout:', out_data, 'stderr:', err_data ]) self.assertIn('Tkinter.py', out_data, msg) self.assertEqual(p.wait(), 0, 'Non-zero exit code')
def setUp(self): # Records changes to env vars self.env = test_support.EnvironmentVarGuard() # Delete all proxy related env vars for k in os.environ.keys(): if 'proxy' in k.lower(): self.env.unset(k)
def testLoadWithUNC(self): import sys if sys.platform != 'win32': return # Build a UNC path from the regular path. # Something like # \\%COMPUTERNAME%\c$\python27\python.exe fullname = os.path.abspath(sys.executable) if fullname[1] != ':': return unc_name = r'\\%s\%s$\%s' % (os.environ['COMPUTERNAME'], fullname[0], fullname[3:]) with test_support.EnvironmentVarGuard() as env: env.unset("TCL_LIBRARY") cmd = '%s -c "import Tkinter; print Tkinter"' % (unc_name, ) p = Popen(cmd, stdout=PIPE, stderr=PIPE) out_data, err_data = p.communicate() msg = '\n\n'.join([ '"Tkinter.py" not in output', 'Command:', cmd, 'stdout:', out_data, 'stderr:', err_data ]) self.assertIn('Tkinter.py', out_data, msg) self.assertEqual(p.wait(), 0, 'Non-zero exit code')
def test_expanduser(self): tester('ntpath.expanduser("test")', 'test') with test_support.EnvironmentVarGuard() as env: env.clear() tester('ntpath.expanduser("~test")', '~test') env['HOMEPATH'] = 'eric\\idle' env['HOMEDRIVE'] = 'C:\\' tester('ntpath.expanduser("~test")', 'C:\\eric\\test') tester('ntpath.expanduser("~")', 'C:\\eric\\idle') del env['HOMEDRIVE'] tester('ntpath.expanduser("~test")', 'eric\\test') tester('ntpath.expanduser("~")', 'eric\\idle') env.clear() env['USERPROFILE'] = 'C:\\eric\\idle' tester('ntpath.expanduser("~test")', 'C:\\eric\\test') tester('ntpath.expanduser("~")', 'C:\\eric\\idle') env.clear() env['HOME'] = 'C:\\idle\\eric' tester('ntpath.expanduser("~test")', 'C:\\idle\\test') tester('ntpath.expanduser("~")', 'C:\\idle\\eric') tester('ntpath.expanduser("~test\\foo\\bar")', 'C:\\idle\\test\\foo\\bar') tester('ntpath.expanduser("~test/foo/bar")', 'C:\\idle\\test/foo/bar') tester('ntpath.expanduser("~\\foo\\bar")', 'C:\\idle\\eric\\foo\\bar') tester('ntpath.expanduser("~/foo/bar")', 'C:\\idle\\eric/foo/bar')
def test_expandvars_nonascii(self): if self.pathmodule.__name__ == 'macpath': self.skipTest('macpath.expandvars is a stub') expandvars = self.pathmodule.expandvars def check(value, expected): self.assertEqual(expandvars(value), expected) encoding = sys.getfilesystemencoding() with test_support.EnvironmentVarGuard() as env: env.clear() unonascii = test_support.FS_NONASCII snonascii = unonascii.encode(encoding) env['spam'] = snonascii env[snonascii] = 'ham' + snonascii check(snonascii, snonascii) check('$spam bar', '%s bar' % snonascii) check('${spam}bar', '%sbar' % snonascii) check('${%s}bar' % snonascii, 'ham%sbar' % snonascii) check('$bar%s bar' % snonascii, '$bar%s bar' % snonascii) check('$spam}bar', '%s}bar' % snonascii) check(unonascii, unonascii) check(u'$spam bar', u'%s bar' % unonascii) check(u'${spam}bar', u'%sbar' % unonascii) check(u'${%s}bar' % unonascii, u'ham%sbar' % unonascii) check(u'$bar%s bar' % unonascii, u'$bar%s bar' % unonascii) check(u'$spam}bar', u'%s}bar' % unonascii)
def test_expandvars(self): with test_support.EnvironmentVarGuard() as env: env.clear() env["foo"] = "bar" env["{foo"] = "baz1" env["{foo}"] = "baz2" tester('ntpath.expandvars("foo")', "foo") tester('ntpath.expandvars("$foo bar")', "bar bar") tester('ntpath.expandvars("${foo}bar")', "barbar") tester('ntpath.expandvars("$[foo]bar")', "$[foo]bar") tester('ntpath.expandvars("$bar bar")', "$bar bar") tester('ntpath.expandvars("$?bar")', "$?bar") tester('ntpath.expandvars("$foo}bar")', "bar}bar") tester('ntpath.expandvars("${foo")', "${foo") tester('ntpath.expandvars("${{foo}}")', "baz1}") tester('ntpath.expandvars("$foo$foo")', "barbar") tester('ntpath.expandvars("$bar$bar")', "$bar$bar") tester('ntpath.expandvars("%foo% bar")', "bar bar") tester('ntpath.expandvars("%foo%bar")', "barbar") tester('ntpath.expandvars("%foo%%foo%")', "barbar") tester('ntpath.expandvars("%%foo%%foo%foo%")', "%foo%foobar") tester('ntpath.expandvars("%?bar%")', "%?bar%") tester('ntpath.expandvars("%foo%%bar")', "bar%bar") tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar") tester('ntpath.expandvars("bar\'%foo%")', "bar\'%foo%")
def setUp(self): self._threads = test_support.threading_setup() os.environ = test_support.EnvironmentVarGuard() self.server_started = threading.Event() self.thread = TestServerThread(self, self.request_handler) self.thread.start() self.server_started.wait()
def test_drop_privileges(self, *args): with test_support.EnvironmentVarGuard() as env: env['SUDO_UID'] = '1000' env['SUDO_GID'] = '1000' misc.drop_privileges() os.seteuid.assert_called_once_with(1000) os.setegid.assert_called_once_with(1000) os.setgroups.assert_called_once_with([1234])
def test_find_on_path_root_resolves_relative_paths(self): outer_bin = os.path.join(self.temp_dir, "bin") chroot = os.path.join(self.temp_dir, "chroot") inner_bin = os.path.join(chroot, self.temp_dir[1:], "bin") self.create_empty_file(os.path.join(outer_bin, "executable"), 0o755) self.create_empty_file(os.path.join(inner_bin, "executable"), 0o755) with test_support.EnvironmentVarGuard() as env: env['PATH'] = outer_bin self.assertTrue(osextras.find_on_path_root(chroot, "executable"))
def test_expandvars_nonascii_word(self): encoding = sys.getfilesystemencoding() uwnonascii = test_support.FS_NONASCII swnonascii = uwnonascii.encode(encoding) if not swnonascii: self.skipTest('Needs non-ASCII word characters') with test_support.EnvironmentVarGuard() as env: env.clear() env[swnonascii] = 'baz' + swnonascii self.assertEqual(posixpath.expandvars(u'$%s bar' % uwnonascii), u'baz%s bar' % uwnonascii)
def test_source(self): # XXX (ncoghlan): It would be nice to use test_support.CleanImport # here, but that breaks because the os module registers some # handlers in copy_reg on import. Since CleanImport doesn't # revert that registration, the module is left in a broken # state after reversion. Reinitialising the module contents # and just reverting os.environ to its previous state is an OK # workaround with test_support.EnvironmentVarGuard(): import os imp.reload(os)
def test_expandvars_nonascii_word(self): encoding = sys.getfilesystemencoding() # Non-ASCII word characters letters = test_support.u(r'\xe6\u0130\u0141\u03c6\u041a\u05d0\u062a\u0e01') uwnonascii = letters.encode(encoding, 'ignore').decode(encoding)[:3] swnonascii = uwnonascii.encode(encoding) if not swnonascii: self.skipTest('Needs non-ASCII word characters') with test_support.EnvironmentVarGuard() as env: env.clear() env[swnonascii] = 'baz' + swnonascii self.assertEqual(posixpath.expandvars(u'$%s bar' % uwnonascii), u'baz%s bar' % uwnonascii)
def setUp(self): if not os.path.isdir(LOCALEDIR): os.makedirs(LOCALEDIR) with open(MOFILE, 'wb') as fp: fp.write(base64.decodestring(GNU_MO_DATA)) with open(UMOFILE, 'wb') as fp: fp.write(base64.decodestring(UMO_DATA)) with open(MMOFILE, 'wb') as fp: fp.write(base64.decodestring(MMO_DATA)) self.env = test_support.EnvironmentVarGuard() self.env['LANGUAGE'] = 'xx' gettext._translations.clear()
def setUp(self): if not os.path.isdir(LOCALEDIR): os.makedirs(LOCALEDIR) fp = open(MOFILE, 'wb') fp.write(base64.decodestring(GNU_MO_DATA)) fp.close() fp = open(UMOFILE, 'wb') fp.write(base64.decodestring(UMO_DATA)) fp.close() fp = open(MMOFILE, 'wb') fp.write(base64.decodestring(MMO_DATA)) fp.close() self.env = test_support.EnvironmentVarGuard() self.env['LANGUAGE'] = 'xx'
def test_expanduser_home_envvar(self): with support.EnvironmentVarGuard() as env: env['HOME'] = '/home/victor' self.assertEqual(posixpath.expanduser("~"), "/home/victor") # expanduser() strips trailing slash env['HOME'] = '/home/victor/' self.assertEqual(posixpath.expanduser("~"), "/home/victor") for home in '/', '', '//', '///': env['HOME'] = home self.assertEqual(posixpath.expanduser("~"), "/") self.assertEqual(posixpath.expanduser("~/"), "/") self.assertEqual(posixpath.expanduser("~/foo"), "/foo")
def test_case_sensitive(self): # gettempdir should not flatten its case # even on a case-insensitive file system # See CPython Issue 14255 (back-ported for Jython) case_sensitive_tempdir = tempfile.mkdtemp("-Temp") _tempdir, tempfile.tempdir = tempfile.tempdir, None try: with support.EnvironmentVarGuard() as env: # Fake the first env var which is checked as a candidate env["TMPDIR"] = case_sensitive_tempdir self.assertEqual(tempfile.gettempdir(), case_sensitive_tempdir) finally: tempfile.tempdir = _tempdir support.rmdir(case_sensitive_tempdir)
def testLoadTkFailure(self): old_display = None if sys.platform.startswith(('win', 'darwin', 'cygwin')): return else: with test_support.EnvironmentVarGuard() as env: if 'DISPLAY' in os.environ: del env['DISPLAY'] display = os.popen('echo $DISPLAY').read().strip() if display: return tcl = Tcl() self.assertRaises(TclError, tcl.winfo_geometry) self.assertRaises(TclError, tcl.loadtk) return
def test_cgi_get(self): with test_support.EnvironmentVarGuard() as env: env['REQUEST_METHOD'] = 'GET' # if the method is GET and no request_text is given, it runs handle_get # get sysout output with test_support.captured_stdout() as data_out: self.cgi.handle_request() # parse Status header data_out.seek(0) handle = data_out.read() status = handle.split()[1] message = ' '.join(handle.split()[2:4]) self.assertEqual(status, '400') self.assertEqual(message, 'Bad Request')
def test_uname_win32_ARCHITEW6432(self): # Issue 7860: make sure we get architecture from the correct variable # on 64 bit Windows: if PROCESSOR_ARCHITEW6432 exists we should be # using it, per # http://blogs.msdn.com/david.wang/archive/2006/03/26/HOWTO-Detect-Process-Bitness.aspx try: with test_support.EnvironmentVarGuard() as environ: if 'PROCESSOR_ARCHITEW6432' in environ: del environ['PROCESSOR_ARCHITEW6432'] environ['PROCESSOR_ARCHITECTURE'] = 'foo' platform._uname_cache = None system, node, release, version, machine, processor = platform.uname() self.assertEqual(machine, 'foo') environ['PROCESSOR_ARCHITEW6432'] = 'bar' platform._uname_cache = None system, node, release, version, machine, processor = platform.uname() self.assertEqual(machine, 'bar') finally: platform._uname_cache = None
def test_pages_fit_on_a_netbook(self): from ubiquity.frontend import gtk_ui with test_support.EnvironmentVarGuard() as env: env['UBIQUITY_MIGRATION_ASSISTANT'] = '1' ui = gtk_ui.Wizard('test-ubiquity') ui.translate_pages() for page in ui.pages: ui.set_page(page.module.NAME) ui.refresh() ui.refresh() if 'UBIQUITY_TEST_SHOW_ALL_PAGES' in os.environ: print(page.module.NAME) import time time.sleep(3) alloc = ui.live_installer.get_allocation() self.assertLessEqual(alloc.width, 640) self.assertLessEqual(alloc.height, 500) if page.module.NAME == 'partman': ui.allow_change_step(False)
def test_security(self): # This test is incomplete since we are normally not run as root and # therefore can't test the file ownership being wrong. os.unlink(temp_filename) d = test_support.TESTFN try: os.mkdir(d) fn = os.path.join(d, '.netrc') with open(fn, 'wt') as f: f.write(TEST_NETRC) with test_support.EnvironmentVarGuard() as environ: environ.set('HOME', d) os.chmod(fn, 0600) self.netrc = netrc.netrc() self.test_case_1() os.chmod(fn, 0622) self.assertRaises(netrc.NetrcParseError, netrc.netrc) finally: test_support.rmtree(d)
def test_expanduser(self): self.assertEqual(posixpath.expanduser("foo"), "foo") try: import pwd except ImportError: pass else: self.assertIsInstance(posixpath.expanduser("~/"), basestring) # if home directory == root directory, this test makes no sense if posixpath.expanduser("~") != '/': self.assertEqual( posixpath.expanduser("~") + "/", posixpath.expanduser("~/")) self.assertIsInstance(posixpath.expanduser("~root/"), basestring) self.assertIsInstance(posixpath.expanduser("~foo/"), basestring) with test_support.EnvironmentVarGuard() as env: env['HOME'] = '/' self.assertEqual(posixpath.expanduser("~"), "/")
def test_cgi_get(self): with test_support.EnvironmentVarGuard() as env: env.set('REQUEST_METHOD', 'GET') # if the method is GET and no request_text is given, it runs handle_get # get sysout output tmp = sys.stdout sys.stdout = open(test_support.TESTFN, "w") self.cgi.handle_request() sys.stdout.close() sys.stdout = tmp # parse Status header handle = open(test_support.TESTFN, "r").read() status = handle.split()[1] message = ' '.join(handle.split()[2:4]) self.assertEqual(status, '400') self.assertEqual(message, 'Bad Request') os.remove(test_support.TESTFN)
def test_expandvars(self): if self.pathmodule.__name__ == 'macpath': self.skipTest('macpath.expandvars is a stub') expandvars = self.pathmodule.expandvars with test_support.EnvironmentVarGuard() as env: env.clear() env["foo"] = "bar" env["{foo"] = "baz1" env["{foo}"] = "baz2" self.assertEqual(expandvars("foo"), "foo") self.assertEqual(expandvars("$foo bar"), "bar bar") self.assertEqual(expandvars("${foo}bar"), "barbar") self.assertEqual(expandvars("$[foo]bar"), "$[foo]bar") self.assertEqual(expandvars("$bar bar"), "$bar bar") self.assertEqual(expandvars("$?bar"), "$?bar") self.assertEqual(expandvars("$foo}bar"), "bar}bar") self.assertEqual(expandvars("${foo"), "${foo") self.assertEqual(expandvars("${{foo}}"), "baz1}") self.assertEqual(expandvars("$foo$foo"), "barbar") self.assertEqual(expandvars("$bar$bar"), "$bar$bar")
def test_security(self): # This test is incomplete since we are normally not run as root and # therefore can't test the file ownership being wrong. d = test_support.TESTFN os.mkdir(d) self.addCleanup(test_support.rmtree, d) fn = os.path.join(d, '.netrc') with open(fn, 'wt') as f: f.write("""\ machine foo.domain.com login bar password pass default login foo password pass """) with test_support.EnvironmentVarGuard() as environ: environ.set('HOME', d) os.chmod(fn, 0600) nrc = netrc.netrc() self.assertEqual(nrc.hosts['foo.domain.com'], ('bar', None, 'pass')) os.chmod(fn, 0o622) self.assertRaises(netrc.NetrcParseError, netrc.netrc)
def test_cgi_xmlrpc_response(self): data = """<?xml version='1.0'?> <methodCall> <methodName>test_method</methodName> <params> <param> <value><string>foo</string></value> </param> <param> <value><string>bar</string></value> </param> </params> </methodCall> """ with test_support.EnvironmentVarGuard() as env, \ test_support.captured_stdout() as data_out, \ test_support.captured_stdin() as data_in: data_in.write(data) data_in.seek(0) env['CONTENT_LENGTH'] = str(len(data)) self.cgi.handle_request() data_out.seek(0) # will respond exception, if so, our goal is achieved ;) handle = data_out.read() # start with 44th char so as not to get http header, we just need only xml self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, handle[44:]) # Also test the content-length returned by handle_request # Using the same test method inorder to avoid all the datapassing # boilerplate code. # Test for bug: http://bugs.python.org/issue5040 content = handle[handle.find("<?xml"):] self.assertEqual( int(re.search('Content-Length: (\d+)', handle).group(1)), len(content))
def test_expandvars_nonascii(self): encoding = sys.getfilesystemencoding() def check(value, expected): tester0("ntpath.expandvars(%r)" % value, expected) tester0("ntpath.expandvars(%r)" % value.decode(encoding), expected.decode(encoding)) with test_support.EnvironmentVarGuard() as env: env.clear() unonascii = test_support.FS_NONASCII snonascii = unonascii.encode(encoding) env['spam'] = snonascii env[snonascii] = 'ham' + snonascii check('$spam bar', '%s bar' % snonascii) check('$%s bar' % snonascii, '$%s bar' % snonascii) check('${spam}bar', '%sbar' % snonascii) check('${%s}bar' % snonascii, 'ham%sbar' % snonascii) check('$spam}bar', '%s}bar' % snonascii) check('$%s}bar' % snonascii, '$%s}bar' % snonascii) check('%spam% bar', '%s bar' % snonascii) check('%{}% bar'.format(snonascii), 'ham%s bar' % snonascii) check('%spam%bar', '%sbar' % snonascii) check('%{}%bar'.format(snonascii), 'ham%sbar' % snonascii)
def testLoadTkFailure(self): old_display = None if sys.platform.startswith(('win', 'darwin', 'cygwin', 'msys')): # no failure possible on windows? # XXX Maybe on tk older than 8.4.13 it would be possible, # see tkinter.h. return with test_support.EnvironmentVarGuard() as env: if 'DISPLAY' in os.environ: del env['DISPLAY'] # on some platforms, deleting environment variables # doesn't actually carry through to the process level # because they don't support unsetenv # If that's the case, abort. display = os.popen('echo $DISPLAY').read().strip() if display: return tcl = Tcl() self.assertRaises(TclError, tcl.winfo_geometry) self.assertRaises(TclError, tcl.loadtk)
def test_cgi_xmlrpc_response(self): data = """<?xml version='1.0'?> <methodCall> <methodName>test_method</methodName> <params> <param> <value><string>foo</string></value> </param> <param> <value><string>bar</string></value> </param> </params> </methodCall> """ open("xmldata.txt", "w").write(data) tmp1 = sys.stdin tmp2 = sys.stdout sys.stdin = open("xmldata.txt", "r") sys.stdout = open(test_support.TESTFN, "w") with test_support.EnvironmentVarGuard() as env: env.set('CONTENT_LENGTH', str(len(data))) self.cgi.handle_request() sys.stdin.close() sys.stdout.close() sys.stdin = tmp1 sys.stdout = tmp2 # will respond exception, if so, our goal is achieved ;) handle = open(test_support.TESTFN, "r").read() # start with 44th char so as not to get http header, we just need only xml self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, handle[44:]) os.remove("xmldata.txt") os.remove(test_support.TESTFN)