def product_add_to_db(request):
person_data = Personal('ru')
person_address = Address('ru')
busines = Business('ru')
date = Datetime('ru')
text = Text('ru')
for _ in range(301):
Products.objects.create(
product_name=text.title(),
product_slug=person_data.cid(),
product_description=text.text(quantity=5),
product_price=random_price(),
product_created_at=date.date(start=2017,
end=2017,
fmt='%Y-%m-%d %H:%M:%S'),
product_modified_at=date.date(start=2017,
end=2017,
fmt='%Y-%m-%d %H:%M:%S'),
)
for _ in range(127):
user = User.objects.create(username='******'.format(
str(datetime.datetime.now().microsecond)),
password='******')
Consumers.objects.create(
user=user,
full_name=person_data.full_name(),
banned=true_or_false(),
gender=person_data.gender(),
)
async def generate_private_history(pg, user_ids, rows=20, locale='ru'):
"""
Insert data into 'private_history' table. For every 'user_id' insert
message_num = (rows / len(user_ids)) per user.
:param pg: connect to DB engine(PostgreSQL)
:param user_ids: list of 'user_id' from table 'users'
:param rows: numbers of rows
:param locale: language locale
:return: None
"""
values = []
user_message = Text(locale=locale)
messages_per_user = rows // len(user_ids)
chat_list = ['CHAT_1', 'CHAT_2', 'CHAT_3', 'CHAT_4']
for user_id in user_ids:
for message_num in range(1, messages_per_user):
values.append({
'message_id': message_num,
'message_json': {
'message': {
'text': user_message.sentence(),
}
},
'user_id': user_id,
'chat_id': choice(chat_list),
})
await insert_data(pg, models.private_history, values)
class ModelsAccountTestCase(unittest.TestCase):
person = Personal()
text = Text()
def setUp(self):
self.app = create_app("testing")
self.client = self.app.test_client()
self.context = self.app.app_context()
self.context.push()
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
self.context.pop()
def test_01_save_and_delete(self):
kwargs = {"username": self.person.name(), "email": self.person.email()}
self.assertEqual(User.query.count(), 0)
user = User(**kwargs)
user.save()
self.assertEqual(user.__repr__(),
"<User {} ID {}>".format(kwargs["username"], 1))
self.assertEqual(User.query.count(), 1)
user.delete()
self.assertEqual(User.query.count(), 0)
def test_02_password(self):
kwargs = {"username": self.person.name(), "email": self.person.email()}
password = self.person.password(16)
user = User(**kwargs)
self.assertIsNone(user.password_hash)
with self.assertRaises(AttributeError):
user.password
user.password = password
self.assertIsNotNone(user.password_hash)
self.assertTrue(user.verify_password(password))
self.assertFalse(user.verify_password(self.person.password(16)))
def test_03_token(self):
kwargs = {"username": self.person.name(), "email": self.person.email()}
key_1, key_2 = self.text.words(2)
user = User(**kwargs)
user.save()
token_1 = user.generate_token(key_1)
sleep(1)
token_1_delay = user.generate_token(key_1)
self.assertNotEqual(token_1, token_1_delay)
token_2 = user.generate_token(key_2)
self.assertEquals((User.confirm(key_1, token_1), user),
(User.confirm(key_2, token_2), user))
self.assertIsNone(User.confirm(key_2, token_1))
token = user.generate_token(key_1, expiration=2)
self.assertEqual(User.confirm(key_1, token), user)
sleep(3)
self.assertIsNone(User.confirm(key_1, token))
def generate_tag(count=80, locale="en"):
text = Text(locale)
for _ in range(count):
while True:
name = text.word()
if Tag.query.filter_by(name=name).first() is None:
break
new = Tag(name=name)
db.session.add(new)
db.session.commit()
def init(count=2000, locale='en'):
from elizabeth import Generic, Text
text = Text(locale)
for _ in range(count):
gen_post = Parallel(
field1=text.word(),
field2=text.word(),
)
gen_post.save()
def init(count=20000, locale='en'):
from elizabeth import Text
from random import randint, choice
text = Text(locale)
posts = list(Post.objects.all())
for _ in range(count):
gen_post = Comment(post=choice(posts),
text=text.text(2),
likes=randint(0, 100))
gen_post.save()
def init(count=2000, locale='en'):
from elizabeth import Generic, Text
from random import randint, choice
gen = Generic(locale)
text = Text(locale)
for _ in range(count):
gen_post = Post(author=choice(User.objects.all()),
text=text.text(5),
likes=randint(0, 100))
gen_post.save()
def init(count=2000, locale='en'):
from elizabeth import Personal, Text
gen = Personal(locale)
text = Text(locale)
for _ in range(count):
gen_post = Contact(name=gen.name(),
num=gen.credit_card_number(),
some_blank=text.text(3),
some_null=gen.email())
gen_post.save()
def generate_category(count=40, locale="en"):
text = Text(locale)
for _ in range(count):
while True:
name = text.word()
if Category.query.filter_by(name=name).first() is None:
break
new = Category(name=name)
if _ % 2:
parent = Category.query.order_by(sql_expression_rand()).first()
new.parent_category = parent
db.session.add(new)
db.session.commit()
def main():
try:
client_msg = Text()
payload = dict(message=None, msg_id=0, producer_type='SYNC')
msg_count = 1
while True:
payload['message'] = client_msg.sentence()
payload['msg_id'] = msg_count
send_msg(json.dumps(payload))
msg_count += 1
time.sleep(1)
except KeyboardInterrupt:
conn.close()
sys.exit()
def main():
try:
client_msg = Text()
payload = dict(message=None, msg_id=0)
msg_count = 1
while True:
payload['message'] = client_msg.sentence()
payload['msg_id'] = msg_count
routing_key = choice(SERVER_LIST) + '.' + choice(MSG_TYPE)
send_msg(json.dumps(payload), routing_key)
msg_count += 1
time.sleep(1)
except KeyboardInterrupt:
conn.close()
sys.exit()
async def send():
try:
client_msg = Text()
payload = dict(message=None, msg_id=0, producer_type='ASYNC')
msg_count = 1
transport, protocol = await aioamqp.connect()
channel = await protocol.channel()
await channel.queue_declare(queue_name='client_msg_queue')
while True:
payload['message'] = client_msg.sentence()
payload['msg_id'] = msg_count
await send_msg(json.dumps(payload), channel)
msg_count += 1
await asyncio.sleep(0.003)
except KeyboardInterrupt:
await protocol.close()
transport.close()
def setUp(self):
self.app = create_app("testing")
self.client = self.app.test_client()
self.context = self.app.app_context()
self.context.push()
db.create_all()
person = Personal()
text = Text()
kwargs = {
"username": person.username(),
"email": person.email(),
"password": person.password(16)
}
user = User(**kwargs)
user.save()
def __auth():
response = self.client.post("/api/auth",
data=json.dumps(kwargs),
content_type="application/json")
self.assertEqual(response.status_code, 200)
def __post():
post = Post(title=self.text.title(),
summary=text.text(3),
body=text.text(6),
author=user)
category = Category(name=text.word())
category.save()
post.category = category
tag = Tag(name=text.word())
tag.save()
post.tags.append(tag)
post.save()
return post
self.login = __auth
self.new_post = __post
del kwargs["email"]
self.data = {"kwargs": kwargs, "user": user}
self.text = text
self.person = person
async def direct_pub_worker():
try:
client_msg = Text()
payload = dict(message=None, msg_id=0, producer_type='ASYNC')
msg_count = 1
transport, protocol = await aioamqp.connect('localhost', 5672)
channel = await protocol.channel()
await channel.exchange_declare(exchange_name='direct_message', type_name='direct')
while True:
payload['message'] = client_msg.sentence()
payload['msg_id'] = msg_count
await send_direct_msg(json.dumps(payload), channel, choice(SERVER_LIST))
msg_count += 1
await asyncio.sleep(0.003)
except aioamqp.AmqpClosedConnection:
print("closed connections")
return
except KeyboardInterrupt:
await protocol.close()
transport.close()
async def send_worker():
try:
client_msg = Text()
payload = dict(message=None, msg_id=0, producer_type='ASYNC')
msg_count = 1
transport, protocol = await aioamqp.connect('localhost', 5672)
channel = await protocol.channel()
await channel.queue('task_queue', durable=True)
while True:
payload['message'] = client_msg.sentence()
payload['msg_id'] = msg_count
await send_msg(json.dumps(payload), channel)
msg_count += 1
await asyncio.sleep(0.003)
except aioamqp.AmqpClosedConnection:
print("closed connections")
return
except KeyboardInterrupt:
await protocol.close()
transport.close()
def generate_post(count=390, locale="en"):
text = Text(locale)
box_summary_box = [1, 2, 3]
box_article_box = [7, 8, 9]
author_count = int(User.query.count() / 4)
tag_count = int(Tag.query.count() / 4)
authors = list()
tags = list()
for _ in range(count):
timestamp = datetime(year=randint(1995, 2017),
month=randint(1, 12),
day=randint(1, 28),
hour=randint(0, 23),
minute=randint(0, 59),
second=randint(0, 59),
microsecond=randint(0, 999999))
if _ % author_count == 0:
authors = User.query.order_by(
sql_expression_rand()).limit(author_count).all()
if _ % tag_count == 0:
tags = Tag.query.order_by(
sql_expression_rand()).limit(tag_count).all()
new = Post(author=authors[_ % author_count],
title=text.title(),
summary=text.text(choice(box_summary_box)),
body=text.text(choice(box_article_box)),
timestamp=timestamp,
last_edit=timestamp,
count=randint(0, 10000))
post_tags = [tag for no, tag in enumerate(tags) if no < _ % 4]
new.tags.extend(post_tags)
if _ % 3 == 0:
category = Category.query.order_by(sql_expression_rand()).first()
new.category = category
db.session.add(new)
db.session.commit()
person = Personal('en') # generate data for users
usersDnList = [] # global list DN of generated users
groupsDnList = [] # global list DN of generated groups
# let's connect
server = Server(serverName, get_info=ALL)
conn = Connection(server, user=connUser, password=connUserPwd, authentication=NTLM)
conn.bind() #must be TRUE if OK
conn.add(usersOU, 'organizationalUnit') # add test-ou for users
conn.add(groupsOU, 'organizationalUnit') # add test-ou for groups
# generate groups
data = Text('en')
for _ in range(0,10):
currentGroup = 'cn='+data.word()+',ou=test-groups,dc=stand,dc=lsd'
conn.add(currentGroup, 'group')
groupsDnList.append(currentGroup) # add gnerated group to global list
for _ in range(0,10):
address_country = address.country() # generate OU name
conn.add('ou='+address_country+',ou=test-ou,dc=stand,dc=lsd', 'organizationalUnit') #create OU
for _ in range (0,10):
name = person.name(gender='male')
surname = person.surname(gender='male')
currentUser = '******'+name+'.'+surname+','+'ou='+address_country+',ou=test-ou,dc=stand,dc=lsd'
usersDnList.append(currentUser) # add generated user in global list
conn.add(currentUser, 'User', # add user in OU
{'givenName': name,
def answer():
text = Text('ru')
a = text.text(quantity=1)
return a
def setUp(self):
self.text = Text('en')
import random
from EventClass import Event
import random
from elizabeth import Text, Address
import datetime
if (len(sys.argv) == 2): # action with given argument
print("Custom Behavior: Saving to ", sys.argv[1])
db = boto3.resource('dynamodb')
table = db.Table(sys.argv[1])
else: # default action
print("Default Behavior: Saving to Development Databasee")
db = boto3.resource('dynamodb')
table = db.Table('ColoradoFunDevTable')
text = Text('en')
address = Address('en')
now = datetime.datetime.now()
def random_date(start, end):
"""Generate a random datetime between `start` and `end`"""
return start + datetime.timedelta(
# Get a random amount of seconds between `start` and `end`
seconds=random.randint(0, int((end - start).total_seconds())), )
for i in range(50):
event = Event()
myID = ""
