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()
