Added more tests.

test/Alias_test.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+
+###
+# Copyright (c) 2002, Jeremiah Fincher
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#   * Neither the name of the author of this software nor the name of
+#     contributors to this software may be used to endorse or promote products
+#     derived from this software without specific prior written consent.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+###
+
+from test import *
+
+import Alias
+
+
+class FunctionsTest(unittest.TestCase):
+    def testFindString(self):
+        L = []
+        self.assertEqual(0, Alias.findString('foo', L))
+        L.append('bar')
+        self.assertEqual(0, Alias.findString('foo', L))
+        L.append('foo')
+        self.assertEqual(1, Alias.findString('foo', L))
+        L.append([])
+        self.assertEqual(1, Alias.findString('foo', L))
+        L.append(['bar'])
+        self.assertEqual(1, Alias.findString('foo', L))
+        L.append(['foo'])
+        self.assertEqual(2, Alias.findString('foo', L))
+        L.append(['bar', 'foo'])
+        self.assertEqual(3, Alias.findString('foo', L))
+        L.append(['foo', 'foo', 'foo'])
+        self.assertEqual(6, Alias.findString('foo', L))
+
+    def testFindDollars(self):
+        L = []
+        self.assertEqual([], Alias.findDollars(L))
+        L.append('foo')
+        self.assertEqual([], Alias.findDollars(L))
+        L.append('$1')
+        self.assertEqual([([1], '$1')], Alias.findDollars(L))
+        L.append('$1 foo bar')
+        self.assertEqual([([1], '$1')], Alias.findDollars(L))
+        L.append('$2')
+        self.assertEqual([([1], '$1'), ([3], '$2')], Alias.findDollars(L))
+        L.append(['foo'])
+        self.assertEqual([([1], '$1'), ([3], '$2')], Alias.findDollars(L))
+        L.append(['foo', 'bar', '$1'])
+        self.assertEqual([([1], '$1'), ([3], '$2'), ([5, 2], '$1')],
+                         Alias.findDollars(L))
+        L.append([[[['$3']]]])

test/ircdb_test.py

@@ -34,22 +34,108 @@ from test import *
 import os
 import unittest
 
+import debug
 import ircdb
 import ircutils
 
+class FunctionsTestCase(unittest.TestCase):
+    def testIsAntiCapability(self):
+        self.failIf(ircdb.isAntiCapability('foo'))
+        self.failIf(ircdb.isAntiCapability('#foo.bar'))
+        self.failUnless(ircdb.isAntiCapability('!foo'))
+        self.failUnless(ircdb.isAntiCapability('#foo.!bar'))
+
+    def testIsChannelCapability(self):
+        self.failIf(ircdb.isChannelCapability('foo'))
+        self.failUnless(ircdb.isChannelCapability('#foo.bar'))
+
+    def testMakeAntiCapability(self):
+        self.assertEqual(ircdb.makeAntiCapability('foo'), '!foo')
+        self.assertEqual(ircdb.makeAntiCapability('#foo.bar'), '#foo.!bar')
+
+    def testMakeChannelCapability(self):
+        self.assertEqual(ircdb.makeChannelCapability('#f', 'b'), '#f.b')
+        self.assertEqual(ircdb.makeChannelCapability('#f', '!b'), '#f.!b')
+
+    def testUnAntiCapability(self):
+        self.assertEqual(ircdb.unAntiCapability('!bar'), 'bar')
+        self.assertEqual(ircdb.unAntiCapability('#foo.!bar'), '#foo.bar')
+
+    def testInvertCapability(self):
+        self.assertEqual(ircdb.invertCapability('bar'), '!bar')
+        self.assertEqual(ircdb.invertCapability('!bar'), 'bar')
+        self.assertEqual(ircdb.invertCapability('#foo.bar'), '#foo.!bar')
+        self.assertEqual(ircdb.invertCapability('#foo.!bar'), '#foo.bar')
+
+
+class CapabilitySetTestCase(unittest.TestCase):
+    def test(self):
+        d = ircdb.CapabilitySet()
+        self.assertRaises(KeyError, d.check, 'foo')
+        d = ircdb.CapabilitySet(('foo',))
+        self.failUnless(d.check('foo'))
+        self.failIf(d.check('!foo'))
+        d.add('bar')
+        self.failUnless(d.check('bar'))
+        self.failIf(d.check('!bar'))
+        d.add('!baz')
+        self.failIf(d.check('baz'))
+        self.failUnless(d.check('!baz'))
+        d.add('!bar')
+        self.failIf(d.check('bar'))
+        self.failUnless(d.check('!bar'))
+        d.remove('!bar')
+        self.assertRaises(KeyError, d.check, '!bar')
+        self.assertRaises(KeyError, d.check, 'bar')
+
+
+class UserCapabilitySetTestCase(unittest.TestCase):
+    def test(self):
+        d = ircdb.UserCapabilitySet(('owner',))
+        self.failIf(d.check('!foo'))
+        self.failUnless(d.check('foo'))
+        
+
+class CapabilitySetTestCase(unittest.TestCase):
+    def test(self):
+        s = ircdb.CapabilitySet()
+        s.add('foo')
+        self.failUnless('foo' in s)
+        self.failIf('!foo' in s)
+        s.add('!bar')
+        self.failUnless('!bar' in s)
+        self.failIf('bar' in s)
+        self.assertRaises(KeyError, s.check, 'baz')
+        self.assertRaises(KeyError, s.check, '!baz')
+        s.remove('!bar')
+        self.assertRaises(KeyError, s.check, '!bar')
+        self.assertRaises(KeyError, s.check, 'bar')
+        s.remove('foo')
+        self.assertRaises(KeyError, s.check, 'foo')
+        self.assertRaises(KeyError, s.check, '!foo')
+
+class UserCapabilitySetTestCase(unittest.TestCase):
+    def test(self):
+        s = ircdb.UserCapabilitySet()
+        s.add('owner')
+        self.failUnless(s.check('owner'))
+        self.failIf(s.check('!owner'))
+        self.failIf(s.check('!foo'))
+        self.failUnless(s.check('foo'))
+
 class IrcUserTestCase(unittest.TestCase):
     def testCapabilities(self):
         u = ircdb.IrcUser()
         u.addCapability('foo')
-        u.addCapability('!bar')
-        self.failIf(u.checkCapability('bar'))
-        self.failUnless(u.checkCapability('!bar'))
         self.failUnless(u.checkCapability('foo'))
         self.failIf(u.checkCapability('!foo'))
+        u.addCapability('!bar')
+        self.failUnless(u.checkCapability('!bar'))
+        self.failIf(u.checkCapability('bar'))
         u.removeCapability('foo')
         u.removeCapability('!bar')
-        self.failIf(u.checkCapability('!bar'))
+        self.assertRaises(KeyError, u.checkCapability, 'foo')
-        self.failIf(u.checkCapability('foo'))
+        self.assertRaises(KeyError, u.checkCapability, '!bar')
 
     def testOwner(self):
         u = ircdb.IrcUser()
@@ -89,7 +175,6 @@ class IrcUserTestCase(unittest.TestCase):
         self.failIf(u.checkCapability('foo'))
         self.failUnless(u.checkCapability('!foo'))
         
-
 class IrcChannelTestCase(unittest.TestCase):
     def testInit(self):
         c = ircdb.IrcChannel()
@@ -133,25 +218,8 @@ class IrcChannelTestCase(unittest.TestCase):
         c.removeBan(banmask)
         self.failIf(c.checkIgnored(prefix))
 
-
-class FunctionsTestCase(unittest.TestCase):
-    def testIsAntiCapability(self):
-        self.failIf(ircdb.isAntiCapability('foo'))
-        self.failIf(ircdb.isAntiCapability('#foo.bar'))
-        self.failUnless(ircdb.isAntiCapability('!foo'))
-        self.failUnless(ircdb.isAntiCapability('#foo.!bar'))
-
-    def testIsChannelCapability(self):
-        self.failIf(ircdb.isChannelCapability('foo'))
-        self.failUnless(ircdb.isChannelCapability('#foo.bar'))
-
-    def testMakeAntiCapability(self):
-        self.assertEqual(ircdb.makeAntiCapability('foo'), '!foo')
-        self.assertEqual(ircdb.makeAntiCapability('#foo.bar'), '#foo.!bar')
-
-
 class UsersDictionaryTestCase(unittest.TestCase):
-    filename = 'emptyUsers.conf'
+    filename = 'UsersDictionaryTestCase.conf'
     def setUp(self):
         fd = file(self.filename, 'w')
         fd.write('{}\n')
@@ -175,6 +243,117 @@ class UsersDictionaryTestCase(unittest.TestCase):
         # The UsersDictionary shouldn't allow users to be added whose hostmasks
         # match another user's already in the database.
         self.assertRaises(ValueError, self.users.setUser, 'bar', u)
-        #self.assertRaises(ValueError, self.users.setUser, 'biff', '*!*@*')
+        u.removeHostmask(banmask)
+        u.addHostmask('*!*@*')
+        self.assertRaises(ValueError, self.users.setUser, 'biff', u)
         
 
+class CheckCapabilityTestCase(unittest.TestCase):
+    filename = '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'
+    channel = '#channel'
+    cap = 'foo'
+    anticap = ircdb.makeAntiCapability(cap)
+    chancap = ircdb.makeChannelCapability(channel, cap)
+    antichancap = ircdb.makeAntiCapability(chancap)
+    channelnothing = ircdb.IrcChannel()
+    channelcap = ircdb.IrcChannel()
+    channelcap.addCapability(cap)
+    channelanticap = ircdb.IrcChannel()
+    channelanticap.addCapability(anticap)
+    def setUp(self):
+        fd = file(self.filename, 'w')
+        fd.write('{}\n')
+        fd.close()
+        self.users = ircdb.UsersDictionary(self.filename)
+        self.channels = ircdb.ChannelsDictionary(self.filename)
+        owner = ircdb.IrcUser()
+        owner.addCapability('owner')
+        owner.addHostmask(self.owner)
+        self.users.setUser('owner', owner)
+        nothing = ircdb.IrcUser()
+        nothing.addHostmask(self.nothing)
+        self.users.setUser('nothing', nothing)
+        justfoo = ircdb.IrcUser()
+        justfoo.addCapability(self.cap)
+        justfoo.addHostmask(self.justfoo)
+        self.users.setUser('justfoo', justfoo)
+        antifoo = ircdb.IrcUser()
+        antifoo.addCapability(self.anticap)
+        antifoo.addHostmask(self.antifoo)
+        self.users.setUser('antifoo', antifoo)
+        justchanfoo = ircdb.IrcUser()
+        justchanfoo.addCapability(self.chancap)
+        justchanfoo.addHostmask(self.justchanfoo)
+        self.users.setUser('justchanfoo', justchanfoo)
+        antichanfoo = ircdb.IrcUser()
+        antichanfoo.addCapability(self.antichancap)
+        antichanfoo.addHostmask(self.antichanfoo)
+        self.users.setUser('antichanfoo', antichanfoo)
+        channel = ircdb.IrcChannel()
+        self.channels.setChannel(self.channel, channel)
+        
+    def tearDown(self):
+        os.remove(self.filename)
+
+    def checkCapability(self, hostmask, capability):
+        return ircdb.checkCapability(hostmask, capability,
+                                     self.users, self.channels)
+
+    def testOwner(self):
+        self.failUnless(self.checkCapability(self.owner, self.cap))
+        self.failIf(self.checkCapability(self.owner, self.anticap))
+        self.failUnless(self.checkCapability(self.owner, self.chancap))
+        self.failIf(self.checkCapability(self.owner, self.antichancap))
+        self.channels.setChannel(self.channel, self.channelanticap)
+        self.failUnless(self.checkCapability(self.owner, self.cap))
+        self.failIf(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.failUnless(self.checkCapability(self.nothing, self.chancap))
+        self.failIf(self.checkCapability(self.nothing, self.antichancap))
+        self.channels.setChannel(self.channel, self.channelanticap)
+        self.failIf(self.checkCapability(self.nothing, self.chancap))
+        self.failUnless(self.checkCapability(self.nothing, self.antichancap))
+
+    def testNothing(self):
+        self.failIf(self.checkCapability(self.nothing, self.cap))
+        self.failIf(self.checkCapability(self.nothing, self.anticap))
+
+    def testJustFoo(self):
+        self.failUnless(self.checkCapability(self.justfoo, self.cap))
+        self.failIf(self.checkCapability(self.justfoo, self.anticap))
+
+    def testAntiFoo(self):
+        self.failUnless(self.checkCapability(self.antifoo, self.anticap))
+        self.failIf(self.checkCapability(self.antifoo, self.cap))
+
+    def testJustChanFoo(self):
+        self.channels.setChannel(self.channel, self.channelnothing)
+        self.failUnless(self.checkCapability(self.justchanfoo, self.chancap))
+        self.failIf(self.checkCapability(self.justchanfoo, self.antichancap)) 
+        self.channelnothing.defaultAllow = not self.channelnothing.defaultAllow
+        self.failUnless(self.checkCapability(self.justchanfoo, self.chancap))
+        self.failIf(self.checkCapability(self.justchanfoo, self.antichancap)) 
+        self.channels.setChannel(self.channel, self.channelanticap)
+        self.failUnless(self.checkCapability(self.justchanfoo, self.chancap))
+        self.failIf(self.checkCapability(self.justchanfoo, self.antichancap))
+
+    def testAntiChanFoo(self):
+        self.channels.setChannel(self.channel, self.channelnothing)
+        self.failIf(self.checkCapability(self.antichanfoo, self.chancap))
+        self.failUnless(self.checkCapability(self.antichanfoo,
+                                             self.antichancap))