async def method_post(self, request: Request, body: dict, session, *args,
**kwargs) -> BaseHTTPResponse:
request_model = RequestCreateEmployeeDto(body)
try:
hashed_password = generate_hash(request_model.password)
except GeneratePasswordHashException as e:
raise SanicPasswordHashException(str(e))
try:
db_employee = employee_queries.create_employee(
session, request_model, hashed_password)
except DBEmployeeExistsException:
raise SanicEmployeeConflictException('Login is busy')
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseEmployeeDto(db_employee)
return await self.make_response_json(body=response_model.dump(),
status=201)
async def test_post_auth_endpoint(request_factory, patched_context, mocker):
password = '******'
hsh_ = generate_hash(password)
db_user = DBUser(
id=1,
login='******',
password=hsh_
)
patched_query = mocker.patch('db.queries.user.get_user')
patched_query.return_value = db_user
json_data = {
'login': '******',
'password': password
}
request = request_factory(
method='post',
content_type='application/json',
json=json_data
)
endpoint = AuthUserEndpoint(None, patched_context, '/auth', ['POST'])
response = await endpoint(request)
assert response.status == 200
async def method_patch(self, request: Request, body: dict,
session: DBSession, token: dict, *args,
**kwargs) -> BaseHTTPResponse:
request_model = RequestPatchUserDto(body)
hashed_password = None
if hasattr(request_model, 'password'):
hashed_password = generate_hash(request_model.password)
try:
user = user_queries.patch_user(session,
request_model,
token['id_auth'],
hashed_password=hashed_password)
except DBLoginExistsException:
raise SanicLoginExistsException('login exits')
try:
session.commit_session()
except (DBDataError, DBIntegrityError) as error:
raise SanicDBException(str(error))
response_model = ResponsePatchUserDto(user)
return await self.make_response_json(status=200,
body=response_model.dump())
async def test_post_user_endpoint(request_factory, patched_context, mocker):
password = '******'
hsh_ = generate_hash(password)
json_data = {
'login': '******',
'password': password,
'first_name': 'Alexey',
'last_name': 'Dorin',
}
request = request_factory(method='post',
content_type='application/json',
json=json_data)
db_user = DBUser(id=1,
login=json_data['login'],
first_name=json_data['first_name'],
last_name=json_data['last_name'],
password=hsh_)
patched_query = mocker.patch('db.queries.user.create_user')
patched_query.return_value = db_user
endpoint = CreateUserEndpoint(None, patched_context, '/user', ['POST'])
response = await endpoint(request)
assert response.status == 201
async def test_patch_user_endpoint(request_factory, patched_context,
request_header_authorization, mocker):
password = '******'
hsh_ = generate_hash(password)
db_user = DBUser(id=1,
login='******',
first_name='Alexei',
last_name='Dori',
password=hsh_)
json_data = {
'first_name': 'Lech',
'last_name': 'Dorin',
}
request = request_factory(method='patch',
headers=request_header_authorization,
content_type='application/json',
json=json_data)
patched_query = mocker.patch('db.queries.user.get_user')
patched_query.return_value = db_user
db_user.first_name = json_data['first_name']
db_user.last_name = json_data['last_name']
patched_query = mocker.patch('db.queries.user.patch_user')
patched_query.return_value = db_user
endpoint = UserEndpoint(None,
patched_context,
'/user/1', ['PATCH'],
auth_required=True)
response = await endpoint(request, uid=1)
assert response.status == 200
async def method_post(self, request: Request, body: dict, session, *args,
**kwargs) -> BaseHTTPResponse:
request_model = RequestCreateUserDto(body)
try:
hashed_password = generate_hash(request_model.password)
except GeneratePasswordHashException as e:
raise SanicPasswordHashException(str(e))
try:
db_user = create_user(session,
user=request_model,
hashed_password=hashed_password)
except DBUserExists:
raise SanicUserConflictException("Login is busy")
try:
session.commit_session()
except (DBDataException, DBIntegrityException) as e:
raise SanicDBException(str(e))
response_model = ResponseUserDto(db_user)
return await self.make_response_json(body=response_model.dump(),
status=201)
async def method_post(self, request: Request, body: dict,
session: DBSession, *args,
**kwargs) -> BaseHTTPResponse:
req_model = ReqCreateUserDTO(body)
hash_pass = generate_hash(req_model.password)
try:
db_user = user_query.create_user(session, req_model, hash_pass)
except DBUserExistsException:
raise SanicUserConflictException("User already exist")
try:
session.commit()
except (DBIntegrityException, DBDataException):
raise SanicDBException
response_model = ResGetUserDTO(db_user)
return await self.make_response_json(body=response_model.dump(),
status=201)
async def method_post(self, request: Request, body: dict,
session: DBSession, *args,
**kwargs) -> BaseHTTPResponse:
request_model = RequestCreateUserDto(body)
try:
hashed_password = generate_hash(request_model.password)
user_queries.create_user(session=session,
user=request_model,
hashed_password=hashed_password)
session.commit_session()
except GeneratePasswordHashException as error:
raise SanicPasswordHashException(str(error))
except DBLoginExistsException:
raise SanicLoginExistsException('login exits')
except (DBDataError, DBIntegrityError) as error:
raise SanicDBException(str(error))
return await self.make_response_json(status=201)
async def test_get_user_endpoint(request_factory, patched_context,
request_header_authorization, mocker):
password = '******'
hsh_ = generate_hash(password)
request = request_factory(method='get',
headers=request_header_authorization)
db_user = DBUser(id=1,
login='******',
first_name='Alexey',
last_name='Dorin',
password=hsh_)
patched_query = mocker.patch('db.queries.user.get_user')
patched_query.return_value = db_user
endpoint = UserEndpoint(None,
patched_context,
'/user/1', ['GET'],
auth_required=True)
response = await endpoint(request, uid=1)
assert response.status == 200
def hash_password(self, data: dict, **kwargs) -> dict:
password = data['password']
hashed_password = generate_hash(password)
data['password'] = hashed_password
return data
def test_invalid_password_hash(password_data):
hsh_ = generate_hash(password_data['password3'])
with pytest.raises(CheckPasswordHashException):
check_hash(password_data['password'], hsh_)
def test_valid_password_hash(password_data):
hsh_ = generate_hash(password_data['password2'])
assert check_hash(password_data['password'], hsh_) is None
