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)