def testVerify(self): # Can't test if no makedb if not os.path.exists('/usr/bin/makedb'): raise TestSkipped('no /usr/bin/makedb') # create a map m = passwd.PasswdMap() e = passwd.PasswdMapEntry() e.name = 'foo' e.uid = 1000 e.gid = 2000 self.failUnless(m.Add(e)) updater = nssdb.NssDbPasswdHandler({ 'dir': self.workdir, 'makedb': '/usr/bin/makedb' }) written = updater.Write(m) self.failUnless(os.path.exists(updater.temp_cache_filename), 'updater.Write() did not create a file') retval = updater.Verify(written) self.failUnlessEqual(True, retval) os.unlink(updater.temp_cache_filename)
def testNssDbPasswdHandlerWriteData(self): entry_string = 'foo:x:1000:1000:foo:/:/bin/sh' makedb_stdin = self.mox.CreateMock(sys.stdin) makedb_stdin.write('.foo %s\n' % entry_string) makedb_stdin.write('=1000 %s\n' % entry_string) makedb_stdin.write('00 %s\n' % entry_string) passwd_map = passwd.PasswdMap() passwd_map_entry = passwd.PasswdMapEntry() passwd_map_entry.name = 'foo' passwd_map_entry.uid = 1000 passwd_map_entry.gid = 1000 passwd_map_entry.gecos = 'foo' passwd_map_entry.dir = '/' passwd_map_entry.shell = '/bin/sh' passwd_map_entry.passwd = 'x' self.failUnless(passwd_map.Add(passwd_map_entry)) writer = nssdb.NssDbPasswdHandler({ 'makedb': '/bin/false', 'dir': '/tmp' }) self.mox.ReplayAll() writer.WriteData(makedb_stdin, passwd_map_entry, 0)
def testVerifyFailure(self): # create a map m = passwd.PasswdMap() e = passwd.PasswdMapEntry() e.name = 'foo' e.uid = 1000 e.gid = 2000 self.assertTrue(m.Add(e)) updater = nssdb.NssDbPasswdHandler({ 'dir': self.workdir, 'makedb': '/usr/bin/makedb' }) written = updater.Write(m) self.assertTrue(os.path.exists(updater.temp_cache_filename), 'updater.Write() did not create a file') # change the cache db = btopen(updater.temp_cache_filename) del db[db.first()[0]] db.sync() db.close() retval = updater.Verify(written) self.assertEqual(False, retval) self.assertFalse( os.path.exists(os.path.join(updater.temp_cache_filename)))
def testGetMapRaisesCacheNotFound(self): bad_file = os.path.join(self.workdir, 'really_not_going_to_exist_okay') self.failIf(os.path.exists(bad_file), 'what the hell, it exists!') config = {} cache = nssdb.NssDbPasswdHandler(config) cache.CACHE_FILENAME = bad_file self.assertRaises(error.CacheNotFound, cache.GetMap)
def testConvertValueToMapEntry(self): ent = 'foo:x:1000:1001:bar:/:/bin/sh' updater = nssdb.NssDbPasswdHandler({}) pme = updater.ConvertValueToMapEntry(ent) self.assertEqual('foo', pme.name) self.assertEqual(1000, pme.uid) self.assertEqual(1001, pme.gid) self.assertEqual('bar', pme.gecos) self.assertEqual('/bin/sh', pme.shell) self.assertEqual('/', pme.dir)
def testVerifyEmptyMap(self): updater = nssdb.NssDbPasswdHandler({'dir': self.workdir}) # create a temp file, clag it into the updater object (_, temp_filename) = tempfile.mkstemp(prefix='nsscache-nssdb_test', dir=self.workdir) updater.temp_cache_filename = temp_filename # make it empty db = bsddb.btopen(temp_filename, 'w') self.assertEqual(0, len(db)) db.close() # TODO(jaq): raising an exception is probably the wrong behaviour self.assertRaises(error.EmptyMap, updater.Verify, set('foo')) os.unlink(temp_filename)
def testNssDbPasswdHandlerWrite(self): ent = 'foo:x:1000:1000:foo:/:/bin/sh' makedb_stdin = self.mox.CreateMock(sys.stdin) makedb_stdin.write('.foo %s\n' % ent) makedb_stdin.write('=1000 %s\n' % ent) makedb_stdin.write('00 %s\n' % ent) makedb_stdin.close() makedb_stdout = self.mox.CreateMock(sys.stdout) makedb_stdout.read().AndReturn('') makedb_stdout.close() m = passwd.PasswdMap() pw = passwd.PasswdMapEntry() pw.name = 'foo' pw.uid = 1000 pw.gid = 1000 pw.gecos = 'foo' pw.dir = '/' pw.shell = '/bin/sh' pw.passwd = 'x' pw.Verify() self.failUnless(m.Add(pw)) self.mox.StubOutWithMock(select, 'select') select.select([makedb_stdout], (), (), 0).AndReturn(([37], [], [])) select.select([makedb_stdout], (), (), 0).AndReturn(([], [], [])) def SpawnMakeDb(): makedb = MakeDbDummy() makedb.stdin = makedb_stdin makedb.stdout = makedb_stdout return makedb writer = nssdb.NssDbPasswdHandler({ 'makedb': '/usr/bin/makedb', 'dir': self.workdir }) writer._SpawnMakeDb = SpawnMakeDb self.mox.ReplayAll() writer.Write(m) tmppasswd = os.path.join(self.workdir, 'passwd.db') self.failIf(os.path.exists(tmppasswd)) # just clean it up, Write() doesn't Commit() writer._Rollback()
def testGetMapIsIterable(self): timestamp = int(time.time()) update_ts_filename = os.path.join( self.workdir, 'passwd.db.nsscache-update-timestamp') update_ts_file = open(update_ts_filename, 'w') update_ts_file.write( '%s\n' % time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime(timestamp))) update_ts_file.close() db_filename = os.path.join(self.workdir, 'passwd.db') db = bsddb.btopen(db_filename) db.close() cache = nssdb.NssDbPasswdHandler({'dir': self.workdir}) cache_map = cache.GetMap() self.assertEquals([], list(cache_map)) os.unlink(update_ts_filename) os.unlink(db_filename)
def testVerifyFailure(self): # Can't test if no makedb if not os.path.exists('/usr/bin/makedb'): raise TestSkipped('no /usr/bin/makedb') # Hide the warning that we expect to get class TestFilter(logging.Filter): def filter(self, record): return not record.msg.startswith( 'verify failed: %d keys missing') fltr = TestFilter() logging.getLogger('NssDbPasswdHandler').addFilter(fltr) # create a map m = passwd.PasswdMap() e = passwd.PasswdMapEntry() e.name = 'foo' e.uid = 1000 e.gid = 2000 self.failUnless(m.Add(e)) updater = nssdb.NssDbPasswdHandler({ 'dir': self.workdir, 'makedb': '/usr/bin/makedb' }) written = updater.Write(m) self.failUnless(os.path.exists(updater.temp_cache_filename), 'updater.Write() did not create a file') # change the cache db = bsddb.btopen(updater.temp_cache_filename) del db[db.first()[0]] db.sync() db.close() retval = updater.Verify(written) self.failUnlessEqual(False, retval) self.failIf(os.path.exists(os.path.join(updater.temp_cache_filename))) # no longer hide this message logging.getLogger('NssDbPasswdHandler').removeFilter(fltr)
def testWriteTestBdb(self): # Can't test if no makedb if not os.path.exists('/usr/bin/makedb'): raise TestSkipped('no /usr/bin/makedb') data = passwd.PasswdMap() pw = passwd.PasswdMapEntry() pw.name = 'foo' pw.passwd = 'x' pw.uid = 1000 pw.gid = 1000 pw.gecos = 'doody' pw.dir = '/' pw.shell = '/bin/sh' self.failUnless(data.Add(pw)) # instantiate object under test dummy_config = {'dir': self.workdir} cache = nssdb.NssDbPasswdHandler(dummy_config) written = cache.Write(data) self.assertTrue('.foo' in written) self.assertTrue('=1000' in written) # perform test db = bsddb.btopen(cache.temp_cache_filename, 'r') self.assertEqual(3, len(db.keys())) self.failUnless('.foo' in db.keys()) self.failUnless('=1000' in db.keys()) self.failUnless('00' in db.keys()) # convert data to pwent d = '%s:x:%s:%s:%s:%s:%s\x00' % (pw.name, pw.uid, pw.gid, pw.gecos, pw.dir, pw.shell) self.assertEqual(db['00'], d) self.assertEqual(db['.foo'], d) self.assertEqual(db['=1000'], d) # tear down os.unlink(cache.temp_cache_filename)
def testLoadBdbCacheFile(self): pass_file = os.path.join(self.workdir, 'passwd.db') db = bsddb.btopen(pass_file, 'c') ent = 'foo:x:1000:500:bar:/:/bin/sh' db['00'] = ent db['=1000'] = ent db['.foo'] = ent db.sync() self.failUnless(os.path.exists(pass_file)) config = {'dir': self.workdir} cache = nssdb.NssDbPasswdHandler(config) data_map = cache.GetMap() cache._LoadBdbCacheFile(data_map) self.assertEqual(1, len(data_map)) # convert data to pwent x = data_map.PopItem() d = '%s:x:%s:%s:%s:%s:%s' % (x.name, x.uid, x.gid, x.gecos, x.dir, x.shell) self.assertEqual(ent, d) os.unlink(pass_file)
def testVerify(self): # create a map m = passwd.PasswdMap() e = passwd.PasswdMapEntry() e.name = 'foo' e.uid = 1000 e.gid = 2000 self.assertTrue(m.Add(e)) updater = nssdb.NssDbPasswdHandler({ 'dir': self.workdir, 'makedb': '/usr/bin/makedb' }) written = updater.Write(m) self.assertTrue(os.path.exists(updater.temp_cache_filename), 'updater.Write() did not create a file') retval = updater.Verify(written) self.assertEqual(True, retval) os.unlink(updater.temp_cache_filename)
def testWriteTestBdb(self): data = passwd.PasswdMap() pw = passwd.PasswdMapEntry() pw.name = 'foo' pw.passwd = 'x' pw.uid = 1000 pw.gid = 1000 pw.gecos = 'doody' pw.dir = '/' pw.shell = '/bin/sh' self.assertTrue(data.Add(pw)) # instantiate object under test dummy_config = {'dir': self.workdir} cache = nssdb.NssDbPasswdHandler(dummy_config) written = cache.Write(data) self.assertTrue(b'.foo' in written) self.assertTrue(b'=1000' in written) # perform test db = btopen(cache.temp_cache_filename, 'r') self.assertEqual(3, len(list(db.keys()))) self.assertTrue(b'.foo' in list(db.keys())) self.assertTrue(b'=1000' in list(db.keys())) self.assertTrue(b'00' in list(db.keys())) # convert data to pwent d = ('%s:x:%s:%s:%s:%s:%s\x00' % (pw.name, pw.uid, pw.gid, pw.gecos, pw.dir, pw.shell)).encode('ascii') self.assertEqual(db[b'00'], d) self.assertEqual(db[b'.foo'], d) self.assertEqual(db[b'=1000'], d) # tear down os.unlink(cache.temp_cache_filename)
def testIsMapPrimaryKey(self): updater = nssdb.NssDbPasswdHandler({}) self.failUnless(updater.IsMapPrimaryKey('.foo')) self.failIf(updater.IsMapPrimaryKey('=1000')) self.failIf(updater.IsMapPrimaryKey('00'))
def testIsMapPrimaryKey(self): updater = nssdb.NssDbPasswdHandler({}) self.assertTrue(updater.IsMapPrimaryKey('.foo')) self.assertFalse(updater.IsMapPrimaryKey('=1000')) self.assertFalse(updater.IsMapPrimaryKey('00'))