def test_get_commentary(test_app, test_database):
"""Este test muestra como se obtienen los comentarios asociados a un
proyecto"""
session = recreate_db(test_database)
client = test_app.test_client()
body = {
"id_project": 1,
"user_id": 1,
"message": "Di Maria",
"token": CommentaryDBModel.encode_auth_token(1)
}
response = client.post("/commentary/1",
data=json.dumps(body),
content_type="application/json")
assert response.status_code == 201
body = {
"id_project": 1,
"user_id": 1,
"message": "Di Maria",
"token": CommentaryDBModel.encode_auth_token(1)
}
response = client.post("/commentary/1",
data=json.dumps(body),
content_type="application/json")
assert response.status_code == 201
body = {
"user_id": 1,
"token": CommentaryDBModel.encode_auth_token(1),
}
response = client.get("/commentary/1",
data=json.dumps(body),
content_type="application/json")
assert response.status_code == 200
patch_data = json.loads(response.data.decode())
assert len(patch_data) == 2
def test_dada_una_db_con_projecto_de_id_1_sin_usuarios_que_lo_hayan_faveado__get_a_projects_barra_id_1_barra_favorites_devuelve_una_lista_vacia(
test_app, test_database):
"""
Dada una base de datos con un proyecto
que no tiene usuarios que lo hayan faveado
Cuando GET "/projects/1/favorites"
Entonces obtengo status 200
Y obtengo el cuerpo:
"project_id": 1,
"users_id": []
"""
session = recreate_db(test_database)
client = test_app.test_client()
body = {
"name": "Colombia",
"description": "string",
"hashtags": "#pruebaaaa #adeu",
"type": "Art",
"goal": 0,
"path": "",
"endDate": "string",
"location": "string",
"image": "string",
"lat": 80.60971,
"lon": -74.08175
}
client.post("/projects",
data=json.dumps(body),
content_type="application/json")
response = client.get("/projects/1/favorites")
assert response is not None
assert response.status_code == 200
user = json.loads(response.data.decode())
assert user['project_id'] == 1
assert len(user['users_id']) == 0
def test_post_project_con_tipo_no_valido(test_app, test_database):
"""
Dada una base de datos con dos proyectos con dos tipos distintos.
Cuando POST 'projects' con tipo invalido
Entonces obtengo status code 400
Con cuerpo:
"status": 'The type selected in not a valid one'
"""
session = recreate_db(test_database)
client = test_app.test_client()
project = {
'name': 'a name',
'description': 'a description',
'hashtags': '#someHashtags',
'type': 'tipo invalido',
'goal': 111,
'endDate': '2022/06/07',
'location': 'a location',
'image': 'www.an-image-url.com',
'path': 'a',
'lat': 50,
"lon": 20.5
}
response = client.post("/projects", json=project)
assert response.status_code == 400
data = json.loads(response.data.decode())
assert data['status'] == 'The type selected in not a valid one'
def test_delete_project_id_elimina_el_proyecto(test_app, test_database):
"""
Dada una base de datos.
Y un proyecto registrado:
'id': <id>,
Cuando DELETE 'projects/<id>'
Entonces obtengo status code 204
Y el proyecto es eliminado
"""
session = recreate_db(test_database)
client = test_app.test_client()
project = {
'name': 'a name',
'description': 'a description',
'hashtags': '#someHashtags',
'type': 'Comics',
'goal': 111,
'endDate': '2022/06/07',
'location': 'a location',
'image': 'an image',
'lat': 50,
"lon": 20.5,
'path': '/img'
}
post_resp = client.post("/projects", json=project)
post_data = json.loads(post_resp.data.decode())
id_project = post_data['id']
with test_app.test_request_context():
delete_resp = client.delete("/projects/{}".format(id_project))
assert delete_resp.status_code == 204
get_resp = client.get("/projects/{}".format(id_project))
assert get_resp.status_code == 404
def test_add_second_rating_in_project_give_average(test_app, test_database):
session = recreate_db(test_database)
session.add(
ProjectDBModel(name='Project Rated',
description='description',
hashtags='#prueba',
type='art',
goal=1000,
endDate='12/02/2021',
location='Buenos Aires',
image='www.an_image_url.com',
createdOn='12/02/2021',
path='a',
lat=50,
lon=20.5))
session.commit()
client = test_app.test_client()
response = client.post("/projects/1/rate",
json={
"rating": 5,
"id_user": 1
})
response = client.post("/projects/1/rate",
json={
"rating": 1,
"id_user": 2
})
assert response.status_code == 200
response = client.get("/projects/1")
project = json.loads(response.data.decode())
assert project['rating'] == 3
def test_get_messages_form_user_1_to_user_2(test_app, test_database):
"""Este tests muestra como se obtienen los mensajes entre dos usuarios
"""
session = recreate_db(test_database)
session.add(CommentaryDBModel(id_1=1, text="*****@*****.**"))
session.commit()
session.add(CommentaryDBModel(id_1=1, text="*****@*****.**"))
session.commit()
messages = CommentaryDBModel.get_messages_from_project(1)
assert len(messages) == 2
def test_favoritesdbmodel_get_favorites_projects_of_project_id_devuelve_lista_vacia_cuando_no_se_ha_agregado_a_favoritos(
test_app, test_database):
"""
Dada una base de datos vacia
Cuando invoco get_favorites_of_project_id(<id project>)
Obtengo:
[]
"""
session = recreate_db(test_database)
id_project_list = FavoritesProjectDBModel.get_favorites_of_project_id(11)
assert len(id_project_list) == 0
def test_add_seer(test_app, test_database):
session = recreate_db(test_database)
session.add(
ProjectDBModel.create("hola", 'a description', '#someHashtags',
'Comics', 111, '2022/06/07', 'a location',
'www.an-image.com', '2022/06/07', 'a', 50, 50.5))
session.commit()
user_model = ProjectDBModel.query.filter_by(id=1).first()
assert user_model.seer == ""
ProjectDBModel.add_seer("Brian", 1)
user_model = ProjectDBModel.query.filter_by(id=1).first()
assert user_model.seer == "Brian"
def test_get_messages_form_user_1_to_user_2_and_user_2_to_user_1(
test_app, test_database):
"""Este tests prueba que se puedan obtener los mensajes asociados a los
dos users independientemente de que usuario es el dueño del mensaje
"""
session = recreate_db(test_database)
session.add(CommentaryDBModel(id_1=1, text="*****@*****.**"))
session.commit()
session.add(CommentaryDBModel(id_1=2, text="*****@*****.**"))
session.commit()
messages = CommentaryDBModel.get_messages_from_project(1)
assert len(messages) == 2
def test_delete_element_from_db(test_app, test_database):
session = recreate_db(test_database)
session.add(
ProjectDBModel.create("hola", 'a description', '#someHashtags',
'Comics', 111, '2022/06/07', 'a location',
'www.an-image.com', "2022/06/07", 'a', 50, 20.5))
session.commit()
associated_id = ProjectDBModel.query.filter_by(name="hola")
assert associated_id.count() == 1
ProjectDBModel.delete(1)
associated_id = ProjectDBModel.query.filter_by(name="hola")
assert associated_id.count() == 0
def test_post_commentary(test_app, test_database):
"""Este test muestra como se crea un comentario asociado un proyecto"""
session = recreate_db(test_database)
client = test_app.test_client()
body = {
"id_project": 1,
"user_id": 1,
"message": "Di Maria",
"token": CommentaryDBModel.encode_auth_token(1),
}
response = client.post("/commentary/1",
data=json.dumps(body),
content_type="application/json")
assert response.status_code == 201
def test_delete_project_id_no_elimina_el_proyecto(test_app, test_database):
"""
Dada una base de datos vacia.
Cuando DELETE 'projects/<id>'
Entonces obtengo status code 404
Con cuerpo:
"status": 'The project requested could not be found'
"""
session = recreate_db(test_database)
client = test_app.test_client()
delete_resp = client.delete("/projects/111")
assert delete_resp.status_code == 404
delete_data = json.loads(delete_resp.data.decode())
assert delete_data['status'] == 'The project requested could not be found'
def test_patch_project_id_con_body_vacio_no_cambia_nada_del_proyecto(
test_app, test_database):
"""
Dada una base de datos.
Y un proyecto registrado:
'id': <id>,
'name': 'a name',
'description': 'a description',
'hashtags': '#someHashtags,
'type': 'a type',
'goal': 111,
'endDate': '2022/06/07',
'location': 'a location',
'image': 'www.an-image-url.com'
Cuando patch 'projects/1'
Con cuerpo:
'id': <id>
'name': 'another name'
Entonces solo se actualiza el nombre del proyecto
"""
session = recreate_db(test_database)
old_project = {
'name': 'a name',
'description': 'a description',
'hashtags': '#someHashtags',
'type': 'Comics',
'goal': 111,
'endDate': '2022/06/07',
'location': 'a location',
'image': 'www.an-image-url.com',
'path': 'a',
'lat': 50,
"lon": 20.5
}
client = test_app.test_client()
post_resp = client.post("/projects", json=old_project)
post_data = json.loads(post_resp.data.decode())
id_project = post_data['id']
update_project = {'id': id_project, 'name': 'another name'}
patch_resp = client.patch("/projects/{}".format(id_project),
json=update_project)
assert patch_resp.status_code == 200
patch_data = json.loads(patch_resp.data.decode())
assert patch_data['name'] == update_project['name']
for field in old_project.keys():
if field == 'name':
continue
assert patch_data[field] == old_project[field]
def test_dada_una_db_con_usuario_de_id_1_post_a_users_barra_id_1_barra_favorites_con_el_cuerpo_correcto_entonces_obtengo(
test_app, test_database):
"""
Dada una base de datos con un proyecto
Cuando Post "/projects/1/favorites" con user_id = 1
Entonces obtengo status 201
Y obtengo el cuerpo:
"project_id": 1,
"users_id": [
1
],
"""
session = recreate_db(test_database)
client = test_app.test_client()
body = {
"name": "Colombia",
"description": "string",
"hashtags": "#pruebaaaa #adeu",
"type": "Art",
"goal": 0,
"path": "",
"endDate": "string",
"location": "string",
"image": "string",
"lat": 80.60971,
"lon": -74.08175
}
client.post("/projects",
data=json.dumps(body),
content_type="application/json")
body = {"user_id": 1}
post_response = client.post("/projects/1/favorites",
data=json.dumps(body),
content_type="application/json")
assert post_response is not None
assert post_response.status_code == 201
user = json.loads(post_response.data.decode())
assert user['project_id'] == 1
assert user["users_id"][0] == 1
old_response = json.loads(post_response.data.decode())
get_response = client.get("/projects/1/favorites")
assert get_response.status_code == 200
new_response = json.loads(get_response.data.decode())
for field in old_response.keys():
assert old_response[field] == new_response[field]
def test_dada_una_db_vacia_get_a_users_barra_id_1_barra_favorites_devuelve_project_not_found(
test_app, test_database):
"""
Dada una base de datos vacia
Cuando GET "/users/1/favorites"
Entonces obtengo status 404
Y obtengo el cuerpo:
"status": "The project requested could not be found",
"message": <mensaje de error>
"""
session = recreate_db(test_database)
client = test_app.test_client()
response = client.get("/projects/1/favorites")
assert response is not None
assert response.status_code == 404
user = json.loads(response.data.decode())
assert user['status'] == "The project requested could not be found"
def test_dada_una_db_con_proyecto_de_id_1_con_un_usuario_que_lo_faveo_id_1_al_hacer_un_delete_de_dicho_id_el_usuario_ya_no_esta_en_la_lista_de_faveados(
test_app, test_database):
"""
Dada una base de datos con un proyecto
Cuando Delete "/projects/1/favorites" con user_id = 1
Entonces obtengo status 201
Y obtengo el cuerpo:
"project_id": 1,
"users_id": [],
"""
session = recreate_db(test_database)
client = test_app.test_client()
body = {
"name": "Colombia",
"description": "string",
"hashtags": "#pruebaaaa #adeu",
"type": "Art",
"goal": 0,
"path": "",
"endDate": "string",
"location": "string",
"image": "string",
"lat": 80.60971,
"lon": -74.08175
}
client.post("/projects",
data=json.dumps(body),
content_type="application/json")
body = {"user_id": 1}
client.post("/projects/1/favorites",
data=json.dumps(body),
content_type="application/json")
body_delete = {
"user_id": 1,
}
delete_response = client.delete("/projects/1/favorites",
data=json.dumps(body_delete),
content_type="application/json")
assert delete_response is not None
assert delete_response.status_code == 200
user = json.loads(delete_response.data.decode())
assert user['project_id'] == 1
assert user["users_id"] == []
def test_favoritesdbmodel_get_projects_of_user_id_devuelve_lista_de_ids_de_usuarios_que_han_fav_el_proyecto(
test_app, test_database):
"""
Dada una base de datos
Tras invocar a add_project_to_favorites_of_user_id(1, 19)
Cuando invoco get_favorites_of_project_id(<id proyecto>)
Obtengo:
[1]
"""
session = recreate_db(test_database)
user_id = 1
project_id = 19
id_projects_list = FavoritesProjectDBModel.add_project_to_favorites_of_user_id(
user_id, project_id)
assert len(id_projects_list) == 1
assert id_projects_list[0] == user_id
id_projects_list = FavoritesProjectDBModel.get_favorites_of_project_id(
project_id)
assert len(id_projects_list) == 1
assert id_projects_list[0] == user_id
def test_get_project_con_filtro_devuelve_solo_los_con_ese_tipo(
test_app, test_database):
"""
Dada una base de datos con dos proyectos con dos tipos distintos.
Cuando GET 'projects' con filtro
Entonces obtengo un solo proyecto
"""
session = recreate_db(test_database)
client = test_app.test_client()
session.add(
ProjectDBModel(name='Project X',
description='description',
hashtags='#prueba',
type='art',
goal=1000,
endDate='12/02/2021',
location='Buenos Aires',
image='www.an_image_url.com',
createdOn='12/02/2021',
path='a',
lat=50,
lon=20.5))
session.add(
ProjectDBModel(name='Project X',
description='description',
hashtags='#prueba',
type='comics',
goal=1000,
endDate='12/02/2021',
location='Buenos Aires',
image='www.an_image_url.com',
createdOn='12/02/2021',
path='a',
lat=50,
lon=20.5))
response = client.get("/projects?type")
projects = json.loads(response.data.decode())
assert len(projects) == 2
response = client.get("/projects?type=Comics")
projects = json.loads(response.data.decode())
assert len(projects) == 1 and projects[0]["type"] == "Comics"
def test_db_empty_POST_projects_name_test_project_should_return_that_with_id_1(
test_app, test_database):
session = recreate_db(test_database)
project = {
'name': 'test project',
'description': 'description',
'hashtags': '#prueba',
'type': 'Comics',
'goal': 1000,
'endDate': '12/02/2021',
'location': 'Buenos Aires',
'image': 'www.an_image_url.com',
'path': 'a',
'lat': 50,
"lon": 20.5
}
client = test_app.test_client()
response = client.post("/projects", json=project)
assert response.status_code == 201
project = json.loads(response.data.decode())
assert project['id'] == 1
assert project['name'] == 'test project'
assert project['image'] == 'www.an_image_url.com'
def test_db_with_only_project_id_1_name_Project_X_GET_id_1_should_return_just_that(
test_app, test_database):
session = recreate_db(test_database)
session.add(
ProjectDBModel(name='Project X',
description='description',
hashtags='#prueba',
type='art',
goal=1000,
endDate='12/02/2021',
location='Buenos Aires',
image='www.an_image_url.com',
createdOn='12/02/2021',
path='a',
lat=50,
lon=20.5))
session.commit()
client = test_app.test_client()
response = client.get("/projects/1")
assert response.status_code == 200
project = json.loads(response.data.decode())
assert project['name'] == 'Project X'
assert project['image'] == 'www.an_image_url.com'
def test_patch_project_id_cambiar_todos_los_contenidos_del_proyecto(
test_app, test_database):
"""
Dada una base de datos.
Y un proyecto registrado:
'id': <id>,
'name': 'a name',
'description': 'a description',
'hashtags': '#someHashtags,
'type': 'Art',
'goal': 111,
'endDate': '2022/06/07',
'location': 'a location',
'image': 'www.an-image-url.com'
Cuando patch 'projects/1'
Con cuerpo:
'id': <id>,
'name': 'another name',
'description': 'another description',
'hashtags': '#otherHashtags,
'type': 'Comics',
'goal': 222,
'endDate': '2023/07/08',
'location': 'another location'
'image': 'www.another-image-url.com'
Entonces los datos del proyeto se actualizan
"""
session = recreate_db(test_database)
old_project = {
'name': 'a name',
'description': 'a description',
'hashtags': '#someHashtags',
'type': 'Art',
'goal': 111,
'endDate': '2022/06/07',
'location': 'a location',
'image': 'www.an-image-url.com',
'path': 'a',
'lat': 50,
"lon": 20.5
}
client = test_app.test_client()
post_resp = client.post("/projects", json=old_project)
post_data = json.loads(post_resp.data.decode())
id_project = post_data['id']
update_project = {
'id': id_project,
'name': 'another name',
'description': 'another description',
'hashtags': '#otherHashtags',
'type': 'Comics',
'goal': 222,
'endDate': '2023/07/08',
'location': 'another location',
'image': 'www.another-image-url.com',
'path': 'a'
}
patch_resp = client.patch("/projects/{}".format(id_project),
json=update_project)
assert patch_resp.status_code == 200
patch_data = json.loads(patch_resp.data.decode())
for field in update_project.keys():
assert patch_data[field] == update_project[field]
