def generate_body(nb_iterations):
return_array = []
for _ in range(nb_iterations):
return_array.append({"type": "heading", "value": lorem_ipsum.words(random.randint(2, 6), common=False)})
return_array.append({"type": "paragraph", "value": "<p>{}</p>".format(lorem_ipsum.paragraph())})
return_array.append({"type": "paragraph", "value": "<p>{}</p>".format(lorem_ipsum.paragraph())})
return return_array
def handle(self, *args, **options):
if len(args):
num_events = int(args[0])
else:
num_events = 10
self.stdout.write("Generating %i fake events for the next 5 days\n" % (num_events,))
today = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
for day in range(6):
for evtnum in range(num_events):
new_event = Event()
new_event.name = "{adj} {noun} {type}".format(
adj=random.choice(self._adjectives),
noun=random.choice(self._nouns),
type=random.choice(self._types),
)
new_event.start = today + datetime.timedelta(days=day, hours=8 + evtnum)
new_event.end = new_event.start + datetime.timedelta(minutes=30)
new_event.location = random.choice(self._locations)
new_event.description = lorem_ipsum.paragraph()
new_event.host = random.choice(self._hosts)
new_event.url = "http://aspc.pomona.edu/"
new_event.status = "approved"
new_event.save()
self.stdout.write("Saved event '%s'" % (new_event.name,))
def setUp(self):
super(CollectionRequestTestCase, self).setUp()
self.summon_alice()
self.summon_ziutek()
self.resource = self.create_resource(owner=self.alice)
self.resource2 = self.create_resource(owner=self.alice)
self.collection = self.create_collection(
owner=self.alice, resources=[self.resource, self.resource2])
self.research_project = self.create_research_project(owner=self.ziutek)
self.message = Message.objects.create(
subject=words(3),
text=paragraph(),
user_from=self.ziutek,
user_to=self.alice,
message_type=MessageType.COLLECTION_REQUEST)
self.collection_request = CollectionRequest.objects.create(
name='collection request',
project=self.research_project,
user=self.alice,
user_from=self.ziutek,
message=self.message)
self.collection_request.collections.add(self.collection)
def handle(self, **options):
if not User.objects.exists():
usernames = words(NUMBER_OF_USERS).split(" ")
User.objects.bulk_create([
User(username=username,
password=username,
email="*****@*****.**" % username) for username in usernames
])
if not Tag.objects.exists():
Tag.objects.bulk_create([Tag(name=word) for word in WORDS])
if not Post.objects.exists():
users = list(User.objects.all())
tags = list(Tag.objects.all())
for p in range(NUMBER_OF_POSTS):
post = Post.objects.create(
author=choice(users),
title=sentence(),
body="\n".join(paragraphs(randint(3, 5))),
thumbnail="http://test.com/test.jpg",
is_published=choice([True, True, False]),
)
post.tags.add(*sample(tags, randint(0, 10)))
post.liked_by.add(*sample(users, randint(0, 10)))
for i in range(comment_count()):
Comment.objects.create(
user=choice(users),
body=paragraph(),
post=post,
parent=None if random() < 0.5 or not post.is_published
else choice(post.comment_set.all() or [None]))
def handle(self, *args, **options):
if len(args):
num_events = int(args[0])
else:
num_events = 10
self.stdout.write('Generating %i fake events for the next 5 days\n' %
(num_events, ))
today = datetime.datetime.now().replace(hour=0,
minute=0,
second=0,
microsecond=0)
for day in range(6):
for evtnum in range(num_events):
new_event = Event()
new_event.name = "{adj} {noun} {type}".format(
adj=random.choice(self._adjectives),
noun=random.choice(self._nouns),
type=random.choice(self._types))
new_event.start = today + datetime.timedelta(days=day,
hours=8 + evtnum)
new_event.end = new_event.start + datetime.timedelta(
minutes=30)
new_event.location = random.choice(self._locations)
new_event.description = lorem_ipsum.paragraph()
new_event.host = random.choice(self._hosts)
new_event.url = "http://aspc.pomona.edu/"
new_event.status = 'approved'
new_event.save()
self.stdout.write("Saved event '%s'" % (new_event.name, ))
def create_some_posts(number):
for i in range(number):
post = Post()
post.title = 'Topic {}'.format(i)
post.text = lorem_ipsum.paragraph()
post.author = 'bog'
post.save()
def get_random_article():
""" Method returns random article dictionary with content, description and title. """
return {
'content': lorem.paragraph(),
'description': lorem.sentence(),
'title': lorem.words(count=4, common=False).capitalize(),
}
class EventFactory(Factory):
class Meta:
model = "events.Event"
strategy = factory.CREATE_STRATEGY
name = factory.Sequence(lambda n: "fossevent{}".format(n))
start_date = datetime.date.today()
end_date = start_date + datetime.timedelta(days=3)
description = lorem_ipsum.paragraph()
def create_messages(self):
users = [self.alice, self.eric, self.ziutek]
message_matrix = list(
itertools.product(users, MessageType.DICT_CHOICES.keys()))
for user, message_type in message_matrix:
Message.objects.create(subject=words(3),
text=paragraph(),
user_from=self.alice,
user_to=user)
def test_paragraph(self, mock_paragraph_randint, mock_choice, mock_sample):
"""paragraph() generates a single paragraph."""
# Make creating 2 sentences use 2 phrases.
mock_paragraph_randint.return_value = 2
mock_sample.return_value = ['exercitationem', 'perferendis']
mock_choice.return_value = '.'
value = paragraph()
self.assertEqual(mock_paragraph_randint.call_count, 7)
self.assertEqual(
value, ('Exercitationem perferendis, exercitationem perferendis. '
'Exercitationem perferendis, exercitationem perferendis.'))
def test_access_message_details(self):
"""User should not have access to other messsages"""
self.summon_ziutek()
self.summon_alice()
message = Message.objects.create(subject=words(3),
text=paragraph(),
user_from=self.ziutek,
user_to=self.alice)
url = message.get_absolute_url()
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
def test_paragraph(self, mock_paragraph_randint, mock_choice, mock_sample):
"""paragraph() generates a single paragraph."""
# Make creating 2 sentences use 2 phrases.
mock_paragraph_randint.return_value = 2
mock_sample.return_value = ['exercitationem', 'perferendis']
mock_choice.return_value = '.'
value = paragraph()
self.assertEqual(mock_paragraph_randint.call_count, 7)
self.assertEqual(value, (
'Exercitationem perferendis, exercitationem perferendis. '
'Exercitationem perferendis, exercitationem perferendis.'
))
def test_create_message_myself(self):
"""User cannot send message to himself"""
url = reverse('messaging:message_create')
self.login_alice()
response = self.client.post(url, {
'subject': words(4),
'user_to': self.alice.pk,
'text': paragraph()
})
self.assertFalse(Message.objects.exists())
self.assertEqual(response.status_code, 200)
form = response.context[-1]['form']
self.assertFalse(form.is_valid())
self.assertIn('user_to', form.errors)
def test_create_message(self):
"""Send message to another active user"""
url = reverse('messaging:message_create')
self.login_alice()
response = self.client.post(url, {
'subject': words(4),
'user_to': self.ziutek.pk,
'text': paragraph()
})
self.assertEqual(Message.objects.count(), 1)
message = Message.objects.all()[0]
self.assertEqual(response.status_code, 302)
self.assertTrue(response.has_header('location'))
self.assertTrue(response['location'].endswith(
message.get_absolute_url()))
self.assertEqual(message.user_from, self.alice)
self.assertEqual(message.user_to, self.ziutek)
self.assertEqual(message.message_type, MessageType.STANDARD)
self.assertIsNone(message.date_received)
def handle(self, **options):
models = [Model(text=paragraph()) for x in range(100)]
Model.objects.bulk_create(models)
models = [Model1(text=paragraph()) for x in range(100)]
Model1.objects.bulk_create(models)
def handle(self, *args, **options):
verbose = int(options.get('verbosity'))
interval = options.get('interval')
nstreams = options.get('nstreams')
types = options.get('types')
flush = options.get('flush')
demo = options.get('demo')
span = options.get('span')
norealtime = options.get('norealtime')
if nstreams is None and types is None and not demo and flush:
datastream.delete_streams()
return
elif flush:
raise base.CommandError("Do you really want to remove all datastream data from the database? Use only '--flush' parameter.")
if nstreams is None and types is None and not flush and demo:
types = DEMO_TYPE
if span == '':
span = DEMO_SPAN
elif demo:
raise base.CommandError("In demo mode other parameters are fixed.")
if nstreams is None and types is None:
nstreams = DEFAULT_NSTREAMS
if types and check_types.match(types):
types = split_types.findall(types)
if nstreams is not None and len(types) != nstreams:
raise base.CommandError("Number of stream types does not mach number of streams.")
nstreams = len(types)
elif types:
raise base.CommandError("Invalid stream types string. Must be a comma separated list of <int|float|enum>[(start,end)|(enum values)].")
streams = []
for i in range(nstreams):
if types is not None:
typ = types[i]
else:
typ = ('int', '')
if typ[0] == 'enum':
value_type = 'nominal'
downsamplers = ['count']
elif typ[0] == 'graph':
value_type = 'graph'
downsamplers = ['count']
else:
value_type = 'numeric'
downsamplers = datastream.backend.value_downsamplers
visualization_value_downsamplers = []
for downsampler in ['mean', 'min', 'max']:
if downsampler in downsamplers:
visualization_value_downsamplers.append(downsampler)
type_constructor, random_function, default_domain = TYPES[typ[0]]
domain = typ[1] or default_domain
domain_range = [type_constructor(d) for d in domain.split(',')]
stream_id = datastream.ensure_stream(
{'title': 'Stream %d' % i},
{
'description': lorem_ipsum.paragraph(),
'unit_description': 'random, domain: %s' % domain,
'stream_number': i,
'visualization': {
'type': 'state' if typ is 'enum' else 'line',
'hidden': True if typ is 'graph' else False,
'value_downsamplers': visualization_value_downsamplers,
'time_downsamplers': ['mean'],
'minimum': domain_range[0] if value_type == 'numeric' else None,
'maximum': domain_range[1] if value_type == 'numeric' else None,
},
},
downsamplers,
datastream.Granularity.Seconds,
value_type=value_type,
)
streams.append((stream_id, typ))
span = span.split(' ')
if len(span) == 1 and span[0]:
span = span[0]
for val, key in (('days', 'd'), ('hours', 'h'), ('minutes', 'm'), ('seconds', 's')):
if span[-1] == key:
try:
s = int(span[:-1])
except ValueError:
raise base.CommandError("Time span value must be an integer.")
span_to = datetime.datetime.now(pytz.utc)
last_timestamp = self.last_timestamp(streams)
span_from = max(
span_to - datetime.timedelta(**{val: s}),
last_timestamp + datetime.timedelta(seconds=interval)
)
break
else:
raise base.CommandError("Unknown time span unit '%s'." % span[-1])
elif len(span) == 2:
try:
# TODO: Support also timezone in the datetime format
span_from, span_to = [datetime.datetime.strptime(x, '%Y-%m-%dT%H:%M:%S') for x in span]
except ValueError:
raise base.CommandError("Use time format 'yyyy-mm-ddThh:mm:ss' (i.e. '2007-03-04T21:08:12').")
else:
raise base.CommandError("Invalid time span parameter. It should be one or two space-delimited values.")
if span_from is not None and span_to is not None and span_from <= span_to:
if verbose > 1:
td = span_to - span_from
self.stdout.write("Appending %d values from %s to %s.\n" % (((td.seconds + td.days * 24 * 3600) // interval * len(streams)), span_from, span_to))
while span_from <= span_to:
for stream_id, (typ, domain) in streams:
type_constructor, random_function, default_domain = TYPES[typ]
value = random_function(*[type_constructor(d) for d in (domain or default_domain).split(',')])
datastream.append(stream_id, value, span_from)
span_from += datetime.timedelta(seconds=interval)
if verbose > 1:
self.stdout.write("Done. Downsampling.\n")
datastream.downsample_streams(until=span_to)
if norealtime:
return
if verbose > 1:
self.stdout.write("Appending real-time value(s) to stream(s) every %s seconds.\n" % interval)
while True:
for stream_id, (typ, domain) in streams:
type_constructor, random_function, default_domain = TYPES[typ]
value = random_function(*[type_constructor(d) for d in (domain or default_domain).split(',')])
if verbose > 1:
self.stdout.write("Appending value '%s' to stream '%s'.\n" % (value, stream_id))
datastream.append(stream_id, value)
datastream.downsample_streams()
time.sleep(interval)
