1  import sys
       2  import unittest
       3  from test.support import import_helper
       4  
       5  pwd = import_helper.import_module('pwd')
       6  
       7  @unittest.skipUnless(hasattr(pwd, 'getpwall'), 'Does not have getpwall()')
       8  class ESC[4;38;5;81mPwdTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
       9  
      10      def test_values(self):
      11          entries = pwd.getpwall()
      12  
      13          for e in entries:
      14              self.assertEqual(len(e), 7)
      15              self.assertEqual(e[0], e.pw_name)
      16              self.assertIsInstance(e.pw_name, str)
      17              self.assertEqual(e[1], e.pw_passwd)
      18              self.assertIsInstance(e.pw_passwd, str)
      19              self.assertEqual(e[2], e.pw_uid)
      20              self.assertIsInstance(e.pw_uid, int)
      21              self.assertEqual(e[3], e.pw_gid)
      22              self.assertIsInstance(e.pw_gid, int)
      23              self.assertEqual(e[4], e.pw_gecos)
      24              self.assertIn(type(e.pw_gecos), (str, type(None)))
      25              self.assertEqual(e[5], e.pw_dir)
      26              self.assertIsInstance(e.pw_dir, str)
      27              self.assertEqual(e[6], e.pw_shell)
      28              self.assertIsInstance(e.pw_shell, str)
      29  
      30              # The following won't work, because of duplicate entries
      31              # for one uid
      32              #    self.assertEqual(pwd.getpwuid(e.pw_uid), e)
      33              # instead of this collect all entries for one uid
      34              # and check afterwards (done in test_values_extended)
      35  
      36      def test_values_extended(self):
      37          entries = pwd.getpwall()
      38          entriesbyname = {}
      39          entriesbyuid = {}
      40  
      41          if len(entries) > 1000:  # Huge passwd file (NIS?) -- skip this test
      42              self.skipTest('passwd file is huge; extended test skipped')
      43  
      44          for e in entries:
      45              entriesbyname.setdefault(e.pw_name, []).append(e)
      46              entriesbyuid.setdefault(e.pw_uid, []).append(e)
      47  
      48          # check whether the entry returned by getpwuid()
      49          # for each uid is among those from getpwall() for this uid
      50          for e in entries:
      51              if not e[0] or e[0] == '+':
      52                  continue # skip NIS entries etc.
      53              self.assertIn(pwd.getpwnam(e.pw_name), entriesbyname[e.pw_name])
      54              self.assertIn(pwd.getpwuid(e.pw_uid), entriesbyuid[e.pw_uid])
      55  
      56      def test_errors(self):
      57          self.assertRaises(TypeError, pwd.getpwuid)
      58          self.assertRaises(TypeError, pwd.getpwuid, 3.14)
      59          self.assertRaises(TypeError, pwd.getpwnam)
      60          self.assertRaises(TypeError, pwd.getpwnam, 42)
      61          self.assertRaises(TypeError, pwd.getpwall, 42)
      62          # embedded null character
      63          self.assertRaisesRegex(ValueError, 'null', pwd.getpwnam, 'a\x00b')
      64  
      65          # try to get some errors
      66          bynames = {}
      67          byuids = {}
      68          for (n, p, u, g, gecos, d, s) in pwd.getpwall():
      69              bynames[n] = u
      70              byuids[u] = n
      71  
      72          allnames = list(bynames.keys())
      73          namei = 0
      74          fakename = allnames[namei] if allnames else "invaliduser"
      75          while fakename in bynames:
      76              chars = list(fakename)
      77              for i in range(len(chars)):
      78                  if chars[i] == 'z':
      79                      chars[i] = 'A'
      80                      break
      81                  elif chars[i] == 'Z':
      82                      continue
      83                  else:
      84                      chars[i] = chr(ord(chars[i]) + 1)
      85                      break
      86              else:
      87                  namei = namei + 1
      88                  try:
      89                      fakename = allnames[namei]
      90                  except IndexError:
      91                      # should never happen... if so, just forget it
      92                      break
      93              fakename = ''.join(chars)
      94  
      95          self.assertRaises(KeyError, pwd.getpwnam, fakename)
      96  
      97          # In some cases, byuids isn't a complete list of all users in the
      98          # system, so if we try to pick a value not in byuids (via a perturbing
      99          # loop, say), pwd.getpwuid() might still be able to find data for that
     100          # uid. Using sys.maxint may provoke the same problems, but hopefully
     101          # it will be a more repeatable failure.
     102          fakeuid = sys.maxsize
     103          self.assertNotIn(fakeuid, byuids)
     104          self.assertRaises(KeyError, pwd.getpwuid, fakeuid)
     105  
     106          # -1 shouldn't be a valid uid because it has a special meaning in many
     107          # uid-related functions
     108          self.assertRaises(KeyError, pwd.getpwuid, -1)
     109          # should be out of uid_t range
     110          self.assertRaises(KeyError, pwd.getpwuid, 2**128)
     111          self.assertRaises(KeyError, pwd.getpwuid, -2**128)
     112  
     113  if __name__ == "__main__":
     114      unittest.main()