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