def test_language_code(self): from faker.providers.misc import Provider for _ in range(99): language_code = Provider.language_code() self.assertTrue(isinstance(language_code, string_types)) Factory.create(locale=language_code)
def handle(self, *args, **options): fake = Factory.create() fakeru = Factory.create('ru_RU') number = int(options['number']) for i in range(0, number): profile = fake.simple_profile() u = User() u.username = profile['username'] u.first_name = fakeru.first_name() u.last_name = fakeru.last_name() u.email = profile['mail'] u.password = make_password('tp2015') u.is_active = True u.is_superuser = False u.save() up = Profile() up.user = u up.info = '%s [%s]' % (fakeru.company(), fakeru.catch_phrase()) image_url = 'http://api.adorable.io/avatars/100/%s.png' % u.username content = urllib.urlretrieve(image_url) up.avatar.save('%s.png' % u.username, File(open(content[0])), save=True) up.save() self.stdout.write('[%d] added user %s' % (u.id, u.username))
def generate_fake(): from sqlalchemy.exc import IntegrityError from random import seed, randint from faker import Factory fake = Factory.create() inside_fake = Factory.create('zh_CN') start = datetime.now() - timedelta(days=1) seed() for i in range(50): name = fake.user_name()[:8] u = User(id=10 + i, username=name, role_id=3, password=name, email='{0}@gmail.com'.format(name), sign_up_time=start + timedelta(minutes=randint(1, 10)), city=inside_fake.city_name(), email_confirmed=1, avatar_extension='png', github=name, website='https://{0}.com'.format(name), email_private=0) db.session.add(u) try: db.session.commit() except: db.session.rollback()
def test_prefix_suffix_always_string(self): # Locales known to contain `*_male` and `*_female`. for locale in ("bg_BG", "dk_DK", "en", "ru_RU", "tr_TR"): f = Factory.create(locale=locale) for x in range(20): # Probabilistic testing. assert isinstance(f.prefix(), string_types) assert isinstance(f.suffix(), string_types)
def init(is_reset=True, is_dir_clean=True): if is_reset: call_command('reset_db', interactive=0) if is_dir_clean: for dir2clean in ['cache', 'infoimage', 'fact', 'news']: dir2clean = os.path.join(settings.BASE_DIR, 'media', dir2clean) if os.path.exists(dir2clean): shutil.rmtree(dir2clean) call_command('makemigrations') call_command('migrate') admin = G(User, username='******', is_active=True, is_staff=True, is_superuser=True) admin.set_password('hello') admin.save() fake = Factory.create() for i in xrange(20): G(fbask_models.Author, first_name=fake.first_name(), last_name=fake.last_name()) G(fbask_models.Article, title=fake.company(), content=fake.address())
def create_random_student(cls): """Fill database with random student""" fake = Factory.create('uk_UA') groups = ["ІН", "ПМ", "КІ", "КН", "АУТП"] random_grade = random.randint(1, 5) if random.choice([True, False]): Student.create( last_name=fake.last_name(), first_name=fake.first_name_male(), patronymic=fake.first_name_male() + "ович", group="{}-{}{}".format( random.choice(groups), random_grade, random.randint(1, 3) ), grade=random_grade ) else: Student.create( last_name=fake.last_name(), first_name=fake.first_name_female(), patronymic=fake.first_name_male() + "івна", group="{}-{}{}".format( random.choice(groups), random_grade, random.randint(1, 3) ), grade=random_grade )
def generate_users(self,user_count): fake = Factory.create() users = [] for i in range(1,user_count): user = User(fake.email(),fake.name(),'welcome',True) users.append(user]) return users
def set_zip(self): fake = Factory.create() # Create data for zip code in address for i in range( 1, len( self.f_name ) ): zip_temp = fake.zipcode() self.zip.append( zip_temp.encode( 'ascii' ) )
def set_phone2(self): fake=Factory.create() # Create data for phone2 for i in range( 1, len( self.f_name ) ): phone2_temp = fake.phone_number() self.phone2.append( phone2_temp.encode( 'ascii' ) )
def make_shell_context(): from modularodm import Q from framework.auth import User, Auth from framework.mongo import database from website.app import init_app from website.project.model import Node from website import models # all models from website import settings import requests app = init_app() context = { 'app': app, 'db': database, 'User': User, 'Auth': Auth, 'Node': Node, 'Q': Q, 'models': models, 'run_tests': test, 'rget': requests.get, 'rpost': requests.post, 'rdelete': requests.delete, 'rput': requests.put, 'settings': settings, } try: # Add a fake factory for generating fake names, emails, etc. from faker import Factory fake = Factory.create() context['fake'] = fake except ImportError: pass return context
def set_street(self): fake = Factory.create() # Create data for street name in address for i in range( 1, len( self.f_name ) ): street_temp = fake.street_address() self.street.append( street_temp.encode( 'ascii' ) )
def fake_xmi(): faker = FFactory.create() for i in range(NUM_SAMPLES): PERSONS.append( TEMPLATE_PERSON.format( faker.first_name(), faker.last_name(), "MALE" if faker.boolean() is True else "FEMALE", faker.boolean(), faker.iso8601(), faker.street_name(), faker.building_number(), faker.postcode(), faker.city(), random.randint(0, NUM_COUNTRIES - 1) ) ) for i in range(NUM_COUNTRIES): COUNTRIES.append( TEMPLATE_COUNTRY.format(faker.country()) ) with open(OUTFILE, "w") as text_file: text_file.write( TEMPLATE.format( os.linesep.join( [os.linesep.join(PERSONS), os.linesep.join(COUNTRIES)] ) ) )
def generate_fake(count=50): from sqlalchemy.exc import IntegrityError from random import seed, randint from faker import Factory fake = Factory.create() seed() user_count = User.query.count() tag_count = Tag.query.count() category_count = Category.query.count() for i in range(count): u = User.query.offset(randint(0, user_count-1)).first() t = Tag.query.offset(randint(0, tag_count-1)).first() c = Category.query.offset(randint(0, category_count-1)).first() post = Post(title=fake.word(), slug=fake.word(), md_text=fake.paragraph(), content=fake.paragraph(), pub_date=fake.date_time(), modify_date=fake.date_time(), category_id=c.id, author_id=u.id, tags_name="python" ) db.session.add(post) try: db.session.commit() except IntegrityError: db.session.rollback()
def seed_from_fake(): "This seeds a DB with fake text, using the faker" # create a fake factory fake = Factory.create() # print is as sanity check print(fake.text()) # open or make text file text_file = open("Output.txt", "w") # 50 times for i in range(50): # make some fake text fake_text = fake.text() # this just gives stupid text # # print fake text # print(fake_text[:49]) # # print seperator # print("_____________") # make new post # split the text up to make a title and post title = fake_text[:49] text = fake_text post = Post(title=fake_text, text=text) post.save()
def write_text_seed_file(): "this creates a file with random fake text" fake = Factory.create() # print is as sanity check print(fake.text()) # open or make text file text_file = open("Output.txt", "w") # 50 times for i in range(50): # make some fake text fake_text = fake.text() # # print fake text # print(fake_text[:49]) # # print seperator # print("_____________") # make new post title = fake_text[:49] text = fake_text line = title + "\t" + text + "\n" text_file.write(line) text_file.close()
def make(): fake = Factory.create() years = range(1970, 2015) first = fake.first_name() last = fake.last_name() email = '{0}{1}{2}@{3}'.format(first, last, random.choice(years), fake.domain_name()) return email, first, last
def test_crear_una_nueva_pizarra_y_guardarla_en_la_bd(self): faker = Factory.create() nombrepiz = faker.word() descripcionpiz = faker.sentence() now = date.today() fechacreacion = now fechafinal = now.replace(day = now.day+1) logindueno = User.objects.get(username = '******') avancepiz = faker.randomInt(0,99) num_pizarras_old = len(Pizarra.objects.all()) CreadorPizarra( nombrepiz = nombrepiz, descripcionpiz = descripcionpiz, fechacreacion = fechacreacion, fechafinal = fechafinal, usuario = logindueno ) pizarras_new = Pizarra.objects.all() self.assertEquals(len(pizarras_new), num_pizarras_old + 1)
def make_shell_context(): from modularodm import Q from framework.auth import User, Auth from framework.mongo import database from website.app import init_app from website.project.model import Node from website import models # all models from website import settings import requests app = init_app() context = { "app": app, "db": database, "User": User, "Auth": Auth, "Node": Node, "Q": Q, "models": models, "run_tests": test, "rget": requests.get, "rpost": requests.post, "rdelete": requests.delete, "rput": requests.put, "settings": settings, } try: # Add a fake factory for generating fake names, emails, etc. from faker import Factory fake = Factory.create() context["fake"] = fake except ImportError: pass return context
def handle(self, *args, **options): fake = Factory.create() number = int(options['number']) users = User.objects.all()[1:] starts = ( u'Help! Nothing happens!', u'I tried all, help', u'I do not find any solutions on the Internet, save', u'Following problem:', u'I think that someone of you faced with the question', u'Sorry, but I am a novice in this matters', u'Hi! Dates burn, need advice', ) for i in range(0, number): q = Question() q.title = fake.sentence(nb_words=randint(4, 6), variable_nb_words=True) q.text = u"%s %s %s" % ( choice(starts), os.linesep, fake.paragraph(nb_sentences=randint(4, 17), variable_nb_sentences=True), ) q.author = choice(users) q.save() self.stdout.write('added question [%d]' % (q.id))
def __init__(self, county = 'zh_CN'): self.fake = Factory.create(county) self.img = DBHelperUtils().get_imgs() self.img_size = len(self.img) self.data_format = { "用户名":"USER_NAME", "照片":"IMAGE", "邮箱":"EMAIL", "城市":"CITY", "字符串":"TEXT", "时间戳":"TIME", "错误代码":"ERR_CODE", "单词":"WORD", "ID":"ID", "对象":"OBJ" } self.erro_code_list = [ 0, 60501, 605002, 605003, 401003, ]
def main(): # Set locale to the United States for US-formatted Social Security Numbers locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') # Create faker factory instance faker = Factory.create() # The number of rows in the resulting CSV num_fake_records = 1000 # Download the field names from Google Sheets in XLSX format google_sheet = pd.read_excel('https://docs.google.com/spreadsheets/d/' + '1bloqWcGFOmFLJ98iYFAEX5PDZWpqBI722-qZVyekZuU' + '/export?format=xlsx', sheetname=None) # If a field doesn't have weights, add 1s as weights # functionally, this will give each class equal weight for field, df in google_sheet.iteritems(): google_sheet[field] = google_sheet[field].fillna(1) # Create the dataframe with dummy data dummy_data = pd.DataFrame([fake_record(google_sheet, faker) for _ in range(num_fake_records)]) # Output and save data print dummy_data.head() output_file = 'dummy_data.csv' dummy_data.to_csv(output_file, index=False) print '\nDummy data saved to: ' + output_file
def setUp(self): self._client = BaoquanClient() self._client.host = 'http://localhost:8080' self._client.access_key = 'fsBswNzfECKZH9aWyh47fc' self._client.pem_path = os.path.dirname(__file__) + '/resources/private_key.pem' self._faker = Factory.create('zh_CN')
def admin_populate_user(): # Create a fake instance fake = Factory.create() form_user = PopulateUserForm() if form_user.validate_on_submit(): user_dbs = [] nr = form_user.number_of_users.data if nr > 1000: flask.flash('You cannot create more than 1000 new users at once. Try again!',\ category='danger') return flask.redirect(flask.url_for('admin_populate')) for i in range(nr): user = fake.profile(fields=['name','username','mail']) user_dbs.append(model.User(name=user['name'],\ username=user['username'], email=user['mail'], active=_return_state(form_user.active.data), admin=_return_state(form_user.admin.data), verified=_return_state(form_user.verified.data))) keys = ndb.put_multi(user_dbs) for key in keys: # run the new user function auth.new_user(key) flask.flash('Created {nr} new users'.\ format(nr=len(user_dbs)), category='success') return flask.redirect(flask.url_for('admin_populate'))
def test_mount_the_caching_adapters_on_https(case): faker = Factory.create() url = faker.uri() sut = JoolaBaseClient(url) case.assertIn("https://", sut.session.adapters) case.assertIsInstance(sut.session.adapters["https://"], CachingHTTPAdapter)
def admin_populate_tag(): form_tag = PopulateTagForm() if form_tag.validate_on_submit() or True: if form_tag.random_tags.data: if form_tag.max_tags.data > 500: flask.flash('Not more than 500 random tags can be created at once. Try again!',\ category='danger') return flask.redirect(flask.url_for('admin_populate')) fake = Factory.create() tags = fake.words(nb=form_tag.max_tags.data) else: tags = form_tag.tags.data.split(', ') # Are icon needed as well? if form_tag.icon.data: icon_keys, _ = model.Icon.get_dbs(keys_only=True,limit=2000, collection=model.Collection.top_key()) else: icon_keys = None cnt = 0 incr = True if form_tag.incr.data=='true' else False for tag in tags: icon_key = random.choice(icon_keys) if icon_keys else None model.Tag.add(tag,auto_incr=incr,icon_key=icon_key) cnt += 1 flask.flash('Added {nr} tags'.\ format(nr=cnt), category='success') return flask.redirect(flask.url_for('admin_populate'))
def setUp(self): self.faker = Factory.create() self.portal = self.layer['portal'] self.util = getUtility(ITodoUtility) self.user1 = api.user.create( email=self.faker.company_email(), username='******' ) self.user2 = api.user.create( email=self.faker.company_email(), username='******' ) self.all_userids = { self.user1.getId(), self.user2.getId(), 'admin', 'test_user_1_', } self.doc1 = api.content.create( container=self.portal, type='Document', id='doc1', title='Doc 1' ) self.doc2 = api.content.create( container=self.portal, type='Document', id='doc2', title='Doc 2' )
def test_select_the_api_token_authentication_mechanism_if_an_api_token_was_provided(case): faker = Factory.create() url = faker.uri() api_token = faker.sha256() sut = JoolaBaseClient(url, api_token=api_token) case.assertIsInstance(sut.session.auth, APITokenAuth)
def handle(self, *args, **options): try: fake_bans_to_create = int(args[0]) except IndexError: fake_bans_to_create = 5 except ValueError: self.stderr.write("\nOptional argument should be integer.") sys.exit(1) fake = Factory.create() ban_fakers = (get_fake_username_ban, get_fake_email_ban, get_fake_ip_ban) message = "Creating %s fake bans...\n" self.stdout.write(message % fake_bans_to_create) created_count = 0 show_progress(self, created_count, fake_bans_to_create) for _ in range(fake_bans_to_create): ban_faker = random.choice(ban_fakers) ban_faker(fake) created_count += 1 show_progress(self, created_count, fake_bans_to_create) Ban.objects.invalidate_cache() message = "\n\nSuccessfully created %s fake bans" self.stdout.write(message % created_count)
def handle(self, *args, **options): fake = Factory.create() number = int(options['number']) users = User.objects.all()[1:] starts = ( u'Помогите! Ничего не получается!!!!', u'Я перепробовал всё, помогите.', u'Не нашел ни одного решения в интернете, спасите!!', u'Проблема следующая:', u'Уже третий день не сплю из-за возникшей проблемы', u'Я думаю, что кто-то из вас сталкивался с таким вопросом', u'Извините, я новичок в вопросах веба.', u'Привет всем! Сроки горят, нужна консультация.', u'Ненавижу Винду', u'Нашел косяк в исходниках MySQL 5.6' ) for i in range(0, number): q = Question() q.title = fake.sentence(nb_words=randint(4, 6), variable_nb_words=True) q.text = u"%s %s %s" % ( choice(starts), os.linesep, fake.paragraph(nb_sentences=randint(4, 17), variable_nb_sentences=True), ) q.author = choice(users) q.save() self.stdout.write('added question [%d]' % (q.id))
def read_users(zfp): fp = zfp.open("ml-100k/u.user") users = read_csv(fp, sep="|", header=None, names=["id", "age", "gender", "occupation", "zip"], index_col=0) f = Factory.create() names = ["Jon Haddad", "Dani Traphagen", "Patrick McFadin", "Mark Quinsland", "Brian Hess", "Russell Spitzer", "Lorina Poland", "Tim Berglund", "Tupshin Harper", "Al Tobey"] names.reverse() def get_name(row): if names: return names.pop() return f.name() users['name'] = users.apply(get_name, axis=1) users['city'] = users.apply(lambda row: f.city(), axis=1) users['address'] = users.apply(lambda row: f.street_address(), axis=1) users['uuid'] = users.apply(lambda _: uuid.uuid4(), axis=1) return users
import random from faker import Factory, Faker #gerar nomes em pt-br fake = Factory.create('pt_PT') f = Faker() arq = open('cliente.csv', 'w') txt = [] txt.append('nome' + ';' + 'idade\n') for i in range(100000): idade = random.randint(12, 70) txt.append(fake.name() + ' ' + f.name() + ';' + str(idade) + '\n') arq.writelines(txt) arq.close()
#!/usr/bin/python import csv import random from faker import Factory records = 10000 fieldnames=['id','name','age','address','currency',] writer = csv.DictWriter(open("10k_people.csv", "w"), fieldnames=fieldnames) #write header row writer.writerow(dict(zip(fieldnames, fieldnames))) fake = Factory.create("en_US") for i in range(0, records): writer.writerow(dict([ ('id', str(random.randint(0,40000))), ('name', fake.name()), ('age', str(random.randint(18,120))), ('address', fake.street_address()), ('currency', fake.currency_code())]))
def setUp(self): self.factory = Factory.create('ar_AA') self.provider = self.factory.provider('faker.providers.internet')
def setUp(self): PrivTestCase.setUp(self) self.fake = Factory.create('ru_RU')
# -*- coding: utf-8 -*- from datetime import datetime, timedelta from unittest import TestCase from faker import Factory from popolo.utils import PartialDate, PartialDateException, PartialDatesInterval faker = Factory.create('it_IT') # a factory to create fake names for tests class PartialDateTestCase(TestCase): def create_instance(self, ds=None, pattern=PartialDate.d_fmt): if not ds: ds = faker.date(pattern=pattern) return PartialDate(ds) def test_new_instance(self): ds = faker.date(PartialDate.d_fmt) d = self.create_instance(ds) self.assertEqual(isinstance(d.date, str), True) self.assertEqual(isinstance(d.date_as_dt, datetime), True) def test_new_instance_using_d_fmt(self): ds = faker.date(PartialDate.d_fmt) d = self.create_instance(ds) self.assertEqual(d.date, ds) self.assertEqual( d.date_as_dt, datetime.strptime(ds, PartialDate.d_fmt)
from django.test import TestCase, Client from django.contrib.auth.models import User from blog.factories import BlogPostFactory, TagFactory from blog.models import BlogPost from faker import Factory faker = Factory.create() class QuerySetTests(TestCase): def setUp(self): self.tag = TagFactory() self.blog_post = BlogPostFactory() self.client = Client() self.user = User.objects.create_user(username=faker.name(), password='******') def test_blog_post_public_queryset(self): self.assertEqual(self.blog_post, BlogPost.objects.get_public_posts().first()) def test_blog_post_private_queryset(self): self.assertEqual(self.blog_post, BlogPost.objects.get_private_posts().first()) def test_blog_post_public_queryset_if_not_logged_user(self): self.assertEqual(1, BlogPost.objects.count()) response = self.client.post('/create-new-post/', data={
from faker import Factory from nameko.events import EventDispatcher from nameko.timer import timer fake = Factory.create() class PaymentService(object): name = "payments" dispatch = EventDispatcher() @timer(interval=10) def emit_event(self): payload = { 'client': { 'name': fake.name(), 'email': fake.safe_email() }, 'payee': { 'name': fake.name(), 'email': fake.safe_email() }, 'payment': { 'amount': fake.random_int(), 'currency': fake.random_element(("USD", "GBP", "EUR")) } } self.dispatch("payment_received", payload)
class TestCase(FlaskTestCase): # Expose faker since it should be easy to use fake = Factory.create() def create_app(self): oauth.remote_apps = {} # The testing configuration is inferred from the production # settings, but it can only be derived after the config files # have actually been evaluated. settings.APP_NAME = APP_NAME settings.TESTING = True settings.DEBUG = True settings.CACHE = True settings.SECRET_KEY = 'batman' settings.APP_UI_URL = UI_URL settings.ARCHIVE_TYPE = 'file' settings.ARCHIVE_PATH = self.temp_dir settings.DATABASE_URI = DB_URI settings.QUEUE = False settings.MAIL_SERVER = None app = create_app({}) mount_app_blueprints(app) return app def create_user(self, foreign_id='tester', name=None, email=None, is_admin=False): role = Role.load_or_create(foreign_id, Role.USER, name or foreign_id, email=email or self.fake.email(), is_admin=is_admin) db.session.commit() return role def login(self, foreign_id='tester', name=None, email=None, is_admin=False): role = self.create_user(foreign_id=foreign_id, name=name, email=email, is_admin=is_admin) headers = {'Authorization': role.api_key} return role, headers def create_collection(self, creator=None, **kwargs): collection = Collection.create(kwargs, role=creator) db.session.add(collection) db.session.commit() update_collection(collection) return collection def grant(self, collection, role, read, write): Permission.grant(collection, role, read, write) db.session.commit() update_collection(collection) def flush_index(self): flush_index() def get_fixture_path(self, file_name): return os.path.abspath(os.path.join(FIXTURES, file_name)) def load_fixtures(self, file_name, process_documents=True): filepath = self.get_fixture_path(file_name) load_fixtures(db, loaders.load(filepath)) db.session.commit() reindex_entities() if process_documents: for doc in Document.all(): process_document(doc) self.flush_index() def setUp(self): if not hasattr(TestCase, '_global_test_state'): TestCase._global_test_state = True delete_index() upgrade_search() else: indexes = [collection_index(), entity_index(), record_index()] es.delete_by_query(index=indexes, body={'query': { 'match_all': {} }}, refresh=True, conflicts='proceed') db.drop_all() db.create_all() create_system_roles() def tearDown(self): db.session.close() @classmethod def setUpClass(cls): cls.temp_dir = mkdtemp() try: os.makedirs(cls.temp_dir) except Exception: pass @classmethod def tearDownClass(cls): shutil.rmtree(cls.temp_dir)
from faker import Factory as FakerFactory from rest_framework.test import APITestCase from rest_framework import status try: from django.core.urlresolvers import reverse except ImportError: from django.urls import reverse from django.contrib.auth import get_user_model from exo_messages.models import Message from exo_messages.conf import settings from .faker_factories import FakeUserFactory faker = FakerFactory.create( getattr(settings, 'FAKER_SETTINGS_LOCALE', 'en_GB')) User = get_user_model() class ExoMessageTest(APITestCase): def test_user_messages_marked_as_read_after_login(self): # PREPARE DATA user = FakeUserFactory.create() user.set_password('123456') user.save() Message.objects.create_message( user=user, code=settings.EXO_MESSAGES_CH_CODE_VALIDATED_EMAIL, level=settings.EXO_MESSAGES_CH_SUCCESS, read_when_login=True,
import re import rootfs_boot from devices import board, wan, lan, prompt from random import randint import ipaddress from faker import Factory import pexpect import re import time import random fake_generator = Factory.create() class SoCat(rootfs_boot.RootFSBootTest): '''Super simple simulatation of HTTP traffic''' all_ips = [] all_conns = [] conns = 100 socat_recv = "TCP-LISTEN" socat_send = "TCP" payload = '"GET / HTTP/1.0\\r\\n\\r\\n"' def startSingleFlow(self, mintime=1, maxtime=60): while True: random_ip = fake_generator.ipv4() random_port = randint(1024, 65535)
from faker import Factory from homes_for_sale.models import SaleFeature from homes_for_sale.factories.sale_factory import SaleFactory import factory fake = Factory.create('en_GB') class SaleFeatureFactory(factory.DjangoModelFactory): class Meta: model = SaleFeature property = factory.SubFactory(SaleFactory) text = fake.text(10) display_order = 1
from django.test import Client, TestCase from django.contrib.auth.models import User from imager_images.models import Photo, Album import factory from faker import Factory as FakeFaker from django.conf import settings import os from django.core import mail import re fake = FakeFaker.create() class PhotoFactory(factory.Factory): class Meta: model = Photo title = fake.sentence() description = fake.paragraph() class AlbumFactory(factory.Factory): class Meta: model = Album title = fake.sentence() description = fake.paragraph() class UserFactory(factory.Factory): class Meta:
def setup_class(cls): cls.client = app.test_client() cls.fake = Factory.create()
from faker import Factory from faker import Faker import sys import os import random import time fake = Faker() fake = Factory.create('pt_BR') schema = "'public'" #para o projeto usando entity framework utilize => dbo QTD_MARCA = 10 QTD_TIPO_MEDIDA = 10 QTD_PAIS = 11 QTD_ESTADO = 12 QTD_CIDADE = 100 QTD_ENDERECO = 1000 QTD_ESTABLECIMENTO = 10 QTD_PESSOA = 5000 #QTD_CONSUMIDOR = 2000; #QUANTIDADE DE PESSOA E CONSUMIDOR DEVEM SER A MESMA QTD_LISTA_COMPRA = 100 QTD_PRODUTO = 18 QTD_COMPRA = 40 #Valor maximo aleatorio por Pessoa QTD_QUANTIDADE_PRODUTO_LISTA = 15 QTD_LISTA_COMPRA_PRODUTO = 0 def main():
from contextlib import contextmanager from unittest import mock from django.core.exceptions import ImproperlyConfigured from django.http import Http404 from django.shortcuts import reverse from django.test import SimpleTestCase from faker import Factory from influencetx.openstates import factories, views from influencetx.testing.view_utils import render_view, response_from_view FAKE = Factory.create() def test_index_view(): html = render_view('openstates:index') assert reverse('openstates:legislator-list') in html assert reverse('openstates:bill-list') in html def test_api_key_required_view(): html = render_view('openstates:api-key-required') assert 'https://openstates.org/api/register/' in html class BaseOpenStatesAPITestCase(SimpleTestCase): def assert_fetch_redirects(self, view_name, args=None, kwargs=None): """Assert view redirects to error page when api-key is missing and in debug mode.""" response = response_from_view(view_name, args=args, kwargs=kwargs) self.assertRedirects(response, reverse('openstates:api-key-required'))
def __init__(self, id=None, from_ip=None, from_hostname=None, from_heloname=None, enveloppe_sender=None, enveloppe_recipients=[], sender=None, recipients=[], body=None, subject=None, random_files=0, is_multipart=False, is_bounce=False, filter_status=None, min_size=0, sent_date=None, lang=None, charset='utf-8', domains=[], mynetworks=[]): self.id = id or generate_key() self.lang = lang or DEFAULT_LANG self.faker = Factory.create(self.lang) self.charset = charset if mynetworks and len(mynetworks) > 0: self.from_ip = random.choice([self.faker.ipv4()] + mynetworks) else: self.from_ip = from_ip or self.faker.ipv4() self.is_out = True if self.from_ip in mynetworks else False self.from_hostname = from_hostname or "mx.%s" % self.faker.domain_name( ) self.from_heloname = from_heloname or self.from_hostname self.is_bounce = random.choice([False, False, True, False, False]) if domains and len(domains) > 0: if self.is_out: self.enveloppe_sender = "%s@%s" % (self.faker.user_name(), random.choice(domains)) self.enveloppe_recipients = enveloppe_recipients or [ self.faker.email() ] else: self.enveloppe_sender = enveloppe_sender or self.faker.email() self.enveloppe_recipients = [ "%s@%s" % (self.faker.user_name(), random.choice(domains)) ] else: self.enveloppe_sender = enveloppe_sender or self.faker.email() self.enveloppe_recipients = enveloppe_recipients or [ self.faker.email() ] if self.is_bounce: self.sender = "<>" else: self.sender = sender or '"%s" <%s>' % (self.faker.name(), self.enveloppe_sender) self.recipients = recipients if not recipients or len(recipients) == 0: self.recipients = [] for r in self.enveloppe_recipients: _r = '"%s" <%s>' % (self.faker.name(), r) self.recipients.append(_r) self.min_size = min_size self.body = body or self.faker.text() self.subject = subject or self.faker.paragraph() self.random_files = random_files self.is_multipart = is_multipart if self.random_files > 0: self.is_multipart = True self.filter_status = filter_status or random.choice( FILTER_STATUS_CHOICES) if self.min_size > 0 and len(self.body) < self.min_size: _body = [] while len(" ".join(_body)) < self.min_size: _body.append(self.body) self.body = " ".join(_body) self.sent_date = None if sent_date: self.sent_date = arrow.get(sent_date).datetime else: self.sent_date = arrow.utcnow().datetime
def setUpClass(cls): """Set up faker and lessons list.""" cls.faker = Factory.create() super(SubjectExecTestCase, cls).setUpClass()
def handle(self, *args, **options): items_to_create = options['categories'] min_level = options['minlevel'] categories = Category.objects.all_categories(True) copy_acl_from = list(Category.objects.all_categories())[0] categories = categories.filter(level__gte=min_level) fake = Factory.create() message = 'Creating %s fake categories...\n' self.stdout.write(message % items_to_create) message = '\n\nSuccessfully created %s fake categories in %s' created_count = 0 start_time = time.time() show_progress(self, created_count, items_to_create) while created_count < items_to_create: parent = random.choice(categories) new_category = Category() if random.randint(1, 100) > 75: new_category.set_name(fake.catch_phrase().title()) else: new_category.set_name(fake.street_name()) if random.randint(1, 100) > 50: if random.randint(1, 100) > 80: new_category.description = '\r\n'.join(fake.paragraphs()) else: new_category.description = fake.paragraph() new_category.insert_at( parent, position='last-child', save=True, ) copied_acls = [] for acl in copy_acl_from.category_role_set.all(): copied_acls.append( RoleCategoryACL( role_id=acl.role_id, category=new_category, category_role_id=acl.category_role_id, )) if copied_acls: RoleCategoryACL.objects.bulk_create(copied_acls) created_count += 1 show_progress(self, created_count, items_to_create, start_time) acl_version.invalidate() total_time = time.time() - start_time total_humanized = time.strftime('%H:%M:%S', time.gmtime(total_time)) self.stdout.write(message % (created_count, total_humanized))
def faker(): return Factory.create('ja_JP')
#!/usr/bin/env python # -*- coding: utf-8 -*- import argparse import random import datetime import math from faker import Factory import pymongo from models import User, Movie, Comment, ChargeRecord, ConsumeRecord, MoviePrice, Reply from models import db fake = Factory.create('zh_CN') def get_mongo_cursor(): client = pymongo.MongoClient('docker') db = client['bt0_movie'] cursor = db.bt0_movie.find() return cursor def gen_users(amount=50): for i in range(amount): u = User(username=fake.name(), password='******') u.phone_number = fake.phone_number() u.avatar = 'http://opsfsk07z.bkt.clouddn.com/avatar-{}.jpg'.format( random.choice(range(50))) db.session.add(u)
def __init__(self): self.fake = Factory.create() self.ips = [self.fake.ipv4() for i in range(100)] self.macs = [self.fake.mac_address() for i in range(100)]
def setUpClass(cls): """Set up faker and lessons list.""" super(GetIndexPageTestCase, cls).setUpClass() cls.faker = Factory.create()
BOT_NAME = 'douban' SPIDER_MODULES = ['douban.spiders'] NEWSPIDER_MODULE = 'douban.spiders' from faker import Factory f = Factory.create() USER_AGENT = f.user_agent() ROBOTSTXT_OBEY = True DEFAULT_REQUEST_HEADERS = { 'Host': 'book.douban.com', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3', 'Accept-Encoding': 'gzip, deflate, br', 'Connection': 'keep-alive', } ITEM_PIPELINES = { 'douban.pipelines.DoubanBookPipeline': 300, }
def __init__(self, **kwargs): super().__init__(**kwargs) self.tableName = "" self.fake = Factory.create()
def test_words_valueerror(self): f = Factory.create() self.assertRaises(ValueError, f.text, max_nb_chars=4)
from datetime import datetime from dateutil.relativedelta import relativedelta import random import csv import sys from faker import Factory fake_fr = Factory.create('fr_FR') from mimesis import Person, Address import mimesis.enums import logging import pandas as pd def main(): try: num_gen = int(sys.argv[1]) except: num_gen = -1 if len(sys.argv) < 2 or num_gen == -1: print( "Usage: python faker_customers_to_csv.py <INT: Number of Customers to generate>" ) print("Exymple: python faker_customers_to_csv.py 10000") return # Generate Customers that are between 18 and 100 years old
def handle(self, *args, **options): # pylint: disable=too-many-locals, too-many-branches items_to_create = options["threads"] fake = Factory.create() categories = list(Category.objects.all_categories()) message = "Creating %s fake threads...\n" self.stdout.write(message % items_to_create) created_threads = 0 start_time = time.time() show_progress(self, created_threads, items_to_create) while created_threads < items_to_create: category = random.choice(categories) # 10% chance thread poster is anonymous if random.randint(0, 100) > 90: starter = None else: starter = User.objects.order_by("?").last() # There's 10% chance thread is closed if random.randint(0, 100) > 90: thread = get_fake_closed_thread(fake, category, starter) # There's further 5% chance thread is hidden elif random.randint(0, 100) > 95: if random.randint(0, 100) > 90: hidden_by = None else: hidden_by = User.objects.order_by("?").last() thread = get_fake_hidden_thread(fake, category, starter, hidden_by) # And further 5% chance thread is unapproved elif random.randint(0, 100) > 95: thread = get_fake_unapproved_thread(fake, category, starter) # Default, standard thread else: thread = get_fake_thread(fake, category, starter) thread.synchronize() thread.save() created_threads += 1 show_progress(self, created_threads, items_to_create, start_time) pinned_threads = random.randint(0, int(created_threads * 0.025)) or 1 self.stdout.write("\nPinning %s threads..." % pinned_threads) for _ in range(0, pinned_threads): thread = Thread.objects.order_by("?")[:1][0] if random.randint(0, 100) > 90: thread.weight = 2 else: thread.weight = 1 thread.save() for category in categories: category.synchronize() category.save() total_time = time.time() - start_time total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time)) message = "\nSuccessfully created %s fake threads in %s" self.stdout.write(message % (created_threads, total_humanized))
def test_invalid_locale(self): with self.assertRaises(AttributeError): Factory.create('foo_Bar')
def __init__(self, config): self._fake = Factory.create(config["args"].language) self._config = config
def handle(self, *args, **options): number_to_create: int = options['posts'] fake: Generator = Factory.create( getattr(settings, 'FAKER_LOCALE', None)) users = User.objects.all() threads = Thread.objects.prefetch_related('posts').all() for _ in tqdm(range(number_to_create), desc='Creating new posts'): thread: Thread = random.choice(threads) # This New post is going to be the reply for parent existing_posts: List[Union[Post, None]] = list(thread.posts.all()) existing_posts.append(None) parent = random.choice(existing_posts) poster: User = random.choice(users) is_unapproved: bool = random.choices([True, False], weights=[0.1, 0.9])[0] is_hidden: bool = random.choices([True, False], weights=[0.1, 0.9])[0] datetime_start = thread.created_on if parent is not None: assert parent.created_on == thread.created_on or parent.created_on > thread.created_on, \ 'Post should be posted after the creation of thread.' datetime_start = parent.created_on created_on: datetime = make_aware( fake.date_time_between_dates(datetime_start=datetime_start, datetime_end=None, tzinfo=None) ) parsed_paragraphs: List[str] = [] for _ in range(random.randint(1, 5)): if random.random() < 0.1: width = random.randint(100, 1600) height = random.randint(100, 1600) url = UNSPLASH_URL % (width, height) parsed_paragraphs.append( f'<p><img src="{url}" alt="" /></p>') else: sentences = fake.sentences(random.randint(1, 10)) raw_paragraph = ' '.join(sentences) parsed_paragraph = f'<p>{raw_paragraph}</p>' parsed_paragraphs.append(parsed_paragraph) content = '\n'.join(parsed_paragraphs) Post( parent=parent, thread=thread, poster=poster, content=content, is_unapproved=is_unapproved, is_hidden=is_hidden, created_on=created_on ).save() # Refresh threads from database in order to refresh thread's posts threads = Thread.objects.prefetch_related('posts').all()