def get_user_data(test_locale='en'):
person = {}
user = Personal(test_locale)
address = Address(test_locale)
person['first_name'], person['last_name'] = user.full_name(gender='male').split()
common.success("Generated user name '%s %s'" % (person['first_name'], person['last_name']))
person['email'] = user.email(gender='male')
common.success("Generated email '%s'" % person['email'])
person['street'] = address.address()
person['city'] = address.city()
person['state'] = address.state()
person['postcode'] = address.postal_code()
common.success("Generated address '%s %s, %s, %s'" % (person['postcode'], person['state'], person['city'], person['street']))
person['password'] = ''.join(random.SystemRandom().choice(string.digits + string.ascii_letters) for _ in range(10))
common.success("Generated password '%s'" % person['password'])
if (test_locale == 'en'):
person['country_code'] = 'US'
person['country'] = 'United States'
person['state_code'] = 'IA'
person['state'] = 'Iowa'
elif (test_locale == 'ru'):
person['country_code'] = 'RU'
person['country'] = 'Russian Federation'
person['state_code'] = None
person['state'] = None
else:
person['country_code'] = None
person['country'] = None
person['state_code'] = None
person['state'] = None
common.success("Generated country '%s' and state '%s'" % (person['country'], person['state']))
return person
def product_add_to_db(request):
person_data = Personal('ru')
person_address = Address('ru')
busines = Business('ru')
date = Datetime('ru')
text = Text('ru')
for _ in range(301):
Products.objects.create(
product_name=text.title(),
product_slug=person_data.cid(),
product_description=text.text(quantity=5),
product_price=random_price(),
product_created_at=date.date(start=2017,
end=2017,
fmt='%Y-%m-%d %H:%M:%S'),
product_modified_at=date.date(start=2017,
end=2017,
fmt='%Y-%m-%d %H:%M:%S'),
)
for _ in range(127):
user = User.objects.create(username='******'.format(
str(datetime.datetime.now().microsecond)),
password='******')
Consumers.objects.create(
user=user,
full_name=person_data.full_name(),
banned=true_or_false(),
gender=person_data.gender(),
)
def init(count=2000, locale='en'):
from elizabeth import Personal, Text
gen = Personal(locale)
text = Text(locale)
for _ in range(count):
gen_post = Contact(name=gen.name(),
num=gen.credit_card_number(),
some_blank=text.text(3),
some_null=gen.email())
gen_post.save()
def generate_user(count=60, locale="en"):
person = Personal(locale)
genders = ["male", "female"]
for _ in range(count):
while True:
username = person.name(gender=genders[_ % 2])
if User.query.filter_by(username=username).first() is None:
break
email = username.replace(" ", "_") + "@weblog.com"
new = User(username=username, email=email, password=person.password())
db.session.add(new)
db.session.commit()
def tell_me_your_name(self, gender):
"""
Uses elizabeth to generate a random name
Returns:
string
"""
personal = Personal('en')
# only two genders are available to elizabeth
# elizabeth uses the gender to generate a name
full_name = personal.full_name(gender=gender)
return full_name
def generate_patients(number, male, female):
patients = []
person = Personal('en')
sensors = [
"Blood Pressure", "Heart Rate", "Glucose Levels",
"Blood Oxygen Saturation"
]
# males
for i in range(int(number * male)):
first_name = person.name(gender="male")
last_name = person.surname()
age = person.age(18)
# creates a copy of sensors
x = sensors
# shuffles the sensors
random.shuffle(x)
# picks a random number of sensors
sens = ",".join(x[:random.randrange(1, len(sensors))])
# sql query here
patients.append(
Patient(
ID=0, #not important for this step as sql will auto increment
first_name=first_name,
last_name=last_name,
age=age,
gender="Male",
sensors=sens))
# females
for i in range(int(number * female)):
first_name = person.name(gender="female")
last_name = person.surname()
age = person.age(18)
gender = "famale"
# creates a copy of sensors
x = sensors
# shuffles the sensors
random.shuffle(x)
# picks a random number of sensors
sens = ",".join(x[:random.randrange(1, len(sensors))])
# sql query here
patients.append(
Patient(
ID=0, #not important for this step as sql will auto increment
first_name=first_name,
last_name=last_name,
age=age,
gender="Female",
sensors=sens))
return patients
def generate_fake_metadata(encoding="utf-8", num_documents=10):
"""Generates some fake metadata in DAT format for use in testing."""
fields = ["document_id",
"group_id",
"author",
"custodian",
"date_created",
"date_modified",
"date_received",
"date_sent",
"fulltext"]
data = []
personal = Personal('en')
datetime = Datetime('en')
text = Text('en')
out = io.StringIO(newline="\n")
last_parent = "BOGUS{:06d}".format(1)
for x in range(1, num_documents):
document = dict()
document["document_id"] = "BOGUS{:06d}".format(x)
random.seed()
if random.randrange(1, 3) == 2:
document["group_id"] = "BOGUS{:06d}".format(x)
last_parent = document["group_id"]
else:
document["group_id"] = last_parent
document["author"] = personal.name()
document["custodian"] = personal.full_name()
document["date_created"] = datetime.date(sep='/')
document["date_modified"] = datetime.date(sep='/')
document["date_received"] = datetime.date(sep='/')
document["date_sent"] = datetime.date(sep='/')
document["fulltext"] = text.text(quantity=10)
data.append(document)
writer = csv.DictWriter(out, delimiter="\x14", quotechar="\xfe", quoting=csv.QUOTE_ALL, fieldnames=fields)
writer.writeheader()
writer.writerows(data)
return out.getvalue().encode(encoding)
class ModelsAccountTestCase(unittest.TestCase):
person = Personal()
text = Text()
def setUp(self):
self.app = create_app("testing")
self.client = self.app.test_client()
self.context = self.app.app_context()
self.context.push()
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
self.context.pop()
def test_01_save_and_delete(self):
kwargs = {"username": self.person.name(), "email": self.person.email()}
self.assertEqual(User.query.count(), 0)
user = User(**kwargs)
user.save()
self.assertEqual(user.__repr__(),
"<User {} ID {}>".format(kwargs["username"], 1))
self.assertEqual(User.query.count(), 1)
user.delete()
self.assertEqual(User.query.count(), 0)
def test_02_password(self):
kwargs = {"username": self.person.name(), "email": self.person.email()}
password = self.person.password(16)
user = User(**kwargs)
self.assertIsNone(user.password_hash)
with self.assertRaises(AttributeError):
user.password
user.password = password
self.assertIsNotNone(user.password_hash)
self.assertTrue(user.verify_password(password))
self.assertFalse(user.verify_password(self.person.password(16)))
def test_03_token(self):
kwargs = {"username": self.person.name(), "email": self.person.email()}
key_1, key_2 = self.text.words(2)
user = User(**kwargs)
user.save()
token_1 = user.generate_token(key_1)
sleep(1)
token_1_delay = user.generate_token(key_1)
self.assertNotEqual(token_1, token_1_delay)
token_2 = user.generate_token(key_2)
self.assertEquals((User.confirm(key_1, token_1), user),
(User.confirm(key_2, token_2), user))
self.assertIsNone(User.confirm(key_2, token_1))
token = user.generate_token(key_1, expiration=2)
self.assertEqual(User.confirm(key_1, token), user)
sleep(3)
self.assertIsNone(User.confirm(key_1, token))
def setUp(self):
self.app = create_app("testing")
self.client = self.app.test_client()
self.context = self.app.app_context()
self.context.push()
db.create_all()
person = Personal()
text = Text()
kwargs = {
"username": person.username(),
"email": person.email(),
"password": person.password(16)
}
user = User(**kwargs)
user.save()
def __auth():
response = self.client.post("/api/auth",
data=json.dumps(kwargs),
content_type="application/json")
self.assertEqual(response.status_code, 200)
def __post():
post = Post(title=self.text.title(),
summary=text.text(3),
body=text.text(6),
author=user)
category = Category(name=text.word())
category.save()
post.category = category
tag = Tag(name=text.word())
tag.save()
post.tags.append(tag)
post.save()
return post
self.login = __auth
self.new_post = __post
del kwargs["email"]
self.data = {"kwargs": kwargs, "user": user}
self.text = text
self.person = person
async def generate_users(pg, rows=20, locale='en'):
"""
Insert data into users table
:param pg: connect to DB engine(PostgreSQL)
:param rows: numbers of rows
:param locale: language locale
:return: list of user_id
"""
values = []
user = Personal(locale)
for i in range(rows):
gender = choice(['female', 'male'])
values.append({
'first_name': user.name(gender=gender),
'last_name': user.surname(gender=gender),
'user_id': uuid.uuid4(),
})
ids = await insert_data(pg, models.users, values, res=True)
return ids
def setUp(self):
self.personal = Personal()
class PersonalBaseTest(TestCase):
def setUp(self):
self.personal = Personal()
def tearDown(self):
del self.personal
def test_str(self):
self.assertTrue(re.match(STR_REGEX, self.personal.__str__()))
def test_age(self):
result = self.personal.age(maximum=55)
self.assertTrue(result <= 55)
def test_age(self):
result = self.personal.age(maximum=55)
self.assertTrue(result <= 55)
def test_age_store(self):
result = self.personal._store['age']
self.assertEqual(result, 0)
def test_age_update(self):
result = self.personal.age() - self.personal._store[
'age'] # calling age() should go first
self.assertEqual(result, 0)
def test_child_count(self):
result = self.personal.child_count(max_childs=10)
self.assertTrue(result <= 10)
def test_work_experience(self):
result = self.personal.work_experience(
working_start_age=0) - self.personal._store['age']
self.assertEqual(result, 0)
def test_work_experience_store(self):
result = self.personal.work_experience(
) - self.personal.work_experience()
self.assertEqual(result, 0)
def test_work_experience_extreme(self):
result = self.personal.work_experience(working_start_age=100000)
self.assertEqual(result, 0)
def test_paypal(self):
result = self.personal.paypal()
self.assertIsNotNone(result)
def test_password(self):
plain = self.personal.password(length=15)
self.assertEqual(len(plain), 15)
md5 = self.personal.password(algorithm='md5')
self.assertEqual(len(md5), 32)
sha1 = self.personal.password(algorithm='sha1')
self.assertEqual(len(sha1), 40)
sha256 = self.personal.password(algorithm='sha256')
self.assertEqual(len(sha256), 64)
sha512 = self.personal.password(algorithm='sha512')
self.assertEqual(len(sha512), 128)
with self.assertRaises(NotImplementedError):
self.personal.password(algorithm='sha42')
def test_username(self):
result = self.personal.username()
self.assertTrue(re.match(USERNAME_REGEX, result))
def test_email(self):
result = self.personal.email()
self.assertTrue(re.match(EMAIL_REGEX, result))
def test_bitcoin(self):
result = self.personal.bitcoin()
self.assertEqual(len(result), 34)
def test_cvv(self):
result = self.personal.cvv()
self.assertTrue((100 <= result) and (result <= 999))
def test_credit_card_number(self):
result = self.personal.credit_card_number()
self.assertTrue(re.match(CREDIT_CARD_REGEX, result))
result_mc = self.personal.credit_card_number(card_type='master_card')
self.assertTrue(re.match(CREDIT_CARD_REGEX, result_mc))
result_ax = self.personal.credit_card_number(card_type='amex')
self.assertTrue(re.match(CREDIT_CARD_REGEX, result_ax))
with self.assertRaises(NotImplementedError):
self.personal.credit_card_number(card_type="discover")
def test_expiration_date(self):
result = self.personal.credit_card_expiration_date(minimum=16,
maximum=25)
year = result.split('/')[1]
self.assertTrue((int(year) >= 16) and (int(year) <= 25))
def test_cid(self):
result = self.personal.cid()
self.assertTrue((1000 <= result) and (result <= 9999))
def test_height(self):
result = self.personal.height(minimum=1.60, maximum=1.90)
self.assertTrue(result.startswith('1'))
self.assertIsInstance(result, str)
def test_weight(self):
result = self.personal.weight(minimum=40, maximum=60)
self.assertTrue((result >= 40) and (result <= 60))
def test_blood_type(self):
result = self.personal.blood_type()
self.assertIn(result, common.BLOOD_GROUPS)
def test_favorite_movie(self):
result = self.personal.favorite_movie()
self.assertIn(result, self.personal.data['favorite_movie'])
def test_favorite_music_genre(self):
result = self.personal.favorite_music_genre()
self.assertIn(result, common.FAVORITE_MUSIC_GENRE)
def test_avatar(self):
result = self.personal.avatar(size=512)
img, size, _, _, _, _ = result.split('/')[::-1]
self.assertEqual(int(size), 512)
self.assertEqual(32, len(img.split('.')[0]))
def test_identifier(self):
result = self.personal.identifier()
mask = '##-##/##'
self.assertEqual(len(mask), len(result))
result = self.personal.identifier(mask='##', suffix=True)
lst = result.split()
_id, sfx = lst[0], lst[1]
self.assertEqual(len(_id), 2)
self.assertEqual(len(sfx), 2)
result = self.personal.identifier(suffix=True)
suffix = result.split(' ')[1]
self.assertTrue(suffix.isalpha())
def test_level_of_english(self):
result = self.personal.level_of_english()
lvl_s = [
'Beginner', 'Elementary', 'Pre - Intermediate', 'Intermediate',
'Upper Intermediate', 'Advanced', 'Proficiency'
]
self.assertIn(result, lvl_s)
def mail():
personal = Personal('ru')
login = personal.email(gender='female')
password = personal.password(length=15)
b = 'login: '******'\n' + 'pass: '******'\n \n Enjoy, sweety...'
return b
class PersonalBaseTest(TestCase):
def setUp(self):
self.personal = Personal()
def tearDown(self):
del self.personal
def test_age(self):
result = self.personal.age(maximum=55)
self.assertTrue(result <= 55)
def test_paypal(self):
result = self.personal.paypal()
self.assertIsNotNone(result)
def test_password(self):
plain = self.personal.password(length=15)
self.assertEqual(len(plain), 15)
md5 = self.personal.password(algorithm='md5')
self.assertEqual(len(md5), 32)
sha1 = self.personal.password(algorithm='sha1')
self.assertEqual(len(sha1), 40)
sha256 = self.personal.password(algorithm='sha256')
self.assertEqual(len(sha256), 64)
sha512 = self.personal.password(algorithm='sha512')
self.assertEqual(len(sha512), 128)
def test_username(self):
result = self.personal.username()
self.assertTrue(re.match(USERNAME_REGEX, result))
def test_email(self):
result = self.personal.email()
self.assertTrue(re.match(EMAIL_REGEX, result))
def test_bitcoin(self):
result = self.personal.bitcoin()
self.assertEqual(len(result), 34)
def test_cvv(self):
result = self.personal.cvv()
self.assertTrue((100 <= result) and (result <= 999))
def test_credit_card_number(self):
result = self.personal.credit_card_number()
self.assertTrue(re.match(CREDIT_CARD_REGEX, result))
def test_expiration_date(self):
result = self.personal.credit_card_expiration_date(minimum=16,
maximum=25)
year = result.split('/')[1]
self.assertTrue((int(year) >= 16) and (int(year) <= 25))
def test_cid(self):
result = self.personal.cid()
self.assertTrue((1000 <= result) and (result <= 9999))
def test_height(self):
result = self.personal.height(minimum=1.60, maximum=1.90)
self.assertTrue(result.startswith('1'))
self.assertIsInstance(result, str)
def test_weight(self):
result = self.personal.weight(minimum=40, maximum=60)
self.assertTrue((result >= 40) and (result <= 60))
def test_blood_type(self):
result = self.personal.blood_type()
self.assertIn(result, common.BLOOD_GROUPS)
def test_favorite_movie(self):
result = self.personal.favorite_movie()
self.assertIn(result, self.personal.data['favorite_movie'])
def test_favorite_music_genre(self):
result = self.personal.favorite_music_genre()
self.assertIn(result, common.FAVORITE_MUSIC_GENRE)
def test_avatar(self):
result = self.personal.avatar()
self.assertTrue(len(result) > 20)
def test_identifier(self):
result = self.personal.identifier()
mask = '##-##/##'
self.assertEqual(len(mask), len(result))
result = self.personal.identifier(mask='##', suffix=True)
lst = result.split()
_id, sfx = lst[0], lst[1]
self.assertEqual(len(_id), 2)
self.assertEqual(len(sfx), 2)
result = self.personal.identifier(suffix=True)
suffix = result.split(' ')[1]
self.assertTrue(suffix.isalpha())
def phrasing(designation, verb, identity, codename, safehouse):
if verb == 'signed for by':
phrase = '{} {} {}'.format(designation, verb, codename)
return phrase
elif verb == 'received by':
phrase = '{} {} {}'.format(designation, verb, safehouse)
return phrase
elif verb == 'mishandled' or verb == 'in transit' or verb == 'cancelled':
phrase = '{} {}'.format(designation, verb)
return phrase
elif verb == 'delivered to':
phrase = '{} {} {}'.format(designation, verb, identity)
return phrase
person = Personal('en')
numbers = [
'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine',
'zero'
]
for i in range(0, 5):
filename = "radio_{}.mp3".format(i)
synth_gender = choice(['male', 'female'])
letter = choice([
'Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo', 'Foxtrot', 'Golf',
'Hotel', 'Indigo', 'Juliet', 'Kilo', 'Lima', 'Mike', 'November',
'Oscar', 'Papa', 'Quebec', 'Romeo', 'Sierra', 'Tango', 'Uniform',
'Victor', 'Whiskey', 'X-ray', 'Yankee', 'Zulu'
])
'Пособие по уходу за ребенком до 3-х лет',
'Ежемесячная выплата многодетнам семьям', 'Льгота на оплату ЖП и ЖКУ',
'Пособие по нуждаемости',
'Компенсания в связи с проживанием на загрязненной территории',
'Единовременная выплаты к праздничным датам')
pp = pprint.PrettyPrinter(indent=4)
# Кол-во выплат у каждого
payments = 10
# В скольких районах он будет стоять на учете
r = 2
# Соль
soul = 'Соцзащита1864io72grFG'
# Настройка генератора на Елизабет
g = Generic('ru')
user = Personal('ru')
pols = ('male', 'female')
# Соединение с БД
client = MongoClient('192.168.0.195', 27017)
db = client['1019']
collection = db['payments']
# Кол-во упаковок
packs = 300
pack_count = 0
while pack_count < packs:
pack_count += 1
start = time.time()
people_for_download = dict()
# Кол-во людей, которых надо сгенерировать
Globals
'''
m_status = ("Married", "Single", "Divorced", "Widowed", "Separated")
c_loss = ("Fire", "Water", "Theft", "Natural Disaster")
n_loss = ("Borrowed", "Misplaced", "Donated")
i_insurer = ("Santam", "Hollard", "Outsurance", "Discovery", "Absa",
"Mutual & Federal", "First for Woman", "Budget", "Miway")
fraud_reasons = ("No Date of birth",
"Date of birth calculated Age and Age do not match",
"Claim amount is more than Sum Insured",
"No Policy start date", "No Policy end date",
"Policy end date before start date", "Claim Date before loss",
"No kind of loss", "Invalid kind of loss",
"No premium but has claim", "Claim after Policy end date",
"Claim before Policy start", "Age is not in requirements")
person = Personal('en')
fake = Faker()
mindate = datetime.strptime('Jun 1 1900 1:33PM', '%b %d %Y %I:%M%p')
maxdate = datetime.today()
'''
Functions
'''
'''
:param n - number of claims to insert
:param f - number of fraud claims
'''
def create_database(n, f):
fraud = set([int(randint(0, n)) for i in range(f)])
# for work with Active Directry
from ldap3 import Server, Connection, ALL, NTLM
from ldap3.extend.microsoft.addMembersToGroups import ad_add_members_to_groups as addUsersInGroups
# data generator
from elizabeth import Personal, Address,Text
import random
# define constans
serverName='lsd-dc1.stand.lsd'
connUser="******"
connUserPwd="" # enter pwd here
usersOU = 'ou=test-ou,dc=stand,dc=lsd' # ou for generated users
groupsOU = 'ou=test-groups,dc=stand,dc=lsd'# ou for generated groups
address = Address('en') # generate data for OU name
person = Personal('en') # generate data for users
usersDnList = [] # global list DN of generated users
groupsDnList = [] # global list DN of generated groups
# let's connect
server = Server(serverName, get_info=ALL)
conn = Connection(server, user=connUser, password=connUserPwd, authentication=NTLM)
conn.bind() #must be TRUE if OK
conn.add(usersOU, 'organizationalUnit') # add test-ou for users
conn.add(groupsOU, 'organizationalUnit') # add test-ou for groups
# generate groups
data = Text('en')
class AuthApiTestCase(unittest.TestCase):
person = Personal()
def setUp(self):
self.app = create_app("testing")
self.client = self.app.test_client()
self.context = self.app.app_context()
self.context.push()
db.create_all()
kwargs = {
"username": self.person.username(),
"email": self.person.email(),
"password": self.person.password(16)
}
user = User(**kwargs)
user.save()
del kwargs["email"]
self.data = {"kwargs": kwargs, "user": user}
def tearDown(self):
db.session.remove()
db.drop_all()
self.context.pop()
def test_01_post_method(self):
kwargs = self.data["kwargs"]
user = self.data["user"]
kwargs_fake = dict(username=self.person.username(),
password=self.person.password(16))
response = self.client.post("/api/auth",
data=json.dumps(kwargs_fake),
content_type="application/json")
self.assertEqual(response.status_code, 400)
data = json.loads(response.data)
self.assertEqual(data["message"]["username"],
"valid username is required for authentication")
response = self.client.post("/api/auth",
data=json.dumps(kwargs),
content_type="application/json")
self.assertEqual(response.status_code, 200)
data = json.loads(response.data)
self.assertEqual(User.confirm("login", data["token"]).id, user.id)
kwargs["password"] = self.person.password(16)
response = self.client.post("/api/auth",
data=json.dumps(kwargs),
content_type="application/json")
self.assertEqual(response.status_code, 401)
data = json.loads(response.data)
self.assertEqual(data["message"], "invalid username or password")
def test_02_refresh_token(self):
kwargs = self.data["kwargs"]
user = self.data["user"]
token_fake = json.dumps(dict(token=json.dumps(kwargs)))
response = self.client.get("/api/auth",
query_string=dict(token=token_fake))
self.assertEqual(response.status_code, 401)
response = self.client.post("/api/auth",
data=json.dumps(kwargs),
content_type="application/json")
token_1 = parse_cookie(
response.headers.getlist('Set-Cookie')[0])["token"]
sleep(1)
response = self.client.get("/api/auth",
query_string=dict(token=token_1))
token_2 = parse_cookie(
response.headers.getlist("Set-Cookie")[0])["token"]
self.assertNotEqual(token_1, token_2)
self.assertEqual(User.confirm("login", token_1).id, user.id)
self.assertEqual(User.confirm("login", token_2).id, user.id)
def wait_engine():
engine = create_engine('mysql://*****:*****@proxysql/proxysql_test',
echo=True,
encoding='utf-8')
while True:
try:
engine.execute("SELECT 1")
return engine
except Exception as e:
logging.exception("MySQL not awailable retrying")
sleep(5)
defaults = Personal()
Base = declarative_base()
Session = sessionmaker()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(40), index=True, default=defaults.username)
fullname = Column(String(40), index=True, default=defaults.full_name)
password = Column(String(40), index=True, default=defaults.password)
def __repr__(self):
return "<User(name='%s', fullname='%s', password='******')>" % (
self.name, self.fullname, self.password)
