def test_incorrect_password(browser_is_opened):
github_main_page = MainPage(*browser_is_opened)
assert "GitHub" in github_main_page.title
github_main_page.password(User(password="******"))
join_github_page = JoinGithubPage(*browser_is_opened)
assert join_github_page.message_found(
"Password is weak and can be easily guessed")
def test_taken_email(browser_is_opened):
github_main_page = MainPage(*browser_is_opened)
assert "GitHub" in github_main_page.title
id_check_input = github_main_page.email(
User(email="*****@*****.**")).get_attribute("aria-describedby")
assert not github_main_page.check_input_field(
id_check_input, "Email is invalid or already taken")
def delete(self, post_id):
result = main_app.post_repo.request_delete(post_id,
User(**get_jwt_identity()))
if result is not None:
abort(400, message=result)
else:
return jsonify({"message": "success"})
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.votes = []
self.comments = []
self.upvote_percentage = []
if self.author:
self.author = User(**self.author)
def generate_random_user():
fake = Faker()
profile = fake.simple_profile()
last_name = profile["name"].split(' ')[1]
return User(username=profile["username"] + last_name,
email=last_name + profile["mail"],
password=fake.password())
def test_not_available_username_input(browser_is_opened):
github_main_page = MainPage(*browser_is_opened)
assert "GitHub" in github_main_page.title
user = User(username="******")
id_check_input = github_main_page.username(user).get_attribute(
"aria-describedby")
assert not github_main_page.check_input_field(
id_check_input, f"Username {user.username} is not available")
def request_create(self, username, password):
found = self.get_by_name(username)
if found is not None:
return None
new_user = User(id=self.next_id, username=username, password=password)
self.by_id[new_user.id] = new_user
self.next_id += 1
return new_user
def put(self, post_id):
args = parser.parse_args()
post = Post(**dict(args))
post.author = User(**get_jwt_identity())
result = main_app.post_repo.request_update(post_id, post.author, post)
if result is not None:
return abort(400, message=result)
return jsonify({'message': 'success'})
def test_incorrect_username_input(browser_is_opened):
github_main_page = MainPage(*browser_is_opened)
assert "GitHub" in github_main_page.title
id_check_input = github_main_page.username(
User(username="******")).get_attribute("aria-describedby")
assert not github_main_page.check_input_field(
id_check_input,
"Username may only contain alphanumeric characters or single hyphens,"
" and cannot begin or end with a hyphen.")
def add_post():
if not request.json:
return make_resp(jsonify({'message': 'Empty request'}), 400)
elif not check_keys(request.json, ("category", "type", "title")):
return make_resp(jsonify({'message': 'Bad request'}), 400)
post = Post(**request.json)
post.author = User(**get_jwt_identity())
post = app.post_repo.request_create(post)
return make_resp(jsonify(post), 200)
def request_create(self, username, password):
"""Create new user"""
found = self.get_by_name(username)
if found is not None:
return None # user with this name already created
new_user = User(id=self.next_id, username=username, password=password)
self.by_id[new_user.id] = new_user
self.next_id += 1
return new_user
def request_create(self, username, password):
found = self.get_by_name(username)
if found is not None:
return None # пользователь с таким именем уже есть
new_user = User(id=self.next_id, username=username, password=password)
self.by_id[new_user.id] = new_user
self.next_id += 1
return new_user
def add_post():
in_json = request.json
if not in_json:
return make_resp(jsonify({'message': "Empty request"}), 400)
elif not check_keys(in_json, ('category', "type", 'title')):
return make_resp((jsonify({'message': "Bad request"})), 400)
post = Post(**in_json)
post.author = User(**get_jwt_identity())
post = app.post_repo.request_create(post)
return make_resp(jsonify(post), 200)
def create_user(self, name: str, session_id: str = None) -> User:
if self.name_exists(name):
usr = self.by_name(name)
if self.is_expired(usr.id):
log.debug(f'User {name} exists, but its expired, removing')
self.delete_user(usr.id)
else:
raise UserAlreadyExistsError(payload={'username': name})
user = User(name, session_id)
self.users[user.id] = user
return user
def generate_user(nums,write_into_database=True):
user_list = []
fake = Faker()
id = 0
while id <= nums:
user = User(fake.name(), fake.address(), fake.job(),random.randint(10,100))
if write_into_database:
repo = UserRepository()
repo.insert_document(DAO,user_data=user.serialize(),collection='user_collection')
user_list.append(user)
id += 1
return user_list
def registerUser():
"""
Use the given username and password to create a user if it doesn't already exist
"""
if User.user_name_exists(request.args['username']):
return "-1"
else:
user = User(user_name=request.args['username'],
password=request.args['password'],
recent_results=['1', '2', '3'])
db.session.add(user)
db.session.commit()
login_user(user)
return "ok"
def get_user(self, user_id):
"""Gets a user from the database"""
cursor = self.connection.cursor()
cursor.execute("SELECT * FROM users where userID = %s", (user_id, ))
row = cursor.fetchone()
if row:
data = {
'name': row[1],
'authentication_method': row[2],
'password': row[3],
'active': row[4],
'authenticated': row[5],
'roles': self.get_roles(row[0])
}
return User(self, user_id, data)
def create_user(_admin_user):
params = assert_data_has_keys(request, {'email', 'password', 'name', 'role'})
if params['role'] not in ['admin', 'provider']:
raise WebError('Role must be either "admin" or "provider"', 400)
id = str(uuid.uuid4())
language = params.get('language', 'en')
name_str = LanguageString(id=str(uuid.uuid4()), content_by_language={language: params['name']})
hashed_password = bcrypt.hashpw(params['password'].encode(), bcrypt.gensalt()).decode()
user = User(id, name_str, params['role'], params['email'], hashed_password)
try:
add_user(user)
except psycopg2.errors.UniqueViolation:
raise WebError('User already exists', 409)
all_users = [User.from_db_row(r).to_dict() for r in all_user_data()]
return jsonify({'users': all_users})
def get_all_users(self):
"""Gets All users from the database"""
cursor = self.connection.cursor()
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
user_list = []
for row in rows:
data = {
'name': row[1],
'authentication_method': row[2],
'password': row[3],
'active': row[4],
'authenticated': row[5],
'roles': self.get_roles(row[0])
}
user_list.append(User(self, row[0], data))
return user_list
def create_user():
user = User(**request.get_json())
repo = UserRepo(FirebaseUserDataClient())
return json.dumps(repo.create(user))
def create_jwt_generate_response(user):
cp_user = User(**user)
del cp_user['password']
j_token = {'token': create_jwt(identity=cp_user)}
return make_resp(jsonify(j_token), 200)
def createUser(self,
isAnalogueEnabled: bool = False,
isCatJamEnabled: bool = False,
isChatBandEnabled: bool = False,
isCutenessEnabled: bool = False,
isCynanMessageEnabled: bool = False,
isCynanSourceEnabled: bool = False,
isDeerForceMessageEnabled: bool = False,
isGiveCutenessEnabled: bool = False,
isJamCatEnabled: bool = False,
isJishoEnabled: bool = False,
isJokesEnabled: bool = False,
isJokeTriviaRepositoryEnabled: bool = False,
isPicOfTheDayEnabled: bool = False,
isPkmnEnabled: bool = False,
isPokepediaEnabled: bool = False,
isRaceEnabled: bool = False,
isRaidLinkMessagingEnabled: bool = False,
isRatJamEnabled: bool = False,
isRewardIdPrintingEnabled: bool = False,
isStarWarsQuotesEnabled: bool = False,
isTamalesEnabled: bool = False,
isTranslateEnabled: bool = False,
isTriviaEnabled: bool = False,
isTriviaGameEnabled: bool = False,
isWeatherEnabled: bool = False,
isWordOfTheDayEnabled: bool = False,
triviaGamePoints: int = 5,
triviaGameTutorialCutenessThreshold: int = 50,
waitForTriviaAnswerDelay: int = 45,
discord: str = None,
handle: str = "TestUser",
increaseCutenessDoubleRewardId: str = None,
instagram: str = None,
locationId: str = None,
picOfTheDayFile: str = None,
picOfTheDayRewardId: str = None,
pkmnBattleRewardId: str = None,
pkmnEvolveRewardId: str = None,
pkmnShinyRewardId: str = None,
speedrunProfile: str = None,
triviaGameRewardId: str = None,
twitter: str = None,
cutenessBoosterPacks: List[CutenessBoosterPack] = None,
pkmnCatchBoosterPacks: List[PkmnCatchBoosterPack] = None,
timeZones: List[tzinfo] = None) -> User:
return User(
isAnalogueEnabled=isAnalogueEnabled,
isCatJamEnabled=isCatJamEnabled,
isChatBandEnabled=isChatBandEnabled,
isCutenessEnabled=isCutenessEnabled,
isCynanMessageEnabled=isCynanMessageEnabled,
isCynanSourceEnabled=isCynanSourceEnabled,
isDeerForceMessageEnabled=isDeerForceMessageEnabled,
isGiveCutenessEnabled=isGiveCutenessEnabled,
isJamCatEnabled=isJamCatEnabled,
isJishoEnabled=isJishoEnabled,
isJokesEnabled=isJokesEnabled,
isJokeTriviaRepositoryEnabled=isJokeTriviaRepositoryEnabled,
isPicOfTheDayEnabled=isPicOfTheDayEnabled,
isPkmnEnabled=isPkmnEnabled,
isPokepediaEnabled=isPokepediaEnabled,
isRaceEnabled=isRaceEnabled,
isRaidLinkMessagingEnabled=isRaidLinkMessagingEnabled,
isRatJamEnabled=isRatJamEnabled,
isRewardIdPrintingEnabled=isRewardIdPrintingEnabled,
isStarWarsQuotesEnabled=isStarWarsQuotesEnabled,
isTamalesEnabled=isTamalesEnabled,
isTranslateEnabled=isTranslateEnabled,
isTriviaEnabled=isTriviaEnabled,
isTriviaGameEnabled=isTriviaGameEnabled,
isWeatherEnabled=isWeatherEnabled,
isWordOfTheDayEnabled=isWordOfTheDayEnabled,
triviaGamePoints=triviaGamePoints,
triviaGameTutorialCutenessThreshold=
triviaGameTutorialCutenessThreshold,
waitForTriviaAnswerDelay=waitForTriviaAnswerDelay,
discord=discord,
handle=handle,
increaseCutenessDoubleRewardId=increaseCutenessDoubleRewardId,
instagram=instagram,
locationId=locationId,
picOfTheDayFile=picOfTheDayFile,
picOfTheDayRewardId=picOfTheDayRewardId,
pkmnBattleRewardId=pkmnBattleRewardId,
pkmnEvolveRewardId=pkmnEvolveRewardId,
pkmnShinyRewardId=pkmnShinyRewardId,
speedrunProfile=speedrunProfile,
triviaGameRewardId=triviaGameRewardId,
twitter=twitter,
cutenessBoosterPacks=cutenessBoosterPacks,
pkmnCatchBoosterPacks=pkmnCatchBoosterPacks,
timeZones=timeZones)
from users.user import User
from users.data_access import add_user
from language_strings.language_string import LanguageString
import uuid
import sys
import bcrypt
name = sys.argv[1]
email_address = sys.argv[2]
password = sys.argv[3]
role = 'super_admin'
id = str(uuid.uuid4())
name_str = LanguageString(id=str(uuid.uuid4()), content_by_language={'en': name})
hashed_password = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
user = User(id, name_str, role, email_address, hashed_password)
add_user(user)
def add_user(self, username, password):
user = User(username, password)
self.users.append(user)
def __init__(self, **kwargs):
super().__init__(**kwargs)
if self.author:
self.author = User(**self.author)
def delete_post_by_id(post_id):
result = app.post_repo.request_delete(post_id, User(**get_jwt_identity()))
if result:
return make_resp(jsonify({'message': result}), 400)
else:
return make_resp(jsonify({'message': 'success'}), 200)
def delete_post_by_id(post_id):
result = app.post_repo.request_delete(post_id, User(**get_jwt_identity()))
if result is not None:
return make_resp(jsonify({"message": result}), 400)
else:
return make_resp(jsonify({"message": "success"}), 200)
model_camry = Model(1, 'Camry', 6000)
model_corolla = Model(2, 'Corolla', 5000)
gearbox_manual = Gearbox(0, 'Manual', 150)
gearbox_auto = Gearbox(1, 'Auto', 300)
gearbox_var = Gearbox(2, 'Variator', 250)
capacity_two = EngineCapacity(0, '2.0', 700)
capacity_two_point_five = EngineCapacity(1, '2.5', 900)
capacity_two_point_eight = EngineCapacity(2, '2.8', 1000)
car_1 = CarBase(model_landCruiser.id, colour_black.id, gearbox_auto.id, capacity_two_point_five.id)
car_2 = CarBase(model_corolla.id, colour_pink.id, gearbox_auto.id, capacity_two_point_five.id)
# Add users
admin = User('admin', True)
admin.set_password('password')
user = User('user', False)
user.set_password('pass')
# Generate db schema
with app.app_context():
db.create_all()
# Add data to DB
db.session.add(colour_pink)
db.session.add(colour_black)
db.session.add(colour_white)
db.session.add(model_landCruiser)
db.session.add(model_camry)
def create_jwt_for_user(user):
cp_user = User(**user)
del cp_user['password']
j_token = {'token': create_jwt(identity=cp_user)}
return j_token
def post(self):
args = parser.parse_args()
post = Post(**dict(args))
post.author = User(**get_jwt_identity())
post = main_app.post_repo.request_create(post)
return jsonify(post)
