def test_create_user_with_valid_data(self, create_valid_data):
session = get_session()
encoded_jwt = auth_services.create_user(session, create_valid_data,
UserRepository)
assert encoded_jwt["token"] != None
def test_create_music_with_valid_tag(self, create_valid_data,
create_valid_data_music_tag,
user_info):
session = get_session()
tag = music_tag_services.create_music_tag(
session,
{
**create_valid_data_music_tag, "user_id": user_info["id"]
},
MusicTagRepository,
)
music = music_services.insert_music(
session,
{
**create_valid_data, "user_id": user_info["id"],
"tag_id": tag.id
},
MusicRepository,
)
assert music.name == create_valid_data["name"]
assert music.artist == create_valid_data["artist"]
assert music.info == create_valid_data["info"]
assert music.album == create_valid_data["album"]
assert music.tag_id == tag.id
def music_tag_route(id_):
session = get_session()
try:
if request.method == "PUT":
music_tag = update_music_tag(
session,
{
**request.json,
"id": id_,
"user_id": request.user_info["id"],
},
MusicTagRepository,
)
response = music_tag.dict()
else:
response = delete_music_tag(
session,
{
"id": id_,
"user_id": request.user_info["id"],
},
MusicTagRepository,
)
return response, 200
except Exception:
if request.method == "PUT":
return "Não foi possível atualizar tag", 400
else:
return "Não foi possível deletar tag", 400
def test_insert_with_invalid_data(self, invalid_data, user_info):
session = get_session()
with pytest.raises(ValidationError):
create_music_tag(session, {
**invalid_data, "user_id": user_info["id"]
}, MusicTagRepository)
def test_login_with_valid_data(self, create_valid_data):
session = get_session()
self.test_register_with_valid_data(create_valid_data)
response = auth_services.login(session, create_valid_data,
UserRepository)
assert "token" in response.keys()
def test_register_with_valid_data(self, create_valid_data):
session = get_session()
encoded_jwt = auth_services.create_user(session, create_valid_data,
UserRepository)
decoded_token = auth_services.validate_token(encoded_jwt["token"])
assert decoded_token["id"] == 1
def test_create_music_with_invalid_tag(self, create_valid_data, user_info):
session = get_session()
with pytest.raises(Exception):
music_services.insert_music(
session, {
**create_valid_data, "user_id": user_info["id"],
"tag_id": 1
})
def test_login_with_invalid_password(self, create_valid_data):
session = get_session()
self.test_register_with_valid_data(create_valid_data)
with pytest.raises(Exception):
auth_services.login(session, {
**create_valid_data, "password": "******"
})
def test_insert_with_valid_data(self, valid_data, user_info):
session = get_session()
music_tag = create_music_tag(session, {
**valid_data, "user_id": user_info["id"]
}, MusicTagRepository)
assert music_tag.name == valid_data["name"]
assert music_tag.id == user_info["id"]
def user_musics():
try:
session = get_session()
musics = music_services.list_user_musics(session,
request.user_info["id"],
UserRepository)
return json.dumps(musics), 200
except:
return "Não foi possível efetivar pesquisa.", 200
def get_valid_user_fixture():
user_data = {
"name": "Pedro",
"email": "*****@*****.**",
"password": "******",
}
session = get_session()
jwt = auth_services.create_user(session, user_data, UserRepository)
return jwt
def login_route():
session = get_session()
try:
response = auth_services.login(session, dict(request.json),
UserRepository)
return response, 200
except ValidationError:
return exceptions.auth_validation_error, 400
except Exception as error:
return error.message, 400
def register_route():
session = get_session()
try:
user = auth_services.create_user(session, dict(request.json),
UserRepository)
return user, 201
except ValidationError:
return exceptions.auth_validation_error, 400
except Exception as error:
return error.message, 400
def test_insert_music_with_valid_data(self, create_valid_data, user_info):
session = get_session()
music = music_services.insert_music(
session, {
**create_valid_data, "user_id": user_info["id"]
}, MusicRepository)
assert music.name == create_valid_data["name"]
assert music.artist == create_valid_data["artist"]
assert music.info == create_valid_data["info"]
def test_login_with_invalid_email(self, create_valid_data,
create_invalid_data):
session = get_session()
self.test_register_with_valid_data(create_valid_data)
with pytest.raises(Exception):
auth_services.login(
session, {
**create_valid_data, "email": create_invalid_data["email"]
})
def test_create_user_with_invalid_name(self, create_valid_data,
create_invalid_data):
session = get_session()
with pytest.raises(ValidationError):
auth_services.create_user(
session,
{
**create_valid_data, "name": create_invalid_data["name"]
},
UserRepository,
)
def get_valid_user_fixture():
user_data = {
"name": "João",
"email": "*****@*****.**",
"password": "******",
}
session = get_session()
jwt = auth_services.create_user(session, user_data, UserRepository)
user_info = auth_services.validate_token(jwt["token"])
user_info["token"] = jwt["token"]
return user_info
def test_insert_music_with_invalid_user_id(self, create_valid_data,
create_invalid_data, user_info):
session = get_session()
with pytest.raises(Exception):
music_services.insert_music(
session,
{
**create_valid_data,
"user_id": 17,
},
MusicRepository,
)
def test_insert_music_with_invalid_artist(self, create_valid_data,
create_invalid_data, user_info):
session = get_session()
with pytest.raises(ValidationError):
music_services.insert_music(
session,
{
**create_valid_data,
"artist": create_invalid_data["artist"],
"user_id": user_info["id"],
},
MusicRepository,
)
def test_list_musics_with_valid_data(self, create_valid_data_list,
user_info):
session = get_session()
for music in create_valid_data_list:
music_services.insert_music(session, music, MusicRepository)
musics = music_services.list_user_musics(session, user_info["id"],
UserRepository)
for music_arg, music_added in zip(create_valid_data_list, musics):
assert music_arg["name"] == music_added.name
assert music_arg["artist"] == music_added.artist
assert music_arg["info"] == music_added.info
def test_update_valid_data(self, create_valid_data, update_valid_data):
session = get_session()
encoded_jwt = auth_services.create_user(session, create_valid_data,
UserRepository)
user_info = auth_services.validate_token(encoded_jwt["token"])
user_services.update_user_data(
session, {
**update_valid_data, "id": user_info["id"]
}, UserRepository)
user = user_services.find_user(session, {"id": user_info["id"]},
UserRepository)
assert user["name"] == update_valid_data["name"]
assert user["email"] == update_valid_data["email"]
def music_route():
session = get_session()
try:
music = music_services.insert_music(
session,
{
**dict(request.json), "user_id": request.user_info["id"]
},
MusicRepository,
)
return music.dict(), 200
except ValidationError as e:
error = CustomValidationError(e)
return error.message, 400
except Exception as error:
return error.message, 400
def create_route():
session = get_session()
try:
if request.method == "POST":
music_tag = {**request.json, "user_id": request.user_info["id"]}
music_tag = create_music_tag(session, music_tag,
MusicTagRepository)
else:
music_tag = get_music_tag(session, request.user_info["id"],
MusicTagRepository)
return jsonify([tag.dict() for tag in music_tag]), 200
return music_tag.dict(), 201
except Exception:
if request.method == "POST":
return "Não foi possível criar tag", 400
else:
return "Não foi possível localizar tag", 400
def test_insert_with_invalid_user(self, valid_data):
session = get_session()
with pytest.raises(Exception):
create_music_tag(session, {**valid_data, "user_id": 1})
