def testWalk(self):
domain = BaseDomain(key='d')
def gotChild1(d):
child1 = d
def gotChild2(d):
child2 = d
def gotSubchild1(d):
subchild1 = d
return domain.walk('').addCallback(lambda result: result is domain) \
.addCallback(lambda _: domain.walk('///')).addCallback(lambda result: self.assert_(result is domain)) \
.addCallback(lambda _: domain.walk('/child1/')).addCallback(lambda result: self.assert_(result is child1)) \
.addCallback(lambda _: domain.walk('child1')).addCallback(lambda result: self.assert_(result is child1)) \
.addCallback(lambda _: domain.walk('child2')).addCallback(lambda result: self.assert_(result is child2)) \
.addCallback(lambda _: domain.walk('child1/sub1')).addCallback(lambda result: self.assert_(result is subchild1)) \
.addCallback(lambda _: domain.walk('unknown')).addCallback(lambda _: self.assert_(False)).addErrback(lambda failure: failure.trap(DomainPathError)) \
.addCallback(lambda _: domain.walk('child1/unknown')).addCallback(lambda _: self.assert_(False)).addErrback(lambda failure: failure.trap(DomainPathError)) \
.addCallback(lambda _: domain.walk('child1/sub1/unknown')).addCallback(lambda _: self.assert_(False)).addErrback(lambda failure: failure.trap(DomainPathError))
return child1.createSubdomain('sub1').addCallback(gotSubchild1)
return domain.createSubdomain('child2').addCallback(gotChild2)
return domain.createSubdomain('child1').addCallback(gotChild1)
def testKey(self):
self.assertEqual('testKey', BaseDomain(key='testKey').key())
domain1 = BaseDomain(key='testKey')
domain2 = BaseDomain(parent=domain1, key='testKey2')
self.assertEqual('testKey2', domain2.key())
domain3 = BaseDomain(parent=domain1, name='sub3')
self.assertEqual('676c7a29cea4e68de9e65b331ea275fb', domain3.key())
def testGet(self):
domain = BaseDomain(dict={'a' : 33}, key='d')
self.assertEqual(33, domain.get('a'))
self.assertRaises(DomainKeyError, domain.get, 'b')
domain2 = BaseDomain(parent=domain, dict={'c' : 44}, name='sub')
self.assertEqual(33, domain2.get('a'))
self.assertEqual(44, domain2.get('c'))
self.assertRaises(DomainKeyError, domain2.get, 'b')
def testCreateSubdomain(self):
domain = BaseDomain(key='d')
def checkIt(child):
def checkChildren(children):
self.assertEquals(['sub'], children.keys())
self.assert_(child is children['sub'])
return domain.children().addCallback(checkChildren)
return domain.createSubdomain('sub').addCallback(checkIt)
def getDefaultDomain(self):
"""
Получить домен по умолчанию в системе.
@return: домен по умолчанию.
@rtype: L{spamfighter.interfaces.IDomain}
"""
from spamfighter.core.domain import BaseDomain, getDefaultDomain
from spamfighter.core.firewall import MessageFirewall
from spamfighter.core.model.bayes import BayesModel
from spamfighter.core.message import MessageDomain, TextAttributeDomain, UniqueIntAttributeDomain, IPAttributeDomain
from spamfighter.core.storage.memory import DomainMemoryStorage
from spamfighter.core.storage.dbm import DomainedDBMStorage
from spamfighter.core.log import MessageLog
from spamfighter.core.counters import RequestPerSecondCounter, RequestCounter, AverageServiceTimeCounter
domain = BaseDomain(parent=getDefaultDomain(), key='sample_root')
rules = """
do lengthCheck(minLength=1, maxLength=1000) mark invalid
do regexpCheck(regexp="[a-z]+") mark notalpha
if invalid, notalpha skip to 1000
do messageFloodCheck() mark flood
do messageFrequencyCheck() mark messagefrequent, frequent
do userFrequencyCheck() mark userfrequent, frequent
if frequent skip to 1000
do modelClassify(model="model2") mark spam
do messageLogPut(log="messageLog2")
1000: do messageLogPut()
if invalid stop as INVALID
if frequent stop as FREQUENT
if spam stop as SPAM
stop as OK
""".strip()
domain.set('model', BayesModel())
domain.set('model2', BayesModel())
domain.set('messageAnalyzer', MessageFirewall(rules))
domain.set('storage', DomainMemoryStorage())
domain.set('logStorage', DomainMemoryStorage())
domain.set('db', DomainedDBMStorage())
domain.set('messageLog', MessageLog(storage='logStorage'))
domain.set('messageLog2', MessageLog(storage='logStorage'))
domain.set('counterRequest', RequestCounter())
domain.set('counterRPS', RequestPerSecondCounter())
domain.set('counterAST', AverageServiceTimeCounter())
def fillS1(subdomain_1):
subdomain_1.set('model2', BayesModel())
subdomain_1.set('counterRequest', RequestCounter())
subdomain_1.set('counterRPS', RequestPerSecondCounter())
subdomain_1.set('counterAST', AverageServiceTimeCounter())
def fillS1_1(subdomain_1_1):
subdomain_1_1.set('messageLog', MessageLog(storage='logStorage'))
subdomain_1.createSubdomain('s1_1').addCallback(fillS1_1)
domain.createSubdomain('s1').addCallback(fillS1)
domain.createSubdomain('s2')
return domain
def testCreateSubdomainDuplicate(self):
domain = BaseDomain(key='d')
return domain.createSubdomain('sub').addCallback(lambda _: domain.createSubdomain('sub')) \
.addCallback(lambda _: self.assert_(False)).addErrback(lambda failure: failure.trap(DomainDuplicateError))
def testParent(self):
domain1 = BaseDomain(key='d')
domain2 = BaseDomain(parent=domain1, name='sub2')
self.assertEqual(None, domain1.parent())
self.assertEqual(domain1, domain2.parent())
def testList(self):
domain = BaseDomain(dict={'a' : 33, 'b' : 44}, key='d')
self.assertEqual(['a', 'b'], domain.list())
domain = BaseDomain(dict={}, key='d')
self.assertEqual([], domain.list())
def testDelete(self):
domain = BaseDomain(dict={'lll':'dsd'}, key='d')
return domain.delete('lll').addCallback(lambda _: self.assertRaises(DomainKeyError, domain.get, 'lll')) \
.addCallback(lambda _: domain.delete('lll'))
def testSet(self):
domain = BaseDomain(key='d')
return domain.set('fff', 'ggg').addCallback(lambda _: self.assertEqual('ggg', domain.get('fff')))
def testHas(self):
domain = BaseDomain(dict={'a' : 33}, key='d')
self.assertEqual(True, domain.has('a'))
self.assertEqual(False, domain.has('b'))
