def test_login_management(faker: Faker) -> None:
auth = Connector.get_authentication_instance()
if BaseAuthentication.default_user:
logins = auth.get_logins(BaseAuthentication.default_user)
assert isinstance(logins, list)
assert len(logins) > 0
auth.flush_failed_logins(BaseAuthentication.default_user)
logins = auth.get_logins(BaseAuthentication.default_user,
only_unflushed=True)
assert len(logins) == 0
logins = auth.get_logins(BaseAuthentication.default_user,
only_unflushed=False)
assert len(logins) > 0
logins = auth.get_logins(faker.ascii_email())
assert isinstance(logins, list)
assert len(logins) == 0
logins = auth.get_logins(faker.pystr())
assert isinstance(logins, list)
assert len(logins) == 0
def generate_data(n):
b_official = backend_official(config['user'], config['pass'],
config['host'], config['port'],
config['db_name'])
b_profile = backend_profile(config['user'], config['pass'], config['host'],
config['port'], config['db_name'])
b_score = backend_score(config['user'], config['pass'], config['host'],
config['port'], config['db_name'])
fake = Faker()
for i in range(n):
profile = dict()
profile['name'] = fake.name()
profile['phone'] = fake.phone_number()[:12]
profile['email'] = fake.ascii_email()
profile['referral'] = fake.name()
profile['age'] = random.randint(0, 99)
profile['password'] = fake.ean13()
b_profile.insert_profile(profile)
b_official.update_written_exam(profile['email'], random.randint(0, 40),
'Intro In English')
term = ['spring', 'summer', 'fall']
b_score.write_class_score(profile['email'], 'Intro In English',
random.randint(2000, 2019),
term[random.randint(0, 2)], 10)
def handle(self, *args, **options):
nb_admins = options["nb_admins"][0]
verbose = options["verbose"]
fake = Faker(options["locale"])
for admin_num in range(1, nb_admins + 1):
hf = self.get_random_hf()
claim_admin = create_test_claim_admin({
"code":
''.join(
random.choices(string.ascii_uppercase + string.digits,
k=8)),
"last_name":
fake.last_name(),
"other_names":
fake.first_name(),
"email_id":
fake.ascii_email(),
"phone":
"+" + fake.msisdn(),
"health_facility_id":
hf
})
if verbose:
print(admin_num, "created claim admin", claim_admin, "for HF",
hf, "with code", claim_admin.code)
def test_05_no_notification_email_for_wrong_usernames(
self, client: FlaskClient, faker: Faker
) -> None:
if not Env.get_bool("MAIN_LOGIN_ENABLE"): # pragma: no cover
log.warning("Skipping admin/users tests")
return
uuid, data = self.create_user(client)
self.delete_mock_email()
# Just to verify that email is deleted
with pytest.raises(FileNotFoundError):
self.read_mock_email()
email = faker.ascii_email()
# Wrong credentials with a non existing email
# -> No notification will be sent
for _ in range(0, max_login_attempts):
self.do_login(client, email, data["password"], status_code=401)
# Verify the ban (i.e. status 403)
headers, _ = self.do_login(client, email, data["password"], status_code=403)
assert headers is None
# Verify that there are no mocked email
with pytest.raises(FileNotFoundError):
self.read_mock_email()
# Goodbye temporary user
self.delete_user(client, uuid)
def user_data(faker: Faker):
return {
"email": faker.ascii_email(),
"name": faker.name(),
"cpf": faker.ssn(),
"password": faker.password(length=12),
}
def seed_users(apps, schema_editor):
User.objects.create_superuser('*****@*****.**', 'secret')
fake = Faker()
if config('SEED', default=False, cast=bool):
print('Sedding users')
for i in range(1, 10):
User.objects.create_user(fake.ascii_email(), 'secret')
def generate_user(dong=0):
Faker.seed(dong)
fake = Faker(['cs_CZ', 'en_GB', 'ru_RU'])
user = ''
email = ''
while len(user) < 7 or len(user) > 15 or len(email) < 7:
user = fake.user_name()
email = fake.ascii_email()
data = {
'username': user,
'email': email,
'password': fake.credit_card_security_code()
}
return data
def generate_data():
Faker.seed(432)
data = []
fake = Faker(['cs_CZ', 'en_GB', 'ru_RU'])
for _ in range(1000):
user = ''
email = ''
while len(user) < 6 and len(email) < 7:
user = fake.user_name()
email = fake.ascii_email()
data.append({
'username': user,
'email': email,
'password': fake.credit_card_security_code()
})
return data
def generation(nb_generation, cpt):
motif = "'"
cpt += 1
chaine_generated = ""
generator = Faker()
'''
chaine_generated += motif
chaine_generated+=str(cpt)
chaine_generated += motif
chaine_generated +=","+motif
'''
chaine_generated += "'"
chaine_split = generator.name().split(" ")
chaine_generated += chaine_split[0]
chaine_generated += motif
chaine_generated += "," + motif
chaine_generated += chaine_split[1]
chaine_generated += motif
chaine_generated += "," + motif
chaine_generated += generator.ascii_email()
chaine_generated += motif
chaine_generated += "," + motif
chaine_generated += generator.date(pattern="%Y/%m/%d", end_datetime=None)
chaine_generated += motif
chaine_generated += "," + motif
chaine_generated += generator.country()
chaine_generated += motif
chaine_generated += "," + motif
chaine_generated += generator.city()
chaine_generated += motif
chaine_generated += "," + motif
chaine_generated += generator.zipcode()
chaine_generated += motif + ","
chaine_generated += motif
chaine_generated += generator.phone_number()
chaine_generated += motif
#debug
#print(chaine_generated)
return chaine_generated
def add_user():
faker = Faker(locale="zh_CN")
num = request.args.get('num', 1, type=int)
for i in range(num):
sno = '20170900{0:04d}'.format(i + 164)
name = faker.name()
password = '******'
phone = faker.phone_number()
email = faker.ascii_email()
user = User()
user.sno = sno
user.phone = phone
user.password = password
user.name = name
user.email = email
db.session.add(user)
db.session.commit()
return 'successfully added user {}'.format(num)
def test_admin_stats(self, client: FlaskClient, faker: Faker) -> None:
if not Env.get_bool("AUTH_ENABLE"):
log.warning("Skipping admin/logins tests")
return
r = client.get(f"{API_URI}/admin/logins")
assert r.status_code == 401
random_username = faker.ascii_email()
self.do_login(client, random_username, faker.pystr(), status_code=401)
headers, _ = self.do_login(client, None, None)
r = client.get(f"{API_URI}/admin/logins", headers=headers)
assert r.status_code == 200
logins = self.get_content(r)
assert isinstance(logins, list)
assert len(logins) > 0
assert "username" in logins[0]
assert "date" in logins[0]
assert "IP" in logins[0]
assert "location" in logins[0]
assert "failed" in logins[0]
assert "flushed" in logins[0]
for login in logins:
if login["username"] == BaseAuthentication.default_user:
break
else: # pragma: no cover
pytest.fail("Default user not found in logins table")
for login in logins:
if login["username"] == random_username:
assert login["failed"] is True
assert login["flushed"] is False
break
else: # pragma: no cover
pytest.fail("Random user not found in logins table")
def get_random_email(cls,
faker: Faker,
name: str,
surname: str,
recursion: int = 0) -> str:
# Please Faker, add some types hints and let me remove this str()!
email = str(faker.ascii_email())
# This email contains the name, re-sampling again
if name.lower() in email.lower(): # pragma: no cover
return cls.get_random_email(faker,
name,
surname,
recursion=recursion + 1)
# This email contains the surname, re-sampling again
if surname.lower() in email.lower(): # pragma: no cover
return cls.get_random_email(faker,
name,
surname,
recursion=recursion + 1)
email_tokens = email.split("@")
email_username = email_tokens[0]
if len(email_username) > 3:
# Please Faker, add some types hints!
return email
# Probably this Faker locale only has very short emails.
# It can happens with Chinese?
# Let's return a repetition of the name it self
if recursion >= 10: # pragma: no cover
return f"{email_username * 4}@{email_tokens[1]}"
return cls.get_random_email( # pragma: no cover
faker,
surname,
surname,
recursion=recursion + 1)
class SchemaStringGenerator:
def __init__(self):
self._faker = Faker()
def generate_string(self, schema: dict) -> str:
format = schema.get(JsonSchemaPropertiesConstants.STRING_TYPE_FORMAT, None)
min_length = schema.get(JsonSchemaPropertiesConstants.STRING_TYPE_MIN_LENGTH, None)
max_length = schema.get(JsonSchemaPropertiesConstants.STRING_TYPE_MAX_LENGTH, None)
enum = schema.get(JsonSchemaPropertiesConstants.STRING_TYPE_ENUM, None)
pattern = schema.get(JsonSchemaPropertiesConstants.STRING_TYPE_PATTERN, None)
if pattern is not None:
return rstr.xeger(pattern)
if enum is not None:
return self._faker.random_elements(elements=enum, length=1)[0]
if min_length is not None or max_length is not None:
if max_length is None:
max_length = 5
return self._faker.pystr(min_length, max_length)
if format:
return self._generate_from_string_format(format)
return self._faker.name()
def _generate_from_string_format(self, format):
return {
"date-time": self._faker.date_time().strftime("%Y-%m-%dT%H:%M:%S%z"),
"date": self._faker.date_time().strftime("%Y-%m-%d"),
"time": self._faker.date_time().strftime("%H:%M:%S"),
"email": self._faker.ascii_email(),
"ipv4": self._faker.ipv4(),
"ipv6": self._faker.ipv6(),
}[format]
def fake_users(iteration):
fake = Faker()
fake.add_provider(internet)
fake.add_provider(person)
fake.add_provider(misc)
for _ in range(iteration):
username = fake.user_name()
first_name = fake.first_name()
last_name = fake.last_name()
email = fake.ascii_email()
avatar_file_name = username + first_name + last_name + '.jpg'
avatar_file_path = 'uploads\\' + avatar_file_name
create_random_image_file(avatar_file_path)
CustomUser.objects.create_user(username=username,
first_name=first_name,
last_name=last_name,
password='******',
email=email,
avatar=avatar_file_path)
print(username)
print(f'{iteration} fake-users are created')
import requests
from faker import Faker
f=Faker(locale='zh_CN')
for i in range(3):
headers = {
'Cookie': 'CID=e05ef3e6bcb4d7afa8accc77052726cf; SEID=4b315ba8e3f143a6e52d160100c35a3029b5ae48c9649e072dc1ca43407736826b58029e9fb18bf08b402648d830e7ac38902ae4070c82eabcc0a0ec; UID=110003619_N1_1569398339'
}
data = {
'birthday':f.date(pattern="%Y-%m-%d"),
'calendar':1,
'naddress':'[{"value":"%s","name":"单位地址","label":"COMPANY"}]'%(f.address()),
'name':f.name(),
'nemail':'[{"label":"EMAIL","name":"邮箱","value":"%s"}]'%(f.ascii_email()),
'new_company_name':'[{"label":"COMPANY","name":"公司","value":"%s"}]'%(f.company()),
'new_position':'[{"label":"POSITION","value":"","name":"职位"}]',
'nwebsite':'[]',
'social':'[]',
'tel':'[{"label":"MOBILE","value":"%s","name":"手机"}]'%(f.phone_number()),
}
url = 'http://yun.115rc.com/api/1.0/ios/9.0.0/22431/customer/save_member'
r=requests.post(url=url,headers=headers,data=data)
back = r.json()
print(back)
from faker import Faker
from databases import mycollection
user = Faker()
for _ in range(20):
# generate and insert fake user data in database
name = user.first_name()
last_name = user.last_name()
email = user.ascii_email()
password = user.password(length=8)
document = {
"name": name,
"last_name": last_name,
"email": email,
"password": password
}
userid = mycollection.insert_one(document)
print("OK")
class Database:
def __init__(self):
self.fake = Faker()
self.cnx = mysql.connector.connect(
user='******',
password='******',
host='localhost',
database='P6DB',
)
def insert_categories(self):
cursor = self.cnx.cursor()
sql_cat = "Insert IGNORE INTO category (name) VALUES (%(cat_name)s)"
categories_list = ['Pizza', 'Dessert', 'Boissons', 'Snack']
for cat in categories_list:
cat_add = {'cat_name': cat}
cursor.execute(sql_cat, cat_add)
self.cnx.commit()
cursor.close()
def insert_delivery_mode(self):
cursor = self.cnx.cursor()
sql_delivery_mode = ("INSERT IGNORE INTO Delevery_mode (name)"
" VALUES (%(mode_n)s)")
mode = ['à emporter', 'sur place', 'livraison']
for mod in mode:
mode_add = {'mode_n': mod}
cursor.execute(sql_delivery_mode, mode_add)
self.cnx.commit()
cursor.close()
def insert_payment_mode(self):
cursor = self.cnx.cursor()
sql_payment_mode = ("INSERT IGNORE INTO payment_mode (name) "
"VALUES (%(mode_payment)s)")
mode_p = ['à la livraison', 'en ligne', 'sur place']
for mode in mode_p:
md = {'mode_payment': mode}
cursor.execute(sql_payment_mode, md)
self.cnx.commit()
cursor.close()
def insert_status(self):
cursor = self.cnx.cursor()
sql_status = "INSERT IGNORE INTO Status (name) VALUES (%(stat)s)"
status = [
'En attente de validation', 'En cours de préparation',
'En cours de livraison'
]
for i in status:
stat_add = {'stat': i}
cursor.execute(sql_status, stat_add)
self.cnx.commit()
cursor.close()
def insert_right(self):
cursor = self.cnx.cursor()
sql_right = "INSERT IGNORE INTO Right (name) VALUES (%(right_n)s)"
right_names = [
'Connexion', 'Regarder la carte', 'Passer commande',
'Voir recettes', 'Consulter stock'
]
for name in right_names:
name_add = {'right_n': name}
cursor.execute(sql_right, name_add)
self.cnx.commit()
cursor.close()
def insert_role(self):
cursor = self.cnx.cursor()
role = ['invité', 'client', 'employé']
sql_role = ("INSERT IGNORE INTO Role (name) " "VALUES (%(role_n)s)")
for r in role:
role_add = {'role_n': r}
cursor.execute(sql_role, role_add)
self.cnx.commit()
cursor.close()
def insert_role_right(self):
cursor = self.cnx.cursor()
sqlrole_r = "INSERT IGNORE INTO Role_has_Right Role_id"
def insert_user(self):
for _ in range(10):
self.fake.first_name()
self.fake.last_name()
self.fake.ascii_email()
self.fake.phone_number()
self.fake.password(length=12)
#!/usr/bin/python
from faker import Faker
fake = Faker()
print("{Fake Name Generator}\n")
print("Name: " + fake.name())
print("Country: " + fake.country())
print("City: " + fake.city())
print("State: " + fake.state())
print("Address: " + fake.address())
print("Zip Code: " + fake.zipcode())
print("Credit Card: " + fake.credit_card_number())
print("Credit Card Security Code: " + fake.credit_card_security_code())
print("Credit Card Expire Date: " +
fake.credit_card_expire(start="now", end="+10y", date_format="%m/%y"))
print("Birth Date: " + fake.date(pattern="%Y-%m-%d", end_datetime=None))
print("Email: " + fake.ascii_email())
print("Job: " + fake.job())
wait = input("\nPress [Enter] to go back...")
os.system("python3 DPredator.py")
class EventGenerator:
'''Generates a set of synthetic behavioral events, with timestamps constrained to a particular date.
'''
def __init__(self, start_date):
self.faker = Faker()
self.faker.add_provider(internet)
self.start_date = start_date
self.ua_generator = Randomize()
def _gen_user_agent(self):
devices = [
('desktop', 'mac'),
('desktop', 'windows'),
('tablet', 'ios'),
('smartphone', 'ios'),
('smartphone', 'android'),
]
ua = self.ua_generator.random_agent(*random.choice(devices))
return ua
def _gen_event_type(self):
'''Creates event type like "io.dagster.page_view".
'''
event_types = [
'page_view',
'button_click',
'reload',
'user_create',
'user_delete',
'signup',
]
return 'io.dagster.{}'.format(random.choice(event_types))
def _gen_timestamp(self):
midnight = datetime.datetime.combine(
self.start_date, datetime.time.min,
tzinfo=datetime.timezone.utc).timestamp()
return midnight + random.randint(0, 86400 - 1)
def __iter__(self):
return self
def __next__(self):
# pylint: disable=no-member
return json.dumps({
'environment':
'production',
'method':
'GET',
# Nested dicts
'cookies': {
'session': secrets.token_urlsafe(16),
'persistent': secrets.token_urlsafe(16),
},
'run_id':
self.faker.uuid4(),
'type':
self._gen_event_type(),
'user_agent':
self._gen_user_agent(),
'ip_address':
self.faker.ipv4_public(),
'timestamp':
self._gen_timestamp(),
'url':
'/' + self.faker.uri_path(),
# like any good production system, we throw some random PII in our behavioral events
'name':
self.faker.name(),
'email':
self.faker.ascii_email(),
# Nested lists
'location':
list(self.faker.location_on_land(coords_only=False)),
})
def test_registration(self, client: FlaskClient, faker: Faker) -> None:
# Always enabled during core tests
if not Env.get_bool("ALLOW_REGISTRATION"): # pragma: no cover
log.warning("User registration is disabled, skipping tests")
return
project_tile = get_project_configuration("project.title",
default="YourProject")
proto = "https" if PRODUCTION else "http"
# registration, empty input
r = client.post(f"{AUTH_URI}/profile")
assert r.status_code == 400
# registration, missing information
r = client.post(f"{AUTH_URI}/profile", data={"x": "y"})
assert r.status_code == 400
registration_data = {}
registration_data["password"] = faker.password(5)
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 400
registration_data["email"] = BaseAuthentication.default_user
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 400
registration_data["name"] = faker.first_name()
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 400
registration_data["surname"] = faker.last_name()
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 400
registration_data["password_confirm"] = faker.password(strong=True)
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 400
min_pwd_len = Env.get_int("AUTH_MIN_PASSWORD_LENGTH", 9999)
registration_data["password"] = faker.password(min_pwd_len - 1)
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 400
registration_data["password"] = faker.password(min_pwd_len)
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 409
m = f"This user already exists: {BaseAuthentication.default_user}"
assert self.get_content(r) == m
registration_data["email"] = faker.ascii_email()
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 409
assert self.get_content(
r) == "Your password doesn't match the confirmation"
registration_data["password"] = faker.password(min_pwd_len,
low=False,
up=True)
registration_data["password_confirm"] = registration_data["password"]
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 409
m = "Password is too weak, missing lower case letters"
assert self.get_content(r) == m
registration_data["password"] = faker.password(min_pwd_len, low=True)
registration_data["password_confirm"] = registration_data["password"]
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 409
m = "Password is too weak, missing upper case letters"
assert self.get_content(r) == m
registration_data["password"] = faker.password(min_pwd_len,
low=True,
up=True)
registration_data["password_confirm"] = registration_data["password"]
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 409
m = "Password is too weak, missing numbers"
assert self.get_content(r) == m
registration_data["password"] = faker.password(min_pwd_len,
low=True,
up=True,
digits=True)
registration_data["password_confirm"] = registration_data["password"]
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
assert r.status_code == 409
m = "Password is too weak, missing special characters"
assert self.get_content(r) == m
registration_data["password"] = faker.password(strong=True)
registration_data["password_confirm"] = registration_data["password"]
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
# now the user is created but INACTIVE, activation endpoint is needed
assert r.status_code == 200
registration_message = "We are sending an email to your email address where "
registration_message += "you will find the link to activate your account"
assert self.get_content(r) == registration_message
events = self.get_last_events(1)
assert events[0].event == Events.create.value
assert events[0].user == "-"
assert events[0].target_type == "User"
assert "name" in events[0].payload
assert "password" in events[0].payload
assert events[0].payload["password"] == OBSCURE_VALUE
mail = self.read_mock_email()
body = mail.get("body")
assert body is not None
assert mail.get("headers") is not None
# Subject: is a key in the MIMEText
assert f"Subject: {project_tile} account activation" in mail.get(
"headers")
assert f"{proto}://localhost/public/register/" in body
# This will fail because the user is not active
_, error = self.do_login(
client,
registration_data["email"],
registration_data["password"],
status_code=403,
)
assert error == "Sorry, this account is not active"
# Also password reset is not allowed
data = {"reset_email": registration_data["email"]}
r = client.post(f"{AUTH_URI}/reset", data=data)
assert r.status_code == 403
assert self.get_content(r) == "Sorry, this account is not active"
events = self.get_last_events(2)
assert events[0].event == Events.refused_login.value
assert events[0].payload["username"] == data["reset_email"]
assert events[0].payload["motivation"] == "account not active"
assert events[1].event == Events.refused_login.value
assert events[1].payload["username"] == data["reset_email"]
assert events[1].payload["motivation"] == "account not active"
# Activation, missing or wrong information
r = client.post(f"{AUTH_URI}/profile/activate")
assert r.status_code == 400
r = client.post(f"{AUTH_URI}/profile/activate", data=faker.pydict(2))
assert r.status_code == 400
# It isn't an email
invalid = faker.pystr(10)
r = client.post(f"{AUTH_URI}/profile/activate",
data={"username": invalid})
assert r.status_code == 400
headers, _ = self.do_login(client, None, None)
activation_message = "We are sending an email to your email address where "
activation_message += "you will find the link to activate your account"
# request activation, wrong username
r = client.post(f"{AUTH_URI}/profile/activate",
data={"username": faker.ascii_email()})
# return is 200, but no token will be generated and no mail will be sent
# but it respond with the activation msg and hides the non existence of the user
assert r.status_code == 200
assert self.get_content(r) == activation_message
events = self.get_last_events(1)
assert events[0].event != Events.activation.value
assert self.read_mock_email() is None
# request activation, correct username
r = client.post(
f"{AUTH_URI}/profile/activate",
data={"username": registration_data["email"]},
)
assert r.status_code == 200
assert self.get_content(r) == activation_message
mail = self.read_mock_email()
body = mail.get("body")
assert body is not None
assert mail.get("headers") is not None
# Subject: is a key in the MIMEText
assert f"Subject: {project_tile} account activation" in mail.get(
"headers")
assert f"{proto}://localhost/public/register/" in body
token = self.get_token_from_body(body)
assert token is not None
# profile activation
r = client.put(f"{AUTH_URI}/profile/activate/thisisatoken")
# this token is not valid
assert r.status_code == 400
# profile activation
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 200
assert self.get_content(r) == "Account activated"
events = self.get_last_events(1)
assert events[0].event == Events.activation.value
assert events[0].user == registration_data["email"]
assert events[0].target_type == "User"
# Activation token is no longer valid
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
assert self.get_content(r) == "Invalid activation token"
# Token created for another user
token = self.get_crafted_token("a")
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token"
# Token created for another user
token = self.get_crafted_token("a", wrong_algorithm=True)
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token"
# Token created for another user
token = self.get_crafted_token("a", wrong_secret=True)
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token"
headers, _ = self.do_login(client, None, None)
r = client.get(f"{AUTH_URI}/profile", headers=headers)
assert r.status_code == 200
uuid = self.get_content(r).get("uuid")
token = self.get_crafted_token("x", user_id=uuid)
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token"
# token created for the correct user, but from outside the system!!
token = self.get_crafted_token("a", user_id=uuid)
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token"
# Immature token
token = self.get_crafted_token("a", user_id=uuid, immature=True)
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token"
# Expired token
token = self.get_crafted_token("a", user_id=uuid, expired=True)
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token: this request is expired"
# Testing the following use case:
# 1 - user registration
# 2 - user activation using unconventional channel, e.g. by admins
# 3 - user tries to activate and fails because already active
registration_data["email"] = faker.ascii_email()
r = client.post(f"{AUTH_URI}/profile", data=registration_data)
# now the user is created but INACTIVE, activation endpoint is needed
assert r.status_code == 200
mail = self.read_mock_email()
body = mail.get("body")
assert body is not None
assert mail.get("headers") is not None
assert f"{proto}://localhost/public/register/" in body
token = self.get_token_from_body(body)
assert token is not None
headers, _ = self.do_login(client, None, None)
r = client.get(f"{API_URI}/admin/users", headers=headers)
assert r.status_code == 200
users = self.get_content(r)
uuid = None
for u in users:
if u.get("email") == registration_data["email"]:
uuid = u.get("uuid")
break
assert uuid is not None
r = client.put(f"{API_URI}/admin/users/{uuid}",
data={"is_active": True},
headers=headers)
assert r.status_code == 204
r = client.put(f"{AUTH_URI}/profile/activate/{token}")
assert r.status_code == 400
c = self.get_content(r)
assert c == "Invalid activation token: this request is no longer valid"
r = client.get(f"{API_URI}/admin/tokens", headers=headers)
content = self.get_content(r)
for t in content:
if t.get("token") == token: # pragma: no cover
pytest.fail(
"Token not properly invalidated, still bount to user {}",
t.get(id))
def test_authentication_abstract_methods(faker: Faker) -> None:
# Super trick!
# https://clamytoe.github.io/articles/2020/Mar/12/testing-abcs-with-abstract-methods-with-pytest
abstractmethods = BaseAuthentication.__abstractmethods__
BaseAuthentication.__abstractmethods__ = frozenset()
auth = Connector.get_authentication_instance()
user = auth.get_user(username=BaseAuthentication.default_user)
group = auth.get_group(name=DEFAULT_GROUP_NAME)
role = auth.get_roles()[0]
auth = BaseAuthentication() # type: ignore
assert (auth.get_user(username=faker.ascii_email(),
user_id=faker.pystr()) is None)
assert auth.get_users() is None
assert auth.save_user(user=user) is None
assert auth.delete_user(user=user) is None
assert auth.get_group(group_id=faker.pystr(),
name=faker.pystr()) is None
assert auth.get_groups() is None
assert auth.get_user_group(user=user) is None
assert auth.get_group_members(group=group) is None
assert auth.save_group(group=group) is None
assert auth.delete_group(group=group) is None
assert auth.get_tokens(
user=user, token_jti=faker.pystr(), get_all=True) is None
assert auth.verify_token_validity(jti=faker.pystr(), user=user) is None
assert (auth.save_token(user=user,
token=faker.pystr(),
payload={},
token_type=faker.pystr()) is None)
assert auth.invalidate_token(token=faker.pystr()) is None
assert auth.get_roles() is None
assert auth.get_roles_from_user(user=user) is None
assert auth.create_role(name=faker.pystr(),
description=faker.pystr()) is None
assert auth.save_role(role=role) is None
assert auth.create_user(userdata={}, roles=[faker.pystr()]) is None
assert auth.link_roles(user=user, roles=[faker.pystr()]) is None
assert auth.create_group(groupdata={}) is None
assert auth.add_user_to_group(user=user, group=group) is None
assert (auth.save_login(
username=faker.ascii_email(), user=user, failed=True) is None)
assert (auth.save_login(
username=faker.ascii_email(), user=None, failed=True) is None)
assert (auth.save_login(
username=faker.ascii_email(), user=user, failed=False) is None)
assert (auth.save_login(
username=faker.ascii_email(), user=None, failed=False) is None)
assert auth.get_logins(username=faker.ascii_email) is None
assert auth.flush_failed_logins(username=faker.ascii_email) is None
BaseAuthentication.__abstractmethods__ = abstractmethods
def test_tokens_management(self, client: FlaskClient,
faker: Faker) -> None:
auth = Connector.get_authentication_instance()
# Just to verify that the function works
verify_token_is_not_valid(auth, faker.pystr())
verify_token_is_not_valid(auth, faker.pystr(), auth.PWD_RESET)
verify_token_is_not_valid(auth, faker.pystr(), auth.ACTIVATE_ACCOUNT)
user = auth.get_user(username=BaseAuthentication.default_user)
t1, payload1 = auth.create_temporary_token(user, auth.PWD_RESET)
assert isinstance(t1, str)
# not valid if not saved
verify_token_is_not_valid(auth, t1, auth.PWD_RESET)
auth.save_token(user, t1, payload1, token_type=auth.PWD_RESET)
verify_token_is_not_valid(auth, t1)
verify_token_is_not_valid(auth, t1, auth.FULL_TOKEN)
verify_token_is_valid(auth, t1, auth.PWD_RESET)
verify_token_is_not_valid(auth, t1, auth.ACTIVATE_ACCOUNT)
verify_token_is_not_valid(auth, faker.ascii_email(), t1)
# Create another type of temporary token => t1 is still valid
t2, payload2 = auth.create_temporary_token(user, auth.ACTIVATE_ACCOUNT)
assert isinstance(t2, str)
# not valid if not saved
verify_token_is_not_valid(auth, t2, auth.ACTIVATE_ACCOUNT)
auth.save_token(user, t2, payload2, token_type=auth.ACTIVATE_ACCOUNT)
verify_token_is_not_valid(auth, t2)
verify_token_is_not_valid(auth, t2, auth.FULL_TOKEN)
verify_token_is_not_valid(auth, t2, auth.PWD_RESET)
verify_token_is_valid(auth, t2, auth.ACTIVATE_ACCOUNT)
verify_token_is_not_valid(auth, faker.ascii_email(), t2)
EXPIRATION = 3
# Create another token PWD_RESET, this will invalidate t1
t3, payload3 = auth.create_temporary_token(user,
auth.PWD_RESET,
duration=EXPIRATION)
assert isinstance(t3, str)
# not valid if not saved
verify_token_is_not_valid(auth, t3, auth.PWD_RESET)
auth.save_token(user, t3, payload3, token_type=auth.PWD_RESET)
verify_token_is_valid(auth, t3, auth.PWD_RESET)
verify_token_is_not_valid(auth, t1)
verify_token_is_not_valid(auth, t1, auth.FULL_TOKEN)
verify_token_is_not_valid(auth, t1, auth.PWD_RESET)
verify_token_is_not_valid(auth, t1, auth.ACTIVATE_ACCOUNT)
# Create another token ACTIVATE_ACCOUNT, this will invalidate t2
t4, payload4 = auth.create_temporary_token(user,
auth.ACTIVATE_ACCOUNT,
duration=EXPIRATION)
assert isinstance(t4, str)
# not valid if not saved
verify_token_is_not_valid(auth, t4, auth.ACTIVATE_ACCOUNT)
auth.save_token(user, t4, payload4, token_type=auth.ACTIVATE_ACCOUNT)
verify_token_is_valid(auth, t4, auth.ACTIVATE_ACCOUNT)
verify_token_is_not_valid(auth, t2)
verify_token_is_not_valid(auth, t2, auth.FULL_TOKEN)
verify_token_is_not_valid(auth, t2, auth.PWD_RESET)
verify_token_is_not_valid(auth, t2, auth.ACTIVATE_ACCOUNT)
# token expiration is only 3 seconds... let's test it
time.sleep(EXPIRATION + 1)
verify_token_is_not_valid(auth, t3, auth.PWD_RESET)
verify_token_is_not_valid(auth, t4, auth.ACTIVATE_ACCOUNT)
unpacked_token = auth.verify_token(None, raiseErrors=False)
assert not unpacked_token[0]
with pytest.raises(InvalidToken, match=r"Missing token"):
auth.verify_token(None, raiseErrors=True)
# Test token validiy
_, token = self.do_login(client, None, None)
tokens = auth.get_tokens(get_all=True)
jti = None
user = None
for t in tokens:
if t["token"] == token:
jti = t["id"]
user = t["user"]
break
assert jti is not None
assert user is not None
assert auth.verify_token_validity(jti, user)
# Verify token against a wrong user
another_user = auth.create_user(
{
"email": faker.ascii_email(),
"name": "Default",
"surname": "User",
"password": faker.password(strong=True),
"last_password_change": datetime.now(pytz.utc),
},
# It will be expanded with the default role
roles=[],
)
auth.save_user(another_user)
assert not auth.verify_token_validity(jti, another_user)
print("AM/PM:\t ", fake.am_pm())
print("This year:\t ", fake.date_this_year())
print("ISBN10:\t ", fake.isbn10())
print("Postal code in state:\t ", fake.postalcode_in_state())
print("Instance:\t ", fake.seed_instance())
print("Android platform token:\t ", fake.android_platform_token())
print("Data time:\t ", fake.date_time())
print("ISBN3:\t ", fake.isbn13())
print("Postal code plus 4:\t ", fake.postalcode_plus4())
print("Sentence:\t ", fake.sentence())
print("Email:\t ", fake.ascii_company_email())
print("Date time add:\t ", fake.date_time_ad())
print("ISO8601:\t ", fake.iso8601())
print("Postcode:\t ", fake.postcode())
print("Sentence:\t ", fake.sentences())
print("ASCII email:\t ", fake.ascii_email())
print("Date time beween:\t ", fake.date_time_between())
print("ITIN:\t ", fake.itin())
print("Postcode in state:\t ", fake.postcode_in_state())
# print("Set formatter:\t ", fake.set_formatter())
print("ASCII free email:\t ", fake.ascii_free_email())
print("Date time between dates:\t ", fake.date_time_between_dates())
print("Fake job:\t ", fake.job())
print("Prefix:\t ", fake.prefix())
print("SHA1:\t ", fake.sha1())
print("ASCII safe email:\t ", fake.ascii_safe_email())
print("Date time this country:\t ", fake.date_time_this_century())
print("Language code:\t ", fake.language_code())
print("Prefix female:\t ", fake.prefix_female())
print("SHA256:\t ", fake.sha256())
print("Bank country:\t", fake.bank_country())
def update_customers(customerFile, fileDate, Delta=False):
fake2 = Faker('en_AU')
fake2.seed_instance(43212)
fake = Faker('en_AU')
fake.seed_instance(4321)
with open(str(pathlib.Path(__file__).parent) + '/Data/customer/customer_' +
fileDate + '.csv',
'w',
newline='') as csvfile:
try:
custs = read_csv(
str(pathlib.Path(__file__).parent) +
'./Data/customer/customer_' + customerFile + '.csv')
except:
custs = read_csv('./Data/customer/customer_20200101.csv')
update_count = int(len(custs) * random.randint(1, 20) * 0.001)
insert_count = int(len(custs) * random.randint(0, 15) * 0.001)
logging.info("Generating update customer_" + fileDate +
".csv file with " + str(update_count) +
" updated customers and " + str(insert_count) +
" new customers")
csvwriter = csv.writer(csvfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
for i in range(update_count):
whatToChange = random.randint(1, 3)
random_cust = random.randint(1, len(custs) - 1)
#print(str(random_cust)+' '+str(whatToChange))
if (whatToChange == 1):
#print("hi")
custs[random_cust][4] = fake2.address().replace("\n", " ")
if (whatToChange == 2):
custs[random_cust][2] = fake2.ascii_email()
if (whatToChange == 3):
custs[random_cust][5] = fake2.city()
custs[random_cust][6] = fake2.state()
if (Delta == True):
csvwriter.writerow(custs[random_cust])
#print(custs)
if (Delta == False):
for customer in custs:
csvwriter.writerow(customer)
for i in range(insert_count):
person = fake.simple_profile(sex=None)
csvwriter.writerow([
fake.bban() + str(random.randint(1, 208888888888888888888)),
person['name'], person['mail'], person['birthdate'],
fake.address().replace("\n", " "),
fake.city(),
fake.state(),
fake.postcode(),
fake.date_between(start_date="-6y", end_date="today")
])
def seed_db():
from models.User import User
from models.Store import Store
from models.Product import Product
from models.Customer import Customer
from models.Order import Order
from main import bcrypt
from faker import Faker
faker = Faker()
users = []
stores = []
products = []
customers = []
for i in range(5):
user = User()
user.email = f"test{i+1}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
user.isAdmin = False
db.session.add(user)
users.append(user)
db.session.commit()
store = Store()
store.storename = faker.bs()
store.firstname = faker.first_name()
store.lastname = faker.last_name()
store.user_id = users[i].id
db.session.add(store)
stores.append(store)
db.session.commit()
for j in range(5):
product = Product()
product.title = faker.numerify(text="Duck ###")
product.price = faker.random_int(min=5, max=200, step=5)
product.store_id = stores[i].id
db.session.add(product)
products.append(product)
db.session.commit()
for j in range(5):
customer = Customer()
customer.firstname = faker.first_name()
customer.lastname = faker.last_name()
customer.email = faker.ascii_email()
customer.phone = faker.phone_number()
customer.store_id = stores[i].id
db.session.add(customer)
customers.append(customer)
db.session.commit()
for k in range(5):
order = Order()
order.order_placed = choice([True, False])
order.customer_id = choice(customers).id
db.session.add(order)
db.session.commit()
for m in range(3):
order.orders_products.append(choice(products))
db.session.commit()
customers = []
db.session.commit()
print("Tables seeded")
class Generator:
_username = set()
_image_counter = 0
def _gen_username(self):
username = self.fake.user_name()
if username in self._username:
self._gen_username()
else:
self._username.add(username)
return username
def __init__(
self,
number_of_users=None,
max_posts_per_user=None,
max_likes_per_user=None,
api_sleep=None,
start_date=None,
end_date=None,
max_post_length=None,
image_generation=None,
images_chance=None,
unsplash_key=None,
):
self.data = get_yaml('generator')
self.fake = Faker()
self.NUMBER_OF_USERS = number_of_users or hard_get(self.data, 'number_of_users')
self.MAX_POSTS_PER_USER = max_posts_per_user or hard_get(self.data, 'max_posts_per_user')
self.MAX_LIKES_PER_USER = max_likes_per_user or hard_get(self.data, 'max_likes_per_user')
self.API_SLEEP = api_sleep or soft_get(self.data, 'api_sleep', float)
self.START_DATETIME = start_date or soft_get(self.data, 'start_date', dt.date)
self.END_DATETIME = end_date or soft_get(self.data, 'end_date', dt.date)
self.MAX_POST_LENGTH = max_post_length or soft_get(self.data, 'max_post_length', int)
self.IMAGE_GENERATION = image_generation or soft_get(self.data, 'image_generation', bool)
if self.IMAGE_GENERATION:
self.IMAGES_CHANCE = images_chance or soft_get(self.data, 'images_chance', float)
self.UNSPLASH_KEY = unsplash_key or hard_get(self.data, 'unsplash_key')
@staticmethod
def generate_like(user):
post = choice(Post.objects.all())
like = Like.objects.get(post=post)
like.user.add(user)
def generate_post(self, user):
date = self.fake.date_time_between(
start_date=user.date_joined,
end_date=self.END_DATETIME,
tzinfo=timezone('Europe/Kiev'),
)
title = ' '.join(self.fake.words(
nb=randint(1, 5),
ext_word_list=None,
unique=False
)
).upper()
text = self.fake.text(max_nb_chars=randint(100, self.MAX_POST_LENGTH), ext_word_list=None)
post = Post(title=title,
text=text,
creator=user)
post.save()
if self.IMAGE_GENERATION:
chance = randint(1, 100)
if chance <= self.IMAGES_CHANCE * 100 and self._image_counter < 50:
self._image_counter += 1
response = r.request('GET', rf'http://api.unsplash.com/photos/random/?client_id={self.UNSPLASH_KEY}')
sleep(self.API_SLEEP)
content = response.content
content = content.decode("UTF-8")
content = json.loads(content)
url = content['urls']['regular']
response = r.request('GET', url)
sleep(self.API_SLEEP)
image = os.path.join(MEDIA_ROOT, 'posts', f'{post.id}.png')
with open(image, 'wb') as img:
img.write(response.content)
post.image = image
post.pub_date = date
post.save()
return post
def generate_user(self):
username = self._gen_username()
email = self.fake.ascii_email()
password = self.fake.ean(length=8)
first_name = self.fake.first_name()
last_name = self.fake.last_name()
date_joined = self.fake.date_time_between(
start_date=self.START_DATETIME,
end_date=self.END_DATETIME,
tzinfo=timezone('Europe/Kiev'),
)
profile_info = dict(
company=self.fake.company(),
role=self.fake.job(),
city=self.fake.city(),
country=self.fake.country(),
bio=self.fake.text(max_nb_chars=randint(50, 500)),
)
user = User(username=username,
email=email,
first_name=first_name,
last_name=last_name,
date_joined=date_joined)
user.set_password(password)
user.save()
profile = UserProfile.objects.get(owner=user)
for key, val in profile_info.items():
setattr(profile, key, val)
profile.save()
return user
def generation(self):
for i in range(self.NUMBER_OF_USERS):
print(f'{i+1} of {self.NUMBER_OF_USERS} user generation!').upper()
u = self.generate_user()
posts = randint(0, self.MAX_POSTS_PER_USER)
for ii in range(posts):
print(f'Post {ii+1}')
self.generate_post(u)
users = User.objects.all()
for user in users:
print('Generating Likes!').upper()
likes = randint(0, self.MAX_LIKES_PER_USER)
for _ in range(likes):
self.generate_like(user)
def test_01_login(self, client: FlaskClient, faker: Faker) -> None:
""" Check that you can login and receive back your token """
log.info("*** VERIFY CASE INSENSITIVE LOGIN")
# BaseAuthentication.load_default_user()
# BaseAuthentication.load_roles()
USER = BaseAuthentication.default_user or "just-to-prevent-None"
PWD = BaseAuthentication.default_password or "just-to-prevent-None"
# Login by using upper case username
self.do_login(client, USER.upper(), PWD)
events = self.get_last_events(1)
assert events[0].event == Events.login.value
assert events[0].user == USER
# Wrong credentials
# Off course PWD cannot be upper :D
self.do_login(client, USER, PWD.upper(), status_code=401)
events = self.get_last_events(1)
assert events[0].event == Events.failed_login.value
assert events[0].payload["username"] == USER
log.info("*** VERIFY valid credentials")
# Login by using normal username (no upper case)
headers, _ = self.do_login(client, None, None)
events = self.get_last_events(1)
assert events[0].event == Events.login.value
assert events[0].user == USER
time.sleep(5)
# Verify MAX_PASSWORD_VALIDITY, if set
headers, token = self.do_login(client, None, None)
events = self.get_last_events(1)
assert events[0].event == Events.login.value
assert events[0].user == USER
self.save("auth_header", headers)
self.save("auth_token", token)
# Verify credentials
r = client.get(f"{AUTH_URI}/status", headers=headers)
assert r.status_code == 200
c = self.get_content(r)
assert isinstance(c, bool) and c
# this check verifies a BUG with neo4j causing crash of auth module
# when using a non-email-username to authenticate
log.info("*** VERIFY with a non-email-username")
self.do_login(
client,
"notanemail",
"[A-Za-z0-9]+",
status_code=400,
)
# Check failure
log.info("*** VERIFY invalid credentials")
random_email = faker.ascii_email()
self.do_login(
client,
random_email,
faker.password(strong=True),
status_code=401,
)
events = self.get_last_events(1)
assert events[0].event == Events.failed_login.value
assert events[0].payload["username"] == random_email
def test_sendmail(self, client: FlaskClient, faker: Faker) -> None:
headers, _ = self.do_login(client, None, None)
r = client.get(f"{API_URI}/admin/mail", headers=headers)
assert r.status_code == 405
r = client.put(f"{API_URI}/admin/mail", headers=headers)
assert r.status_code == 405
r = client.patch(f"{API_URI}/admin/mail", headers=headers)
assert r.status_code == 405
r = client.delete(f"{API_URI}/admin/mail", headers=headers)
assert r.status_code == 405
data: Dict[str, Any] = {"dry_run": False}
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["subject"] = faker.pystr()
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["body"] = faker.text()
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["to"] = faker.pystr()
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["to"] = faker.ascii_email()
data["body"] = "TEST EMAIL BODY"
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 204
mail = self.read_mock_email()
body = mail.get("body", "")
assert "TEST EMAIL BODY" in body
data["dry_run"] = True
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 200
response = self.get_content(r)
assert isinstance(response, dict)
assert "html_body" in response
assert "plain_body" in response
assert "subject" in response
assert "to" in response
assert "cc" in response
assert "bcc" in response
data["dry_run"] = False
data["body"] = "TEST EMAIL <b>HTML</b> BODY"
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 204
mail = self.read_mock_email()
body = mail.get("body", "")
assert "TEST EMAIL <b>HTML</b> BODY" in body
data["dry_run"] = True
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 200
response = self.get_content(r)
assert isinstance(response, dict)
assert "html_body" in response
assert "plain_body" in response
assert "subject" in response
assert "to" in response
assert "cc" in response
assert "bcc" in response
data["dry_run"] = False
data["body"] = faker.text()
data["cc"] = faker.pystr()
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["cc"] = faker.ascii_email()
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 204
data["cc"] = f"{faker.ascii_email()},{faker.pystr()}"
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["cc"] = f"{faker.ascii_email()},{faker.ascii_email()}"
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 204
data["bcc"] = faker.pystr()
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["bcc"] = f"{faker.ascii_email()},{faker.pystr()}"
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 400
data["bcc"] = f"{faker.ascii_email()},{faker.ascii_email()}"
r = client.post(f"{API_URI}/admin/mail", json=data, headers=headers)
assert r.status_code == 204
mail = self.read_mock_email()
body = mail.get("body", "")
email_headers = mail.get("headers", "")
assert body is not None
assert email_headers is not None
# Subject: is a key in the MIMEText
assert f"Subject: {data['subject']}" in email_headers
ccs = mail.get("cc", [])
assert ccs[0] == data["to"]
assert ccs[1] == data["cc"].split(",")
assert ccs[2] == data["bcc"].split(",")
import mlab
from models.customer import Customer
from faker import Faker
from random import randint, choice
from cFake import *
mlab.connect()
fake = Faker()
for i in range(10):
print(i, "....")
g = randint(0, 1)
if g == 0:
n = female_name()
elif g == 1:
n = male_name()
customer = Customer(name=n,
yob=randint(1990, 2001),
gender=g,
email=fake.ascii_email(),
phone=sdt(),
address=tp(),
job=job(),
company=cty(),
contacted=choice([True, False]))
customer.save()
print("providers.geo".center(100,"="))
print(fake.coordinate())
print(fake.latitude())
print(fake.latlng())
print(fake.local_latlng())
print(fake.location_on_land())
print(fake.longitude())
print("providers.internet".center(100,"="))
print(fake.ascii_company_email())
print(fake.ascii_email())
print(fake.ascii_free_email())
print(fake.ascii_safe_email())
print(fake.company_email())
print(fake.dga())
print(fake.domain_name())
print(fake.domain_word())
print(fake.email())
print(fake.free_email())
print(fake.free_email_domain())
print(fake.hostname())
print(fake.http_method())
print(fake.image_url())
print(fake.ipv4())
print(fake.ipv4_network_class())
print(fake.ipv4_private())
