Merge pull request 'ajoute test_logos' (#249) from jmplace/ScoDoc-Lille:tests_api_logos into master

Reviewed-on: https://scodoc.org/git/ScoDoc/ScoDoc/pulls/249

config_test_logos.py pourra être renommé config_test_api.py.

tests/api/test_api_logos.py

+#!/usr/bin/env python3
+# -*- mode: python -*-
+# -*- coding: utf-8 -*-
+
+"""Exemple utilisation API ScoDoc 9 avec jeton obtenu par basic authentication
+
+utilisation:
+    à faire fonctionner en environnment de test (FLASK_ENV=test dans le fichier .env)
+    pytest tests/api/test_api_logos.py
+"""
+
+import pytest
+
+from scodoc import app
+from tests.unit.config_test_logos import (
+    create_super_token,
+    create_admin_token,
+    create_lambda_token,
+    create_logos,
+    create_dept,
+)
+
+
+def test_super_access(create_super_token):
+    dept1, dept2, dept3, token = create_super_token
+    HEADERS = {"Authorization": f"Bearer {token}"}
+    with app.test_client() as client:
+        response = client.get("/ScoDoc/api/logos", headers=HEADERS)
+        assert response.status_code == 200
+        assert response.json is not None
+
+
+def test_admin_access(create_admin_token):
+    dept1, dept2, dept3, token = create_admin_token
+    headers = {"Authorization": f"Bearer {token}"}
+    with app.test_client() as client:
+        response = client.get("/ScoDoc/api/logos", headers=headers)
+        assert response.status_code == 401
+
+
+def test_lambda_access(create_lambda_token):
+    dept1, dept2, dept3, token = create_lambda_token
+    headers = {"Authorization": f"Bearer {token}"}
+    with app.test_client() as client:
+        response = client.get("/ScoDoc/api/logos", headers=headers)
+        assert response.status_code == 401
+
+
+def test_initial_with_header_and_footer(create_super_token):
+    dept1, dept2, dept3, token = create_super_token
+    headers = {"Authorization": f"Bearer {token}"}
+    with app.test_client() as client:
+        response = client.get("/ScoDoc/api/logos", headers=headers)
+        assert response.status_code == 200
+        assert response.json is not None
+        assert len(response.json) == 7

tests/unit/config_test_logos.py

+# -*- coding: utf-8 -*-
+
+"""Test Logos
+    Mise en place de l'environnement de test pour logos
+"""
+from pathlib import Path
+from shutil import copytree, rmtree, copy
+
+import pytest
+
+import app.scodoc.sco_utils as scu
+from app import db, Departement
+from app.auth.models import User, Role
+from config import TestConfig
+from scodoc import app
+from tests.conftest import test_client
+
+RESOURCES_DIR = "/opt/scodoc/tests/ressources/test_logos"
+
+
+@pytest.fixture
+def create_dept(test_client):
+    """Crée 3 départements:
+    return departements object
+    """
+    client = test_client
+    dept1 = Departement(acronym="RT")
+    dept2 = Departement(acronym="INFO")
+    dept3 = Departement(acronym="GEA")
+    db.session.add(dept1)
+    db.session.add(dept2)
+    db.session.add(dept3)
+    db.session.commit()
+    yield dept1, dept2, dept3
+    db.session.delete(dept1)
+    db.session.delete(dept2)
+    db.session.delete(dept3)
+    db.session.commit()
+
+
+@pytest.fixture
+def create_logos(create_dept):
+    """Crée les logos:
+    ...logos --+-- logo_A.jpg
+               +-- logo_C.jpg
+               +-- logo_D.png
+               +-- logo_E.jpg
+               +-- logo_F.jpeg
+               +-- logos_{d1} --+-- logo_A.jpg
+               |                +-- logo_B.jpg
+               +-- logos_{d2} --+-- logo_A.jpg
+
+    """
+    dept1, dept2, dept3 = create_dept
+    dept1_id = dept1.id
+    dept2_id = dept2.id
+    FILE_LIST = ["logo_A.jpg", "logo_C.jpg", "logo_D.png", "logo_E.jpg", "logo_F.jpeg"]
+    for filename in FILE_LIST:
+        from_path = Path(RESOURCES_DIR).joinpath(filename)
+        to_path = Path(scu.SCODOC_LOGOS_DIR).joinpath(filename)
+        copy(from_path.absolute(), to_path.absolute())
+    copytree(
+        f"{RESOURCES_DIR}/logos_1",
+        f"{scu.SCODOC_LOGOS_DIR}/logos_{dept1_id}",
+    )
+    copytree(
+        f"{RESOURCES_DIR}/logos_2",
+        f"{scu.SCODOC_LOGOS_DIR}/logos_{dept2_id}",
+    )
+    yield dept1, dept2, dept3
+    rmtree(f"{scu.SCODOC_LOGOS_DIR}/logos_{dept1_id}")
+    rmtree(f"{scu.SCODOC_LOGOS_DIR}/logos_{dept2_id}")
+    # rm files
+    for filename in FILE_LIST:
+        to_path = Path(scu.SCODOC_LOGOS_DIR).joinpath(filename)
+        to_path.unlink()
+
+
+def get_token(user_name):
+    with app.test_client() as client:
+        response = client.post("/ScoDoc/api/tokens", auth=(user_name, user_name))
+        assert response.status_code == 200
+        token = response.json["token"]
+        user = User.check_token(token) if token else None
+        assert user.user_name == user_name
+        app.logger.info(f"{user.user_name}: token obtained: {token}")
+        return token
+
+
+@pytest.fixture
+def create_super_token(create_logos):
+    dept1, dept2, dept3 = create_logos
+    # change super_admin password
+    # utilisateur mozart -> super
+    user_name = "mozart"
+    u = User.query.filter_by(user_name=user_name).first()
+    if u is None:
+        u = User(user_name=user_name)
+    u.set_password(user_name)
+    if "SuperAdmin" not in {r.name for r in u.roles}:
+        super_role = Role.query.filter_by(name="SuperAdmin").first()
+        u.add_role(super_role, None)
+    db.session.add(u)
+    db.session.commit()
+    return dept1, dept2, dept3, get_token(u.user_name)
+
+
+@pytest.fixture
+def create_admin_token(create_logos):
+    dept1, dept2, dept3 = create_logos
+    # utilisateur bach -> admin
+    user_name = "bach"
+    u = User.query.filter_by(user_name=user_name).first()
+    if u is None:
+        u = User(user_name=user_name)
+    u.set_password(user_name)
+    if "Admin" not in {r.name for r in u.roles}:
+        admin_role = Role.query.filter_by(name=user_name).first()
+        u.add_role(admin_role, TestConfig.DEPT_TEST)
+    db.session.add(u)
+    db.session.commit()
+    return dept1, dept2, dept3, get_token(u.user_name)
+
+
+@pytest.fixture
+def create_lambda_token(create_logos):
+    dept1, dept2, dept3 = create_logos
+    # utilisateur vivaldi -> lambda
+    user_name = "vivaldi"
+    u = User.query.filter_by(user_name=user_name).first()
+    if u is None:
+        u = User(user_name=user_name)
+    u.set_password(user_name)
+    db.session.add(u)
+    db.session.commit()
+    return dept1, dept2, dept3, get_token(user_name)

tests/unit/setup.py

@@ -6,6 +6,7 @@ from tests.unit import sco_fake_gen
 from app import db
 from app import models
 
+import app.scodoc.sco_utils as scu
 from app.scodoc import sco_codes_parcours
 
 

tests/unit/test_logos.py

@@ -2,131 +2,69 @@
 
 """Test Logos
 
-
 Utiliser comme: 
     pytest tests/unit/test_logos.py
-
 """
 from pathlib import Path
-from shutil import copytree, copy, rmtree
+from shutil import copy
 
 import pytest as pytest
 from _pytest.python_api import approx
 
 import app
-from app import db
-from app.models import Departement
 import app.scodoc.sco_utils as scu
 from app.scodoc.sco_logos import (
     find_logo,
     Logo,
     list_logos,
-    GLOBAL,
     write_logo,
     delete_logo,
 )
-
-RESOURCES_DIR = "/opt/scodoc/tests/ressources/test_logos"
-
-
-@pytest.fixture
-def create_dept(test_client):
-    """Crée 2 départements:
-    return departements object
-    """
-    dept1 = Departement(acronym="RT")
-    dept2 = Departement(acronym="INFO")
-    dept3 = Departement(acronym="GEA")
-    db.session.add(dept1)
-    db.session.add(dept2)
-    db.session.add(dept3)
-    db.session.commit()
-    yield dept1, dept2, dept3
-    db.session.delete(dept1)
-    db.session.delete(dept2)
-    db.session.delete(dept3)
-    db.session.commit()
-
-
-@pytest.fixture
-def create_logos(create_dept):
-    """Crée les logos:
-    ...logos --+-- logo_A.jpg
-               +-- logo_C.jpg
-               +-- logo_D.png
-               +-- logo_E.jpg
-               +-- logo_F.jpeg
-               +-- logos_{d1} --+-- logo_A.jpg
-               |                +-- logo_B.jpg
-               +-- logos_{d2} --+-- logo_A.jpg
-
-    """
-    dept1, dept2, dept3 = create_dept
-    d1 = dept1.id
-    d2 = dept2.id
-    d3 = dept3.id
-    FILE_LIST = ["logo_A.jpg", "logo_C.jpg", "logo_D.png", "logo_E.jpg", "logo_F.jpeg"]
-    for fn in FILE_LIST:
-        from_path = Path(RESOURCES_DIR).joinpath(fn)
-        to_path = Path(scu.SCODOC_LOGOS_DIR).joinpath(fn)
-        copy(from_path.absolute(), to_path.absolute())
-    copytree(
-        f"{RESOURCES_DIR}/logos_1",
-        f"{scu.SCODOC_LOGOS_DIR}/logos_{d1}",
-    )
-    copytree(
-        f"{RESOURCES_DIR}/logos_2",
-        f"{scu.SCODOC_LOGOS_DIR}/logos_{d2}",
-    )
-    yield None
-    rmtree(f"{scu.SCODOC_LOGOS_DIR}/logos_{d1}")
-    rmtree(f"{scu.SCODOC_LOGOS_DIR}/logos_{d2}")
-    # rm files
-    for fn in FILE_LIST:
-        to_path = Path(scu.SCODOC_LOGOS_DIR).joinpath(fn)
-        to_path.unlink()
+from tests.unit.config_test_logos import create_dept, create_logos, RESOURCES_DIR
 
 
 def test_select_global_only(create_logos):
+    dept1, dept2, dept3 = create_logos
     C_logo = app.scodoc.sco_logos.find_logo(logoname="C")
     assert C_logo.filepath == f"{scu.SCODOC_LOGOS_DIR}/logo_C.jpg"
 
 
-def test_select_local_only(create_dept, create_logos):
-    dept1, dept2, dept3 = create_dept
+def test_select_local_only(create_logos):
+    dept1, dept2, dept3 = create_logos
     B_logo = app.scodoc.sco_logos.find_logo(logoname="B", dept_id=dept1.id)
     assert B_logo.filepath == f"{scu.SCODOC_LOGOS_DIR}/logos_{dept1.id}/logo_B.jpg"
 
 
-def test_select_local_override_global(create_dept, create_logos):
-    dept1, dept2, dept3 = create_dept
+def test_select_local_override_global(create_logos):
+    dept1, dept2, dept3 = create_logos
     A1_logo = app.scodoc.sco_logos.find_logo(logoname="A", dept_id=dept1.id)
     assert A1_logo.filepath == f"{scu.SCODOC_LOGOS_DIR}/logos_{dept1.id}/logo_A.jpg"
 
 
-def test_select_global_with_strict(create_dept, create_logos):
-    dept1, dept2, dept3 = create_dept
+def test_select_global_with_strict(create_logos):
+    dept1, dept2, dept3 = create_logos
     A_logo = app.scodoc.sco_logos.find_logo(logoname="A", dept_id=dept1.id, strict=True)
     assert A_logo.filepath == f"{scu.SCODOC_LOGOS_DIR}/logos_{dept1.id}/logo_A.jpg"
 
 
-def test_looks_for_non_existant_should_give_none(create_dept, create_logos):
+def test_looks_for_non_existant_should_give_none(create_logos):
     # search for a local non-existant logo returns None
-    dept1, dept2, dept3 = create_dept
+    dept1, dept2, dept3 = create_logos
     no_logo = app.scodoc.sco_logos.find_logo(logoname="Z", dept_id=dept1.id)
     assert no_logo is None
 
 
-def test_looks_localy_for_a_global_should_give_none(create_dept, create_logos):
+def test_looks_localy_for_a_global_should_give_none(create_logos):
     # search for a local non-existant logo returns None
-    dept1, dept2, dept3 = create_dept
+    dept1, dept2, dept3 = create_logos
     no_logo = app.scodoc.sco_logos.find_logo(
         logoname="C", dept_id=dept1.id, strict=True
     )
     assert no_logo is None
 
 
-def test_get_jpg_data(create_dept, create_logos):
+def test_get_jpg_data(create_logos):
+    dept1, dept2, dept3 = create_logos
     logo = find_logo("A", dept_id=None)
     assert logo is not None
     logo.select()
@@ -137,7 +75,8 @@ def test_get_jpg_data(create_dept, create_logos):
     assert logo.mm == approx((9.38, 5.49), 0.1)
 
 
-def test_get_png_without_data(create_dept, create_logos):
+def test_get_png_without_data(create_logos):
+    dept1, dept2, dept3 = create_logos
     logo = find_logo("D", dept_id=None)
     assert logo is not None
     logo.select()
@@ -149,7 +88,8 @@ def test_get_png_without_data(create_dept, create_logos):
     assert logo.mm is None
 
 
-def test_delete_unique_global_jpg_logo(create_dept, create_logos):
+def test_delete_unique_global_jpg_logo(create_logos):
+    dept1, dept2, dept3 = create_logos
     from_path = Path(RESOURCES_DIR).joinpath("logo_A.jpg")
     to_path = Path(scu.SCODOC_LOGOS_DIR).joinpath("logo_W.jpg")
     copy(from_path.absolute(), to_path.absolute())
@@ -158,8 +98,8 @@ def test_delete_unique_global_jpg_logo(create_dept, create_logos):
     assert not to_path.exists()
 
 
-def test_delete_unique_local_jpg_logo(create_dept, create_logos):
-    dept1, dept2, dept3 = create_dept
+def test_delete_unique_local_jpg_logo(create_logos):
+    dept1, dept2, dept3 = create_logos
     from_path = Path(RESOURCES_DIR).joinpath("logo_A.jpg")
     to_path = Path(scu.SCODOC_LOGOS_DIR).joinpath(f"logos_{dept1.id}", "logo_W.jpg")
     copy(from_path.absolute(), to_path.absolute())
@@ -168,8 +108,8 @@ def test_delete_unique_local_jpg_logo(create_dept, create_logos):
     assert not to_path.exists()
 
 
-def test_delete_multiple_local_jpg_logo(create_dept, create_logos):
-    dept1, dept2, dept3 = create_dept
+def test_delete_multiple_local_jpg_logo(create_logos):
+    dept1, dept2, dept3 = create_logos
     from_path_A = Path(RESOURCES_DIR).joinpath("logo_A.jpg")
     to_path_A = Path(scu.SCODOC_LOGOS_DIR).joinpath(f"logos_{dept1.id}", "logo_V.jpg")
     from_path_B = Path(RESOURCES_DIR).joinpath("logo_D.png")
@@ -183,7 +123,8 @@ def test_delete_multiple_local_jpg_logo(create_dept, create_logos):
     assert not to_path_B.exists()
 
 
-def test_create_global_jpg_logo(create_dept, create_logos):
+def test_create_global_jpg_logo(create_logos):
+    dept1, dept2, dept3 = create_logos
     path = Path(f"{RESOURCES_DIR}/logo_C.jpg")
     stream = path.open("rb")
     logo_path = Path(scu.SCODOC_LOGOS_DIR).joinpath("logo_X.jpg")
@@ -193,8 +134,8 @@ def test_create_global_jpg_logo(create_dept, create_logos):
     logo_path.unlink(missing_ok=True)
 
 
-def test_create_locale_jpg_logo(create_dept, create_logos):
-    dept1, dept2, dept3 = create_dept
+def test_create_locale_jpg_logo(create_logos):
+    dept1, dept2, dept3 = create_logos
     path = Path(f"{RESOURCES_DIR}/logo_C.jpg")
     stream = path.open("rb")
     logo_path = Path(scu.SCODOC_LOGOS_DIR).joinpath(f"logos_{dept1.id}", "logo_Y.jpg")
@@ -204,7 +145,8 @@ def test_create_locale_jpg_logo(create_dept, create_logos):
     logo_path.unlink(missing_ok=True)
 
 
-def test_create_jpg_instead_of_png_logo(create_dept, create_logos):
+def test_create_jpg_instead_of_png_logo(create_logos):
+    dept1, dept2, dept3 = create_logos
     # action
     logo = Logo("D")  # create global logo (replace logo_D.png)
     path = Path(f"{RESOURCES_DIR}/logo_C.jpg")
@@ -226,9 +168,9 @@ def test_create_jpg_instead_of_png_logo(create_dept, create_logos):
     created.unlink(missing_ok=True)
 
 
-def test_list_logo(create_dept, create_logos):
+def test_list_logo(create_logos):
     # test only existence of copied logos. We assumes that they are OK
-    dept1, dept2, dept3 = create_dept
+    dept1, dept2, dept3 = create_logos
     logos = list_logos()
     assert set(logos.keys()) == {dept1.id, dept2.id, None}
     assert {"A", "C", "D", "E", "F", "header", "footer"}.issubset(