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 = ""