def sample_job(self):
# Create portfolio
skills_list = [
'Farmer', 'Carpenter', 'PHP', 'Javascript', 'Designer', 'Css'
]
for i in range(1, 1000):
title = 'job-example%s' % i
default = {
'title':
title,
'contact_information':
loremipsum.get_paragraph(),
'description':
loremipsum.get_paragraph(),
'role':
random.choice(Job.ROLE_CHOICES)[0],
'position':
random.choice(Job.POSITION_CHOICES)[0],
'salary_min':
randint(500, 5000),
'salary_max':
randint(6000, 50000),
'equity_min':
randint(0, 100),
'equity_max':
randint(0, 100),
'years_of_experience':
randint(0, 10),
'location':
' '.join(loremipsum.get_sentence(False).split(' ')[0:5]),
'skills':
random.choice(skills_list),
'created':
timezone.now(),
'changed':
timezone.now(),
'status':
STATUS_PUBLISHED,
}
job, created = Job.objects.get_or_create(title=title,
defaults=default)
if created:
job.country = random.choice(self.country_list)
job.save()
print 'Generated %s : %s' % ('Job', job.title)
self.job_list.append(job)
def createRandomEvents(self, context, count):
print 'creating {0} Events'.format(count)
for i in range(count):
obj = createContentInContainer(context, u'Event', title=loremipsum.get_sentence())
obj.description = loremipsum.get_paragraph()
self.publish(obj)
obj.reindexObject()
def create_random_profile(time):
first_name = random.choice(first_names)
last_name = random.choice(last_names)
customerId = first_name + " " + last_name
email = customerId.lower().replace(" ", ".") + "@" + random.choice(email_domains)
preference = random.choice(preferences)
froms = preferencesMap[preference]
profile = {
"customerId": customerId,
"accountStatus": "C",
"cycle": "1",
"email": email,
"mobile": ''.join("%0.11d" % random.randint(0,999999999999)),
"contactPreference": preference
}
details = {
"from": random.sample(froms, 1)[0],
"time": time.strftime("%Y-%m-%d %H:%M:%S"),
"text": get_paragraph()
}
payload = {
"profile": profile,
"details": details
}
print payload
return payload
def sample_news(self):
admin = User.objects.get(id=1)
for i in range(20):
permalink = 'example-news-%s' % i
news, created = News.objects.get_or_create(
permalink=permalink,
defaults={
'title':
' '.join(loremipsum.get_sentence(False).split(' ')[0:5]),
'summary':
' '.join(loremipsum.get_sentence(False).split(' ')[0:15]),
'description':
loremipsum.get_paragraph(),
'permalink':
permalink,
'status':
STATUS_PUBLISHED,
'created_by':
admin,
})
if created:
instance_save_image_from_url(
news, 'http://lorempixel.com/430/320/nature/', rand=True)
print 'Generated news: %s' % news.permalink
random.shuffle(self.topic_list)
for topic in self.topic_list[0:random.randrange(0, 4)]:
news.topics.add(topic)
self.news_list.append(news)
def get(self, number=10, bulk=False, **kwargs):
"""randomly generated document, title and text based on loremipsum module,
image is a link to lorempixel random image
Parameters
----
number : int
The number of test documents to generated
bulk : bool (default=False)
Whether to yield single documents (if False) or a list of documents (if True)
"""
start = randint(0, 1000)
batch = []
for i in range(number):
fake_id = i + start
doc = {
"_id": "testdoc_{fake_id}".format(**locals()),
"title": prettier(loremipsum.get_sentence()),
"text": prettier(loremipsum.get_paragraph()),
"image": "http://lorempixel.com/400/200/",
}
doc.update(kwargs)
if not bulk:
yield doc
else:
batch.append(doc)
if not len(batch) % (number / 10):
yield batch
batch = []
if bulk and batch:
yield batch
def createRandomBanners(self, context, count, w, h):
print 'creating {0} Banners'.format(count)
for i in range(count):
obj = createContentInContainer(context, u'BannerEsports', title=loremipsum.get_sentence(), picture=self.getRandomImage(w, h, u'sports'))
obj.description = loremipsum.get_paragraph()
obj.url = u'http://www.upc.edu'
self.publish(obj)
obj.reindexObject()
def handle(self, *args, **options):
for i in range(5):
newUser = User(username='******' + str(i))
newUser.save()
users = User.objects.all()
for i in range(10):
newTag = Tag(text='TestTag' + str(i))
newTag.save()
self.stdout.write(
self.style.SUCCESS(
'Generation of test tags completed successfully!'))
tags = Tag.objects.all()
for i in range(25):
upperLine = random.randrange(10)
bottomLine = upperLine + random.randrange(10 - upperLine) + 1
newQuestion = Question(asking=users[random.randrange(5)],
title=get_sentence(),
text=get_paragraph(),
ratin=random.randrange(100))
newQuestion.save()
for tag in tags[upperLine:bottomLine]:
newQuestion.tags.add(tag)
self.stdout.write(
self.style.SUCCESS(
'Generation of test Questions completed successfully!'))
questions = Question.objects.all()
for question in questions:
counter = 0
for user in users:
newLike = Like(assessment=(-1 + random.randrange(2) * 2),
question_id=question.id,
user_id=user.id)
newLike.save()
counter += newLike.assessment
question.ratin = counter
question.save()
for i in range(random.randrange(10)):
newAnswer = Answer(text=get_paragraph(),
correct=False,
answerer_id=(users[random.randrange(5)].id),
question_id=question.id)
newAnswer.save()
self.stdout.write(
self.style.SUCCESS(
'Generation of test Answers and Likes completed successfully!')
)
def createRandomEvents(self, context, count):
print 'creating {0} Events'.format(count)
for i in range(count):
obj = createContentInContainer(context,
u'Event',
title=loremipsum.get_sentence())
obj.description = loremipsum.get_paragraph()
self.publish(obj)
obj.reindexObject()
def generate_note_data(max_length=300):
content = get_paragraph()[:max_length]
# add random hashtags
content += '\n' + get_sentence().replace(' ', ' #')
data = {
'title': get_sentence(),
'content': content,
'color': Command.random_color(),
'is_pinned': bool(randint(0, 1)),
'is_archived': bool(randint(0, 1)),
}
return data
def generate_note_data(max_length=300):
content = get_paragraph()[:max_length]
# add random hashtags
content += '\n' + get_sentence().replace(' ', ' #')
data = {
'title': get_sentence(),
'content': content,
'color': Command.random_color(),
'is_pinned': bool(randint(0, 1)),
'is_archived': bool(randint(0, 1)),
}
return data
def createRandomBanners(self, context, count, w, h):
print 'creating {0} Banners'.format(count)
for i in range(count):
obj = createContentInContainer(context,
u'BannerEsports',
title=loremipsum.get_sentence(),
picture=self.getRandomImage(
w, h, u'sports'))
obj.description = loremipsum.get_paragraph()
obj.url = u'http://www.upc.edu'
self.publish(obj)
obj.reindexObject()
def handle(self, *args, **options):
add_users()
users = User.objects.filter(username__startswith="user_")
courses = Course.objects.all()
for user in users:
for course in courses:
CourseFeedback.objects.create(course=course, user=user, comment=get_paragraph(),
r_course_difficulty=choice([5, 2, 0, -2, -5]),
r_course_organization=choice([5, 2, 0, -2, -5]),
r_tutor_presentation=choice([5, 2, 0, -2, -5]),
r_tutor_support=choice([5, 2, 0, -2, -5]),
r_recommendation=choice([5, 2, 0, -2, -5]),
)
def write_mockfiles(self, append=True):
for filename in self.mock_filenames:
paragraph = get_paragraph()
C = configobj.ConfigObj(filename)
text = C['randomtext']['text'].strip()
if append:
text += paragraph
else:
text = paragraph
C['randomtext']['text'] = text
C.write()
self.git(['add', filename])
def __auto_populate(num_of_stories=10, num_of_tags=10):
# generate tags
for i in xrange(num_of_tags):
t = Tag(name=LI.get_sentence().split()[0])
t.save()
tags = Tag.objects.all()
for i in xrange(num_of_stories):
s = Story(title=LI.get_sentence(), body=LI.get_paragraph())
s.save()
for j in xrange(rnd.randint(1, 4)):
tag_idx = rnd.randint(0, len(tags)-1)
s.tag.add(tags[tag_idx])
s.save()
def sample_event(self):
admin = User.objects.get(id=1)
for i in range(20):
permalink = 'example-event-%s' % i
event, created = Event.objects.get_or_create(
permalink=permalink,
defaults={
'title':
' '.join(loremipsum.get_sentence(False).split(' ')[0:5]),
'summary':
' '.join(loremipsum.get_sentence(False).split(' ')[0:15]),
'description':
loremipsum.get_paragraph(),
'permalink':
permalink,
'status':
STATUS_PUBLISHED,
'created_by':
admin,
'start_date':
timezone.now(),
'end_date':
timezone.now(),
'phone':
'08123456789',
'email':
'*****@*****.**',
'facebook_url':
'http://facebook.com/%s' % permalink,
'twitter_url':
'http://twitter.com/%s' % permalink,
'homepage_url':
'http://homepage.com/%s' % permalink,
'location':
' '.join(loremipsum.get_sentence(False).split(' ')[0:20]),
})
if created:
instance_save_image_from_url(
event, 'http://lorempixel.com/430/320/nature/', rand=True)
print 'Generated event: %s' % event.permalink
random.shuffle(self.topic_list)
for topic in self.topic_list[0:random.randrange(0, 4)]:
event.topics.add(topic)
self.event_list.append(event)
def sample_people(self):
# Generate 60 users with lorempixel
for i in range(0, 60):
user_role = random.choice(self.user_role_list)
user, created = User.objects.get_or_create(
email='*****@*****.**' % i,
defaults={
'email':
'*****@*****.**' % i,
'priority':
randint(0, 10),
'username':
'******' % i,
'first_name':
names.get_first_name(),
'last_name':
names.get_last_name(),
'occupation':
' '.join(loremipsum.get_sentence(False).split(' ')[0:3]),
'summary':
' '.join(loremipsum.get_sentence(False).split(' ')[0:15]),
'description':
loremipsum.get_paragraph(),
'facebook_url':
'https://www.facebook.com/username%s' % i,
'twitter_url':
'https://www.twitter.com/username%s' % i,
'linkedin_url':
'https://www.linkedin.com/username%s' % i,
'homepage_url':
'https://www.homepage.com/username%s' % i,
})
if created:
user.set_password('password')
user.country = random.choice(self.country_list)
user.user_roles.add(user_role)
user.save()
instance_save_image_from_url(
user, 'http://lorempixel.com/430/320/people/', rand=True)
print 'Generated user : %s (%s)' % (user.get_display_name(),
user.email)
self.user_list.append(user)
def test_diff(self):
doc1 = TestDocument()
original = test_text = doc1.string_attr = get_paragraph()
print(test_text)
test_text_words = test_text.split()
for x in range(10):
r1 = random.randint(0, len(test_text_words)-1)
r2 = random.randint(0, len(test_text_words)-1)
test_text = test_text.replace(test_text_words[r1],
test_text_words[r2])
diff = Diff()
diff.add_diff(doc1, 'string_attr', test_text)
print(diff.string_attr)
prev_text = diff.prev_version(doc1, 'string_attr')
assert prev_text[1][0] is True, "patch unsuccessful"
assert prev_text[0] == original, \
"reverted text does not match original"
def run(args):
settings = {
'host': args.host,
'database': args.database,
'username': args.username,
'password': args.password,
}
avenger = ""
avengers = ["Black Widow", "Jarvis", "Iron Man", "Thor", "Hulk",
"Captain America", "Hulk", "Nick Fury", "Pepper Potts", "Hawkeye",
"Luke Cage", "Falcon", "Scarlet Witch"]
try:
uri = "mongodb://{username}:{password}@{host}/{database}".format(**settings) if \
settings['username'] else "mongodb://{}/{}".format(settings['host'], settings['database'])
conn = pymongo.MongoClient(uri)
except Exception as ex:
print("Error: {}\ntraceback: {}".format(str(ex), traceback.format_exc()))
exit('Failed to connect, terminating.')
db = conn.random_data
while True:
if len(sys.argv) > 1:
avenger = sys.argv[1]
print("Using avenger: {}".format(avenger))
else:
avenger = random.choice(avengers)
doc = {
'timestamp': datetime.datetime.utcnow(),
'review_id': str(uuid.uuid1()),
'user_id': str(uuid.uuid1()),
'product_name': avenger,
'comment': get_paragraph(),
'cost': randint(1, 10),
'value': randint(1, 10),
'product_quality': randint(1, 10),
'up_votes': randint(1, 2000),
'down_votes': randint(1, 1000),
}
mongo_collection = 'Hulk'
print("{: <25} {: >20}".format(mongo_collection, db[mongo_collection].insert(doc)))
def generate_random_data():
from models import Area, User, Ticket, Note, TicketCloseReason
import random
import loremipsum
db.drop_all()
db.create_all()
areas = [
Area(name=u'CTO'),
Area(name=u'Network'),
Area(name=u'Infrastructure'),
Area(name=u'Devops'),
Area(name=u'Helpdesk'),
]
db.session.add_all(areas)
db.session.commit()
users = [
User(user='******', name=u'Bruno Bonagura', areas=areas, access_admin=True, access_reports=False),
]
users[0].set_password('ax886dds')
db.session.add_all(users)
reasons = [
TicketCloseReason(reason=u'Solved'),
TicketCloseReason(reason=u'False Alarm'),
TicketCloseReason(reason=u'Network failure'),
TicketCloseReason(reason=u'Misconfiguration'),
TicketCloseReason(reason=u'Remission')
]
db.session.add_all(reasons)
db.session.commit()
random.seed('oi')
for i in range(1, 100):
t = Ticket(
title = unicode(loremipsum.get_sentence()),
text = unicode(loremipsum.get_paragraph()),
current_area = random.choice(areas),
created_at = datetime.now() - timedelta(random.randint(1,100)),
created_by = random.choice(users),
)
t.add_note(random.choice(users), unicode(loremipsum.get_sentence()))
db.session.add(t)
db.session.commit()
def create_full_document(i):
document = create_simple_document(i)
headerImg = 'http://lorempixel.com/400/300/{}/{}'.format(
document['category'].lower(),
document['title'].replace('.', '').replace(' ', '%20'))
document['headerImg'] = headerImg
title_split = document['title'].split()
author = '{} {}'.format(title_split[0].title(),
title_split[1].title()).replace('.', '')
document['author'] = author
document['created'] = datetime.utcnow().isoformat()
document['text'] = ''
for _ in xrange(5):
document['text'] += '<p>{}</p>'.format(loremipsum.get_paragraph())
return document
def handle(self, *args, **options):
blog = options.get('blog')
quantity = options.get('quantity')
blog_models = import_module('blog.blog%s.models' % blog)
Post = blog_models.Post
users = list(User.objects.all())
categories = list(Category.objects.all())
posts = []
for i in range(int(quantity)):
amount = int(random.random() * 4) + 1
content = ' '.join(loremipsum.get_paragraphs(amount, True))
title = loremipsum.generate_sentence(True)[2]
posts.append(
Post.objects.create(
author=random.choice(users),
category=random.choice(categories),
title=title[:60],
content=content,
approved=random.random() < 0.8, # ~80% post approved
featured=random.random() < 0.1 # ~10% post approved
)
)
tags = list(Tag.objects.all())
for post in posts:
for i in range(int(random.random() * 4)):
comment = loremipsum.get_paragraph(True)
blog_models.PostComment.objects.create(
post=post,
user=random.choice(users),
comment=comment,
approved=random.random() < 0.8 # ~80% post approved
)
for tag in random.choices(tags, k=random.choice([2, 3, 4])):
post.tags.add(tag)
def sample_portfolio(self):
# Create portfolio
for i in range(1, 500):
default = {
'title':
' '.join(loremipsum.get_sentence(False).split(' ')[0:3]),
'description': loremipsum.get_paragraph(),
'id': i,
'url': 'http://portfolio%s.com' % i
}
portfolio, created = Portfolio.objects.get_or_create(
id=i, defaults=default)
if created:
total_image = randint(2, 4)
for j in range(total_image):
instance_save_image_from_url(
portfolio,
'http://lorempixel.com/430/320/technics/',
field_name='images',
append=True,
rand=True)
print 'Generated %s : %s' % ('portfolio', portfolio.title)
self.portfolio_list.append(portfolio)
Copyright 2013 James Brotchie <*****@*****.**>, @brotchie
"""
from loremipsum import get_sentence, get_paragraph, get_paragraphs
from random import randint, sample
TAGS = ['matlab', 'python', 'open source']
AUTHOR = 'Firstname Lastname <*****@*****.**>'
randyear = lambda: randint(2013, 2015)
randmonth = lambda: randint(1, 12)
randday = lambda: randint(1, 28)
randtitle = lambda: get_sentence(False)
randsummary = lambda: get_paragraph(False)
randtag = lambda: sample(TAGS, 1)[0]
randcontent = lambda: '\n\n'.join(get_paragraphs(randint(3,4)))
def generate_date():
return '{}-{:02}-{:02}'.format(randyear(), randmonth(), randday())
def generate_article():
title = randtitle()
slug = title.replace('.', '').replace(' ', '-')
info = dict(
title=title,
slug=slug,
date=generate_date(),
tags=randtag(),
author=AUTHOR,
def sample_organization(
self, type_of_organization=Organization.TYPE_SOCIAL_ENTERPRISE):
# Generate 30 se with lorempixel
for i in range(0, 60):
# randdom short or long name
if random.randrange(0, 2):
name = ''.join(
loremipsum.get_sentence(False).split(' ')
[0:random.randrange(2, 5)])
else:
name = ' '.join(
loremipsum.get_sentence(False).split(' ')
[0:random.randrange(3, 10)])
name = name.replace('.', '')
permalink = 'example-%s-%s' % (type_of_organization, i)
organization, created = Organization.objects.get_or_create(
permalink=permalink,
defaults={
'type_of_organization':
type_of_organization,
'created_by':
random.choice(self.user_list),
'name':
name,
'summary':
loremipsum.get_sentence(False),
'description':
''.join([
'<p>%s</p>' % loremipsum.get_paragraph(False)
for ignore in range(0, random.randrange(0, 5))
]),
'facebook_url':
'https://www.facebook.com/%s/' % permalink,
'twitter_url':
'https://www.twitter.com/%s/' % permalink,
'linkedin_url':
'https://www.linkedin.com/%s/' % permalink,
'homepage_url':
'https://www.homepage.com/%s/' % permalink,
'status':
STATUS_PUBLISHED
})
if created:
random.shuffle(self.user_list)
for user in self.user_list[0:random.randrange(0, 4)]:
organization.admins.add(user)
organization.country = random.choice(self.country_list)
random.shuffle(self.type_of_need_list)
for type_of_need in self.type_of_need_list[0:random.
randrange(0, 4)]:
organization.type_of_needs.add(type_of_need)
random.shuffle(self.topic_list)
for topic in self.topic_list[0:random.randrange(0, 4)]:
organization.topics.add(topic)
random.shuffle(self.type_of_support_list)
for type_of_support in self.type_of_support_list[
0:random.randrange(0, 4)]:
organization.type_of_supports.add(type_of_support)
instance_save_image_from_url(
organization,
'http://lorempixel.com/430/320/abstract/',
rand=True)
print 'Generated %s : %s' % (
organization.get_type_of_organization_display(),
organization.name)
self.organization_list.append(organization)
def test_get_paragraph(self):
"""Test loremipsum.get_paragraph function."""
self.assertIsInstance(loremipsum.get_paragraph(), self._unicode_str)
def test_get_paragraph(self):
"""Test loremipsum.get_paragraph function."""
self.assertIsInstance(loremipsum.get_paragraph(), self._unicode_str)
passphrase = "very insecure passphrase - never use it"
db = zerodb.DB(("localhost", 8001), username=username, password=passphrase)
# Everything we record should be within a transaction manager
# or be ended with transaction.commit()
with transaction.manager:
for i in range(400):
if (i % 100) == 0:
# Random text generation is slow, so we report
# about progress here
print(i)
e = models.Employee(name=names.get_first_name(),
surname=names.get_last_name(),
salary=random.randrange(200000),
description=loremipsum.get_paragraph(),
extra=loremipsum.get_sentence())
db.add(e) # Don't forget to add created object to the db
# One special record
desc = """A theoretical physicist, cosmologist,
author and Director of Research at the Centre for
Theoretical Cosmology within the University of Cambridge,
Stephen William Hawking resides in the United Kingdom."""
e = models.Employee(name="Stephen", surname="Hawking",
salary=400000,
description=desc)
db.add(e) # Don't forget to add created object to the db
# This is not really necessary
db.disconnect()
passphrase = "very insecure passphrase - never use it"
db = zerodb.DB(("localhost", 8001), username=username, password=passphrase)
# Everything we record should be within a transaction manager
# or be ended with transaction.commit()
with transaction.manager:
for i in range(400):
if (i % 100) == 0:
# Random text generation is slow, so we report
# about progress here
print(i)
e = models.Employee(name=names.get_first_name(),
surname=names.get_last_name(),
salary=random.randrange(200000),
description=loremipsum.get_paragraph(),
extra=loremipsum.get_sentence())
db.add(e) # Don't forget to add created object to the db
# One special record
desc = """A theoretical physicist, cosmologist,
author and Director of Research at the Centre for
Theoretical Cosmology within the University of Cambridge,
Stephen William Hawking resides in the United Kingdom."""
e = models.Employee(name="Stephen",
surname="Hawking",
salary=400000,
description=desc)
db.add(e) # Don't forget to add created object to the db
# This is not really necessary
def generate_presentation():
return random.choice([get_paragraph(), ''.join(get_sentences(2)), ''])
print "Error:", ex
exit('Failed to connect, terminating.')
db = conn.random_data
while True:
if len(sys.argv) > 1:
avenger = sys.argv[1]
else:
avenger = random.choice(avengers)
doc = {
'timestamp': datetime.datetime.utcnow(),
'review_id': str(uuid.uuid1()),
'user_id': str(uuid.uuid1()),
'product_name': avenger,
'comment': get_paragraph(),
'cost': randint(1, 10),
'value': randint(1, 10),
'product_quality': randint(1, 10),
'up_votes': randint(1, 2000),
'down_votes': randint(1, 1000),
}
mongo_collection = 'product_reviews'
print("{: <25} {: >20}".format(mongo_collection, db[mongo_collection].insert(doc)))
