def test_random_string(self):
s1 = random_string(min_len=20)
self.assertEqual(len(s1), 20)
self.assertIsInstance(s1, str)
self.assertNotEqual(s1, random_string(min_len=20))
self.assertNotEqual(s1, random_string(min_len=20))
self.assertNotEqual(s1, random_string(min_len=20))
def test_random_string(self):
s1 = random_string(min_len=20)
self.assertEqual(len(s1), 20)
self.assertIsInstance(s1, str)
self.assertNotEqual(s1, random_string(min_len=20))
self.assertNotEqual(s1, random_string(min_len=20))
self.assertNotEqual(s1, random_string(min_len=20))
def test_lock(self):
key1 = random_string()
key2 = random_string()
lock = self.cache.lock(key1, blocking=False)
other_lock = self.cache.lock(key2, blocking=False)
self.assertTrue(lock.acquire())
self.assertFalse(lock.acquire())
self.assertTrue(other_lock.acquire())
other_lock.release()
lock.release()
def test_lock(self):
key1 = random_string()
key2 = random_string()
lock = self.cache.lock(key1, blocking=False)
other_lock = self.cache.lock(key2, blocking=False)
self.assertTrue(lock.acquire())
self.assertFalse(lock.acquire())
self.assertTrue(other_lock.acquire())
other_lock.release()
lock.release()
def generate_secret(length, hexadecimal=False):
if hexadecimal:
return ''.join((hex(randint(1, 10000)) for _ in range(length)))
else:
chars = 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)'
return random_string(min_len=length, max_len=length,
char=chars)
def randomname(prefix=None, len=8):
"""Generate a random name with a prefix (default to ``luxtest-``)
"""
prefix = prefix if prefix is not None else 'luxtest-'
name = random_string(min_len=len, max_len=len,
characters=string.ascii_letters)
return ('%s%s' % (prefix, name)).lower()
def randomname(prefix=None, len=8):
'''Generate a random name with a prefix (default to ``luxtest-``)
'''
prefix = prefix if prefix is not None else 'luxtest-'
name = random_string(min_len=len,
max_len=len,
characters=string.ascii_letters)
return ('%s%s' % (prefix, name)).lower()
async def setUp(self):
self.app = api.QueueApp(
name='connection_%s' % random_string(),
config='tests.config',
workers=0
)
await self.app.start()
self.backend = self.app.backend
def user(self, websocket):
user = websocket.handshake.get('django.user')
if user.is_authenticated():
return user.username, True
else:
session = websocket.handshake.get('django.session')
user = session.get('chatuser')
if not user:
user = '******' % random_string(length=6).lower()
session['chatuser'] = user
return user, False
def user(self, websocket):
user = websocket.handshake.get('django.user')
if user.is_authenticated():
return user.username, True
else:
session = websocket.handshake.get('django.session')
user = session.get('chatuser')
if not user:
user = '******' % random_string(length=6).lower()
session['chatuser'] = user
return user, False
def test_copy_json(self):
data = {'test': 12345}
text = json.dumps(data)
size = len(text)
key = '%s.json' % random_string(characters=string.ascii_letters)
response = self.s3.upload_file(BUCKET, text, key=key)
self.assert_status(response)
copy_key = 'copy_{}'.format(key)
response = self.s3.copy_storage_object(BUCKET, key, BUCKET, copy_key)
self.assert_status(response)
self.assert_s3_equal(text.encode('utf-8'), copy_key)
self._clean_up(key, size)
self._clean_up(copy_key, size)
def test_can_paginate(self):
name = random_string()
for i in range(5):
key_name = '%s/key%d' % (name, i)
self._create_object(key_name, 'bla')
# Eventual consistency.
self._green_sleep(3)
paginator = self.s3.get_paginator('list_objects')
pages = paginator.paginate(MaxKeys=1, Bucket=BUCKET, Prefix=name)
responses = self._fetch_all(pages)
self.assertEqual(len(responses), 5)
for i, el in enumerate(responses):
key = el['Contents'][0]['Key']
self.assertEqual(key, '%s/key%d' % (name, i))
def test_upload_text(self):
with open(__file__, "r") as f:
body = f.read()
key = "%s.py" % random_string(characters=string.ascii_letters)
response = self.s3.put_object(Bucket=BUCKET, Body=body, ContentType="text/plain", Key=key)
self.assert_status(response)
#
# Read object
response = self.s3.get_object(Bucket=BUCKET, Key=key)
self.assert_status(response)
self.assertEqual(response["ContentType"], "text/plain")
#
# Delete object
response = self.s3.delete_object(Bucket=BUCKET, Key=key)
self.assert_status(response, 204)
self.assertRaises(ClientError, self.s3.get_object, Bucket=BUCKET, Key=key)
async def test_paginate_asyncio_build_full_result(self):
name = random_string()
for i in range(5):
key_name = '%s/key%d' % (name, i)
await self._asyncio_create_object(key_name, 'bla')
await asyncio.sleep(3)
s3 = self.s3.client
paginator = s3.get_paginator('list_objects')
pages = paginator.paginate(MaxKeys=1, Bucket=BUCKET, Prefix=name)
result = await pages.build_full_result()
self.assertEqual(len(result), 1)
responses = result['Contents']
self.assertEqual(len(responses), 5)
for i, el in enumerate(responses):
key = el['Key']
self.assertEqual(key, '%s/key%d' % (name, i))
def test_upload_text(self):
with open(__file__, 'r') as f:
body = f.read()
key = '%s.py' % random_string(characters=string.ascii_letters)
response = self.s3.put_object(Bucket=BUCKET,
Body=body,
ContentType='text/plain',
Key=key)
self.assert_status(response)
# Read object
response = self.s3.get_object(Bucket=BUCKET, Key=key)
self.assert_status(response)
self.assertEqual(response['ContentType'], 'text/plain')
# Delete Object
response = self.s3.delete_object(Bucket=BUCKET, Key=key)
self.assert_status(response, 204)
def test_copy_text(self):
filename = __file__
with open(filename, 'r') as f:
size = len(f.read())
with open(filename, 'r') as f:
key = '%s.py' % random_string(characters=string.ascii_letters)
response = self.s3.upload_file(BUCKET,
f,
key=key,
ContentType='text/plain')
self.assert_status(response)
copy_key = 'copy_{}'.format(key)
response = self.s3.copy_storage_object(BUCKET, key, BUCKET,
copy_key)
self.assert_status(response)
self.assert_s3_equal(filename, copy_key)
self._clean_up(key, size)
self._clean_up(copy_key, size)
def randomkey(cls, length=None):
return random_string(min_length=length, max_length=length)
def randomname(prefix):
name = random_string(min_len=8, max_len=8, characters=string.ascii_letters)
return ('%s%s' % (prefix, name)).lower()
def generate_secret(length=64, allowed_chars=None, hexadecimal=False):
if hexadecimal:
return ''.join((hex(randint(1, 10000)) for _ in range(length)))
return random_string(length, length, allowed_chars or secret_choices)
def populate(datatype='string', size=10, start=None, end=None,
converter=None, choice_from=None, **kwargs):
'''Utility function for populating lists with random data.
Useful when populating database with data for fuzzy testing.
Supported data-types
* *string*
For example::
populate('string', 100, min_len=3, max_len=10)
create a 100 elements list with random strings
with random length between 3 and 10
* *date*
For example::
from datetime import date
populate('date', 200, start=date(1997,1,1), end=date.today())
create a 200 elements list with random datetime.date objects
between *start* and *end*
* *integer*
For example::
populate('integer', 200, start=0, end=1000)
create a 200 elements list with random integers between ``start``
and ``end``
* *float*
For example::
populate('float', 200, start=0, end=10)
create a 200 elements list with random floats between ``start`` and
``end``
* *choice* (elements of an iterable)
For example::
populate('choice', 200, choice_from=['pippo','pluto','blob'])
create a 200 elements list with random elements from ``choice_from``
'''
data = []
converter = converter or def_converter
if datatype == 'date':
date_end = end or date.today()
date_start = start or date(1990, 1, 1)
delta = date_end - date_start
for s in range(size):
data.append(converter(random_date(date_start, delta.days)))
elif datatype == 'integer':
start = start or 0
end = end or 1000000
for s in range(size):
data.append(converter(randint(start, end)))
elif datatype == 'float':
start = start or 0
end = end or 10
for s in range(size):
data.append(converter(uniform(start, end)))
elif datatype == 'choice' and choice_from:
for s in range(size):
data.append(choice(list(choice_from)))
else:
for s in range(size):
data.append(converter(random_string(**kwargs)))
return data
def randomname(prefix=None):
prefix = prefix or 'luxtest_'
name = random_string(min_len=8, max_len=8, characters=string.ascii_letters)
return ('%s%s' % (prefix, name)).lower()
def randomname(prefix=None):
prefix = prefix or 'luxtest_'
name = random_string(min_len=8, max_len=8, characters=string.ascii_letters)
return ('%s%s' % (prefix, name)).lower()
def generate_secret(length, hexadecimal=False):
if hexadecimal:
return ''.join((hex(randint(1, 10000)) for _ in range(length)))
else:
chars = 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)'
return random_string(min_len=length, max_len=length, char=chars)
def generate_secret(length=64, allowed_chars=None, hexadecimal=False):
if hexadecimal:
return ''.join((hex(randint(1, 10000)) for _ in range(length)))
return random_string(length, length, allowed_chars or secret_choices)
def randomkey(cls, length=None):
return random_string(min_length=length, max_length=length)
async def setUp(self):
self.app = api.QueueApp(name='connection_%s' % random_string(),
config='tests.config',
workers=0)
await self.app.start()
self.backend = self.app.backend
