def defaultcapability(self, irc, msg, args, action, capability):
"""{add|remove} <capability>
Adds or removes (according to the first argument) <capability> from the
default capabilities given to users (the configuration variable
supybot.capabilities stores these).
"""
if action == "add":
conf.supybot.capabilities().add(capability)
irc.replySuccess()
elif action == "remove":
try:
conf.supybot.capabilities().remove(capability)
irc.replySuccess()
except KeyError:
if ircdb.isAntiCapability(capability):
irc.error("That capability wasn't in " "supybot.capabilities.")
else:
anticap = ircdb.makeAntiCapability(capability)
conf.supybot.capabilities().add(anticap)
irc.replySuccess()
def defaultcapability(self, irc, msg, args, action, capability):
"""{add|remove} <capability>
Adds or removes (according to the first argument) <capability> from the
default capabilities given to users (the configuration variable
supybot.capabilities stores these).
"""
if action == 'add':
conf.supybot.capabilities().add(capability)
irc.replySuccess()
elif action == 'remove':
try:
conf.supybot.capabilities().remove(capability)
irc.replySuccess()
except KeyError:
if ircdb.isAntiCapability(capability):
irc.error('That capability wasn\'t in '
'supybot.capabilities.')
else:
anticap = ircdb.makeAntiCapability(capability)
conf.supybot.capabilities().add(anticap)
irc.replySuccess()
def testMakeAntiCapability(self):
self.assertEqual(ircdb.makeAntiCapability('foo'), '-foo')
self.assertEqual(ircdb.makeAntiCapability('#foo,bar'), '#foo,-bar')
class CheckCapabilityTestCase(IrcdbTestCase):
filename = os.path.join(conf.supybot.directories.conf(),
'CheckCapabilityTestCase.conf')
owner = 'owner!owner@owner'
nothing = 'nothing!nothing@nothing'
justfoo = 'justfoo!justfoo@justfoo'
antifoo = 'antifoo!antifoo@antifoo'
justchanfoo = 'justchanfoo!justchanfoo@justchanfoo'
antichanfoo = 'antichanfoo!antichanfoo@antichanfoo'
securefoo = 'securefoo!securefoo@securefoo'
channel = '#channel'
cap = 'foo'
anticap = ircdb.makeAntiCapability(cap)
chancap = ircdb.makeChannelCapability(channel, cap)
antichancap = ircdb.makeAntiCapability(chancap)
chanop = ircdb.makeChannelCapability(channel, 'op')
channelnothing = ircdb.IrcChannel()
channelcap = ircdb.IrcChannel()
channelcap.addCapability(cap)
channelanticap = ircdb.IrcChannel()
channelanticap.addCapability(anticap)
def setUp(self):
IrcdbTestCase.setUp(self)
try:
os.remove(self.filename)
except:
pass
self.users = ircdb.UsersDictionary()
#self.users.open(self.filename)
self.channels = ircdb.ChannelsDictionary()
#self.channels.open(self.filename)
owner = self.users.newUser()
owner.name = 'owner'
owner.addCapability('owner')
owner.addHostmask(self.owner)
self.users.setUser(owner)
nothing = self.users.newUser()
nothing.name = 'nothing'
nothing.addHostmask(self.nothing)
self.users.setUser(nothing)
justfoo = self.users.newUser()
justfoo.name = 'justfoo'
justfoo.addCapability(self.cap)
justfoo.addHostmask(self.justfoo)
self.users.setUser(justfoo)
antifoo = self.users.newUser()
antifoo.name = 'antifoo'
antifoo.addCapability(self.anticap)
antifoo.addHostmask(self.antifoo)
self.users.setUser(antifoo)
justchanfoo = self.users.newUser()
justchanfoo.name = 'justchanfoo'
justchanfoo.addCapability(self.chancap)
justchanfoo.addHostmask(self.justchanfoo)
self.users.setUser(justchanfoo)
antichanfoo = self.users.newUser()
antichanfoo.name = 'antichanfoo'
antichanfoo.addCapability(self.antichancap)
antichanfoo.addHostmask(self.antichanfoo)
self.users.setUser(antichanfoo)
securefoo = self.users.newUser()
securefoo.name = 'securefoo'
securefoo.addCapability(self.cap)
securefoo.secure = True
securefoo.addHostmask(self.securefoo)
self.users.setUser(securefoo)
channel = ircdb.IrcChannel()
self.channels.setChannel(self.channel, channel)
def checkCapability(self, hostmask, capability):
return ircdb.checkCapability(hostmask, capability, self.users,
self.channels)
def testOwner(self):
self.assertTrue(self.checkCapability(self.owner, self.cap))
self.assertFalse(self.checkCapability(self.owner, self.anticap))
self.assertTrue(self.checkCapability(self.owner, self.chancap))
self.assertFalse(self.checkCapability(self.owner, self.antichancap))
self.channels.setChannel(self.channel, self.channelanticap)
self.assertTrue(self.checkCapability(self.owner, self.cap))
self.assertFalse(self.checkCapability(self.owner, self.anticap))
def testNothingAgainstChannel(self):
self.channels.setChannel(self.channel, self.channelnothing)
self.assertEqual(self.checkCapability(self.nothing, self.chancap),
self.channelnothing.defaultAllow)
self.channelnothing.defaultAllow = not self.channelnothing.defaultAllow
self.channels.setChannel(self.channel, self.channelnothing)
self.assertEqual(self.checkCapability(self.nothing, self.chancap),
self.channelnothing.defaultAllow)
self.channels.setChannel(self.channel, self.channelcap)
self.assertTrue(self.checkCapability(self.nothing, self.chancap))
self.assertFalse(self.checkCapability(self.nothing, self.antichancap))
self.channels.setChannel(self.channel, self.channelanticap)
self.assertFalse(self.checkCapability(self.nothing, self.chancap))
self.assertTrue(self.checkCapability(self.nothing, self.antichancap))
def testNothing(self):
self.assertEqual(self.checkCapability(self.nothing, self.cap),
conf.supybot.capabilities.default())
self.assertEqual(self.checkCapability(self.nothing, self.anticap),
not conf.supybot.capabilities.default())
def testJustFoo(self):
self.assertTrue(self.checkCapability(self.justfoo, self.cap))
self.assertFalse(self.checkCapability(self.justfoo, self.anticap))
def testAntiFoo(self):
self.assertTrue(self.checkCapability(self.antifoo, self.anticap))
self.assertFalse(self.checkCapability(self.antifoo, self.cap))
def testJustChanFoo(self):
self.channels.setChannel(self.channel, self.channelnothing)
self.assertTrue(self.checkCapability(self.justchanfoo, self.chancap))
self.assertFalse(
self.checkCapability(self.justchanfoo, self.antichancap))
self.channelnothing.defaultAllow = not self.channelnothing.defaultAllow
self.assertTrue(self.checkCapability(self.justchanfoo, self.chancap))
self.assertFalse(
self.checkCapability(self.justchanfoo, self.antichancap))
self.channels.setChannel(self.channel, self.channelanticap)
self.assertTrue(self.checkCapability(self.justchanfoo, self.chancap))
self.assertFalse(
self.checkCapability(self.justchanfoo, self.antichancap))
def testChanOpCountsAsEverything(self):
self.channels.setChannel(self.channel, self.channelanticap)
id = self.users.getUserId('nothing')
u = self.users.getUser(id)
u.addCapability(self.chanop)
self.users.setUser(u)
self.assertTrue(self.checkCapability(self.nothing, self.chancap))
self.channels.setChannel(self.channel, self.channelnothing)
self.assertTrue(self.checkCapability(self.nothing, self.chancap))
self.channelnothing.defaultAllow = not self.channelnothing.defaultAllow
self.assertTrue(self.checkCapability(self.nothing, self.chancap))
def testAntiChanFoo(self):
self.channels.setChannel(self.channel, self.channelnothing)
self.assertFalse(self.checkCapability(self.antichanfoo, self.chancap))
self.assertTrue(
self.checkCapability(self.antichanfoo, self.antichancap))
def testSecurefoo(self):
self.assertTrue(self.checkCapability(self.securefoo, self.cap))
id = self.users.getUserId(self.securefoo)
u = self.users.getUser(id)
u.addAuth(self.securefoo)
self.users.setUser(u)
try:
originalConfDefaultAllow = conf.supybot.capabilities.default()
conf.supybot.capabilities.default.set('False')
self.assertFalse(
self.checkCapability('a' + self.securefoo, self.cap))
finally:
conf.supybot.capabilities.default.set(
str(originalConfDefaultAllow))
def testMakeAntiCapability(self):
self.assertEqual(ircdb.makeAntiCapability('foo'), '-foo')
self.assertEqual(ircdb.makeAntiCapability('#foo,bar'), '#foo,-bar')
