def testFilterSimple(self):
session = self.session()
query = session.query(self.model)
for i in range(10):
code = randomcode()
qs = query.filter(code = code)
self.assertEqual(qs.count(),1)
self.assertEqual(qs[0].code,code)
def testExcludeSimple(self):
session = self.session()
query = session.query(self.model)
for i in range(10):
code = randomcode()
r = query.exclude(code = code)
self.assertEqual(r.count(),SIZE-1)
self.assertFalse(code in set((o.code for o in r)))
def testFilterSimple(self):
session = self.session()
query = session.query(self.model)
for i in range(10):
code = self.data.randomcode()
qs = yield query.filter(code=code).all()
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0].code, code)
def testExcludeSimple(self):
session = self.session()
query = session.query(self.model)
for i in range(10):
code = self.data.randomcode()
all = yield query.exclude(code=code).all()
self.assertEqual(len(all), self.data.size-1)
self.assertFalse(code in set((o.code for o in all)))
def testExcludeSimple(self):
session = self.session()
query = session.query(self.model)
for i in range(10):
code = self.data.randomcode()
all = yield query.exclude(code=code).all()
self.assertEqual(len(all), self.data.size - 1)
self.assertFalse(code in set((o.code for o in all)))
def extend(self, words):
add = self.data.add
for word in words:
we = word+self.endchar
add(we)
for idx in range(self.minlen,len(word)):
add(word[:idx])
self.data.save()
def testFilterSimple(self):
session = self.session()
query = session.query(self.model)
for i in range(10):
code = self.data.randomcode()
qs = yield query.filter(code=code).all()
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0].code, code)
def setUp(self):
ts = []
ss = []
self.closureCount = 0
for x in range(5000):
t = oTest1()
ts.append(t)
s = safeRef(t, self._closure)
ss.append(s)
ts.append(ftest2)
ss.append(safeRef(ftest2, self._closure))
for x in range(30):
t = oTest2()
ts.append(t)
s = safeRef(t, self._closure)
ss.append(s)
self.ts = ts
self.ss = ss
def generate(self):
size, num = self.size
self.names = self.populate('choice', size=size,
choice_from=basic_english_words)
self.groups = []
self.empty = size*['']
for i in range(size):
text = ' '.join(self.populate('choice', num,\
choice_from=basic_english_words))
self.groups.append(text)
def add(self, word):
'''Add a word to the dataset'''
dataset = self.data
we = word+self.endchar
if word in dataset:
dataset.add(we)
dataset.save()
elif we not in dataset:
for idx in range(self.minlen,len(word)):
dataset.add(word[:idx])
dataset.add(we)
dataset.save()
def make(self, size = 5, maxsize = 10, nesting = 1, level = 0):
keys = populate(size = size)
if level:
keys.append('')
for key in keys:
t = choice(self.rtype) if level else 'dict'
if nesting and t == 'dict':
yield key,dict(self.make(size = randint(0,maxsize),
maxsize = maxsize,
nesting = nesting - 1,
level = level + 1))
else:
if t == 'list':
v = [random() for i in range(10)]
elif t == 'number':
v = random()
elif t == 'dict':
v = random()
else:
v = t
yield key,v
def make(self, size=5, maxsize=10, nesting=1, level=0):
keys = populate(size=size)
if level:
keys.append('')
for key in keys:
t = choice(self.rtype) if level else 'dict'
if nesting and t == 'dict':
yield key, dict(
self.make(size=randint(0, maxsize),
maxsize=maxsize,
nesting=nesting - 1,
level=level + 1))
else:
if t == 'list':
v = [random() for i in range(10)]
elif t == 'number':
v = random()
elif t == 'dict':
v = random()
else:
v = t
yield key, v
def disconnect(self, receiver=None, sender=None, weak=True,
dispatch_uid=None):
"""
Disconnect receiver from sender for signal.
If weak references are used, disconnect need not be called. The receiver
will be remove from dispatch automatically.
Arguments:
receiver
The registered receiver to disconnect. May be none if
dispatch_uid is specified.
sender
The registered sender to disconnect
weak
The weakref state to disconnect
dispatch_uid
the unique identifier of the receiver to disconnect
"""
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
self.lock.acquire()
try:
for index in range(len(self.receivers)):
(r_key, _) = self.receivers[index]
if r_key == lookup_key:
del self.receivers[index]
break
finally:
self.lock.release()
'Dallas':('TLS', None),
'maisey':('MS', None),
'zhang':('JNK', None),
'Chile':('XL', None),
'Jose':('HS', None),
'Arnow':('ARN','ARNF'),
'solilijs':('SLLS', None),
'Parachute':('PRKT', None),
'Nowhere':('NR', None),
'Tux':('TKS', None)}
NUM_WORDS = 40
WORDS_GROUPS = lambda size : (' '.join(populate('choice', NUM_WORDS,\
choice_from = basic_english_words))\
for i in range(size))
class TestCase(test.CleanTestCase):
'''Mixin for testing the search engine. No tests implemented here,
just registration and some utility functions. All search-engine tests
below will derive from this class.'''
multipledb = 'redis'
metaphone = True
stemming = True
models = (WordItem, Item, RelatedItem)
def setUp(self):
self.register()
self.engine = self.make_engine()
self.engine.register(Item,('related',))
def publish():
for i in range(messages_per_channel):
for c in channels_to_publish_to:
self.client.publish(c, 'a message')
import datetime
import threading
import time
from distutils.version import StrictVersion
from stdnet.utils import to_string, ispy3k, iteritems, range, flatzset
if not ispy3k:
chr = unichr
from .base import *
to_charlist = lambda x: [x[c:c + 1] for c in range(len(x))]
binary_set = lambda x : set(to_charlist(x))
encode_dict = lambda h : dict(((k,v.encode()) for k,v in h.items()))
class ServerCommandsTestCase(BaseTest):
def setUp(self):
self.client = self.get_client()
self.client.flushdb()
def tearDown(self):
self.client.flushdb()
# GENERAL SERVER COMMANDS
def test_dbsize(self):
self.client['a'] = 'foo'