class TestSqlServerPlaylistRepository(unittest.TestCase):
def setUp(self):
self.repo = SqlServerPlaylistRepository()
self.listPlaylist = self.repo.get_playlist_of_account("d771a0a6-1f92-4e5e-918d-966e3c1f7b4f")
self.playlist: Playlist = Playlist(2,None, None, None,True,None)
def test_get_playlist_of_account_account_exists(self):
self.assertIsNotNone(self.listPlaylist)
def test_get_playlist_of_account_correct_account(self):
self.assertEqual(self.listPlaylist[0].account.idAccount, "d771a0a6-1f92-4e5e-918d-966e3c1f7b4f")
def test_get_playlist_of_account_accoun_not_exists(self):
listPlaylist = self.repo.get_playlist_of_account("notexists")
self.assertListEqual(listPlaylist,[])
def test_update_succesful(self):
self.playlist.title = "Running"
self.playlist.cover = "defaultPlaylistCover.jpeg"
result = self.repo.update(self.playlist)
self.assertTrue(result)
def test_update_playlist_not_exists(self):
self.playlist.idPlaylist = -1
self.playlist.title = "Running"
self.playlist.cover = "defaultPlaylistCover.jpeg"
result = self.repo.update(self.playlist)
self.assertFalse(result)
def delete(self, idPlaylist):
exists_usecase = exists_playlist.ExistsPlaylist(
SqlServerPlaylistRepository())
delete_usecase = delete_playlist.DeletePlaylist(
SqlServerPlaylistRepository())
try:
if exists_usecase.execute(idPlaylist):
if delete_usecase.execute(idPlaylist):
return {}, 200
except EmptyFieldsException as ex:
return {"error": str(ex)}, 400
except PlaylistNotExistException as ex:
return {"error": str(ex)}, 404
except DataBaseException as ex:
return {"error": str(ex)}, 500
def get(self, queryCriterion):
try:
usecase = search_playlist.SearchPlaylist(SqlServerPlaylistRepository())
list_playlists = usecase.execute(queryCriterion)
return [ob.to_json() for ob in list_playlists], 200
except PlaylistInvalidException as ex:
return {"error": str(ex)}, 400
except PlaylistNotExistException as ex:
return {"error": str(ex)}, 400
except Exception as ex:
return {"error": str(ex)}, 500
def post(self, idPlaylist, idTrack):
exists_usecase = exists_playlist.ExistsPlaylist(
SqlServerPlaylistRepository())
exists_track_usecase = exists_track_playlist.ExistsTrackPlaylist(
SqlServerPlaylistRepository())
add_usecase = add_track_to_playlist.AddTrackPlaylist(
SqlServerPlaylistRepository())
try:
if exists_usecase.execute(idPlaylist):
if exists_track_usecase.execute(idPlaylist, idTrack):
return {"error": "Track already exists in playlist"}, 400
else:
if add_usecase.execute(idPlaylist, idTrack):
return {}, 201
except EmptyFieldsException as ex:
return {"error": str(ex)}, 400
except PlaylistNotExistException as ex:
return {"error": str(ex)}, 404
except DataBaseException as ex:
return {"error": str(ex)}, 500
pass
def delete(self, idPlaylist, idTrack):
exists_usecase = exists_playlist.ExistsPlaylist(
SqlServerPlaylistRepository())
exists_track_usecase = exists_track_playlist.ExistsTrackPlaylist(
SqlServerPlaylistRepository())
remove_usecase = remove_track_to_playlist.RemoveTrackPlaylist(
SqlServerPlaylistRepository())
try:
if exists_usecase.execute(idPlaylist):
if not exists_track_usecase.execute(idPlaylist, idTrack):
return {"error": "Track not exists in playlist"}, 404
else:
if remove_usecase.execute(idPlaylist, idTrack):
return {}, 200
except EmptyFieldsException as ex:
return {"error": str(ex)}, 400
except PlaylistNotExistException as ex:
return {"error": str(ex)}, 404
except DataBaseException as ex:
return {"error": str(ex)}, 500
pass
def put(self, idPlaylist):
update_usecase = update_playlist.UpdatePlaylist(
SqlServerPlaylistRepository())
exists_usecase = exists_playlist.ExistsPlaylist(
SqlServerPlaylistRepository())
dtoclass = update_playlist.UpdatePlaylistInputDto(
idPlaylist,
request.json["title"],
request.json["cover"],
request.json["publicPlaylist"],
request.json["idAccount"],
)
try:
if exists_usecase.execute(dtoclass.idPlaylist):
if update_usecase.execute(dtoclass):
return {}, 200
except PlaylistNotExistException as ex:
return {"error": str(ex)}, 404
except PlaylistInvalidException as ex:
return {"error": str(ex)}, 404
except DataBaseException as ex:
return {"error": str(ex)}, 500
def post(self):
usecase = create_playlist.CreatePlaylist(SqlServerPlaylistRepository())
dtoclass = create_playlist.CreatePlaylistInputDto(
request.json["title"],
request.json["cover"],
request.json["publicPlaylist"],
request.json["idPlaylistType"],
request.json["idAccount"],
)
try:
playlist = usecase.execute(dtoclass)
return playlist.to_json_create(), 200
except PlaylistInvalidException as ex:
return {"error": str(ex)}, 404
except DataBaseException as ex:
return {"error": str(ex)}, 500
def get(self, idAccount):
usecase = GetPlaylistForAccount(SqlServerPlaylistRepository())
try:
usecaseAccount = ExistAccount(SqlServerAccountRepository())
if not usecaseAccount.execute(idAccount):
response = jsonify({'error': 'Account not exist'})
response.status_code = 404
return response
playlits = usecase.execute(idAccount)
return jsonify([ob.to_json() for ob in playlits])
except EmptyFieldsException as ex:
error = str(ex)
response = jsonify({'error': error})
response.status_code = 400
return response
except DataBaseException:
error = str(ex)
response = jsonify({'error': error})
response.status_code = 500
return response
class TestGetPlaylistForAccount(unittest.TestCase):
def test_Empty_Fields(self):
case = GetPlaylistForAccount(SqlServerPlaylistRepository())
self.assertRaises(EmptyFieldsException, case.execute, None)
import sys
sys.path.append("")
from playlists.playlists.application.use_cases.get_playlist_of_account import GetPlaylistForAccount
from infraestructure.sqlserver_repository_playlist import SqlServerPlaylistRepository
from playlists.playlists.domain.exceptions import EmptyFieldsException
import unittest
class TestGetPlaylistForAccount(unittest.TestCase):
def test_Empty_Fields(self):
case = GetPlaylistForAccount(SqlServerPlaylistRepository())
self.assertRaises(EmptyFieldsException, case.execute, None)
def test_not_exists_account(self):
case = GetPlaylistForAccount(SqlServerPlaylistRepository())
result = case.execute("Noexits")
self.assertEqual(result, [])
def test_exists_account(self):
case = GetPlaylistForAccount(SqlServerPlaylistRepository())
result = case.execute("b485f40f-4f2b-43b6-9c6a-604875f31832")
self.assertIsNotNone(result)
if __name__ == "__main__":
unittest.main()
def setUp(self):
self.repo = SqlServerPlaylistRepository()
self.listPlaylist = self.repo.get_playlist_of_account("d771a0a6-1f92-4e5e-918d-966e3c1f7b4f")
self.playlist: Playlist = Playlist(2,None, None, None,True,None)