def test_teachers(ldap: Ldap):
    ldap.connect()
    ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
    enseignants = ldap.search_enseignant()
    assert len(enseignants) > 0
    for enseignant in enseignants:
        assert isinstance(enseignant, EnseignantLdap)
    ldap.disconnect()
def test_eleves(ldap: Ldap):
    ldap.connect()
    ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
    eleves = ldap.search_eleve()
    assert len(eleves) > 0
    for student in eleves:
        assert isinstance(student, EleveLdap)
    ldap.disconnect()
def test_personnes(ldap: Ldap):
    ldap.connect()
    ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
    personnes = ldap.search_personne()
    assert len(personnes) == 77
    for person in personnes:
        assert isinstance(person, PersonneLdap)
    ldap.disconnect()
def test_structures(ldap: Ldap):
    ldap.connect()
    ldap_utils.run_ldif('data/default-structures.ldif', ldap)
    structures = ldap.search_structure()
    assert len(structures) == 2
    for structure in structures:
        assert isinstance(structure, StructureLdap)
        getted_structure = ldap.get_structure(structure.uai)
        assert isinstance(getted_structure, StructureLdap)
    ldap.disconnect()
    def test_should_load_context(self, ldap: Ldap, db: Database,
                                 docker_config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, docker_config)
        synchronizer.initialize()

        assert synchronizer.context
        assert synchronizer.context.timestamp_now_sql is not None
        assert synchronizer.context.id_context_categorie_inter_etabs == 3
        assert synchronizer.context.id_context_categorie_inter_cfa == 343065
        assert synchronizer.context.id_field_classe == 1
        assert synchronizer.context.id_field_domaine == 3
        assert synchronizer.context.id_role_extended_teacher == 13
        assert synchronizer.context.id_role_advanced_teacher == 20
        assert synchronizer.context.map_etab_domaine == {
            '0291595B': ['lycees.netocentre.fr'],
            '0290009C': ['lycees.netocentre.fr']
        }
    def test_maj_etab(self, ldap: Ldap, db: Database, config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        structure = ldap.get_structure("0290009C")
        assert structure is not None
        etab_context = synchronizer.handle_etablissement(structure.uai)
        assert etab_context.uai == "0290009C"
        assert etab_context.gere_admin_local is True
        assert etab_context.etablissement_regroupe is False
        assert etab_context.regexp_admin_moodle == "(esco|clg37):admin:Moodle:local:.*_0290009C$"
        assert etab_context.regexp_admin_local == "(esco|clg37):admin:local:.*_0290009C$"
        assert etab_context.etablissement_theme == "0290009c"
        assert etab_context.id_context_categorie is not None
        assert etab_context.id_zone_privee is not None
        assert etab_context.id_context_course_forum is not None

        etablissement_ou = ldap.get_structure("0290009C").nom
        db.mark.execute("SELECT * FROM {entete}course_categories "
                        "WHERE name = %(name)s "
                        "AND theme = %(theme)s".format(entete=db.entete),
                        params={
                            'name': etablissement_ou,
                            'theme': etab_context.uai
                        })
        result = db.mark.fetchone()
        assert result is not None
    def test_maj_inspecteur(self, ldap: Ldap, db: Database, config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        users = ldap.search_personne()
        user = users[0]
        synchronizer.handle_inspecteur(user)

        db.mark.execute(
            "SELECT * FROM {entete}user WHERE username = %(username)s".format(
                entete=db.entete),
            params={'username': str(user.uid).lower()})
        result = db.mark.fetchone()
        user_id = result[0]
        assert result is not None

        db.mark.execute(
            "SELECT * FROM {entete}role_assignments WHERE userid = %(userid)s".
            format(entete=db.entete),
            params={'userid': user_id})
        roles_results = db.mark.fetchall()
        assert len(roles_results) == 1
        assert roles_results[0][1] == 2

        db.mark.execute(
            "SELECT * FROM {entete}user_info_data WHERE userid = %(userid)s".
            format(entete=db.entete),
            params={'userid': user_id})
        infos_result = db.mark.fetchone()
        assert infos_result[3] == "lycees.netocentre.fr"
    def test_maj_usercfa_interetab(self, ldap: Ldap, db: Database,
                                   config: Config,
                                   action_config: ActionConfig):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        users = ldap.search_personne()
        user = users[0]
        user.is_member_of = [
            action_config.inter_etablissements.ldap_valeur_attribut_admin
        ]
        synchronizer.handle_user_interetab(user)

        db.mark.execute(
            "SELECT * FROM {entete}user WHERE username = %(username)s".format(
                entete=db.entete),
            params={'username': str(user.uid).lower()})
        result = db.mark.fetchone()
        user_id = result[0]
        db.mark.execute(
            "SELECT * FROM {entete}role_assignments WHERE userid = %(userid)s".
            format(entete=db.entete),
            params={'userid': user_id})
        roles_results = db.mark.fetchall()
        assert len(roles_results) == 2
        assert roles_results[1][1] == db.get_id_role_admin_local()
    def test_nettoyage(self, ldap: Ldap, db: Database, config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        etab_context = synchronizer.handle_etablissement("0290009C")
        eleves = ldap.search_eleve(None, "0290009C")
        for eleve in eleves:
            synchronizer.handle_eleve(etab_context, eleve)

        eleves_by_cohorts_db, eleves_by_cohorts_ldap = \
            synchronizer.get_users_by_cohorts_comparators(etab_context, r'(Élèves de la Classe )(.*)$',
                                                          'Élèves de la Classe %')

        eleves_by_cohorts_ldap.pop('1ERE S2', None)
        eleves_by_cohorts_ldap.pop('TES3', None)
        eleves_by_cohorts_ldap['TS2'].remove('f1700ivg')
        eleves_by_cohorts_ldap['TS2'].remove('f1700ivl')
        eleves_by_cohorts_ldap['TS2'].remove('f1700ivv')

        synchronizer.purge_cohorts(eleves_by_cohorts_db,
                                   eleves_by_cohorts_ldap,
                                   "Élèves de la Classe %s")
        db.delete_empty_cohorts()

        s = "SELECT COUNT(cohort_members.id) FROM {entete}cohort_members AS cohort_members" \
            " INNER JOIN {entete}cohort AS cohort" \
            " ON cohort_members.cohortid = cohort.id" \
            " WHERE cohort.name = %(cohortname)s".format(entete=db.entete)

        db.mark.execute(s,
                        params={'cohortname': "Élèves de la Classe 1ERE S2"})
        result = db.mark.fetchone()
        assert result[0] == 0
        db.mark.execute(s, params={'cohortname': "Élèves de la Classe TES3"})
        result = db.mark.fetchone()
        assert result[0] == 0

        db.mark.execute(
            "SELECT {entete}user.username FROM {entete}cohort_members AS cohort_members"
            " INNER JOIN {entete}cohort AS cohort"
            " ON cohort_members.cohortid = cohort.id"
            " INNER JOIN {entete}user"
            " ON cohort_members.userid = {entete}user.id"
            " WHERE cohort.name = %(cohortname)s".format(entete=db.entete),
            params={'cohortname': "Élèves de la Classe TS2"})
        results = [result[0] for result in db.mark.fetchall()]
        assert 'f1700ivg' not in results
        assert 'f1700ivl' not in results
        assert 'f1700ivv' not in results
        assert len(results) == 5
    def test_maj_eleve(self, ldap: Ldap, db: Database, config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        structure = ldap.get_structure("0290009C")
        eleves = ldap.search_eleve(None, "0290009C")
        eleve = eleves[1]
        etab_context = synchronizer.handle_etablissement(structure.uai)
        synchronizer.handle_eleve(etab_context, eleve)

        db.mark.execute(
            "SELECT * FROM {entete}user WHERE username = %(username)s".format(
                entete=db.entete),
            params={'username': str(eleve.uid).lower()})
        result = db.mark.fetchone()
        assert result is not None
        assert result[10] == 'Dorian'
        assert result[12] == '*****@*****.**'
        assert result[27] == '0290009c'
        eleve_id = result[0]
        db.mark.execute(
            "SELECT * FROM {entete}role_assignments WHERE userid = %(userid)s".
            format(entete=db.entete),
            params={'userid': eleve_id})
        roles_results = db.mark.fetchall()
        assert len(roles_results) == 0
        for classe in eleve.classes:
            cohort_name = "Élèves de la Classe %s" % classe
            db.mark.execute(
                "SELECT * FROM {entete}cohort WHERE name = %(name)s".format(
                    entete=db.entete),
                params={'name': cohort_name})
            cohort = db.mark.fetchone()
            cohort_id = cohort[0]
            db.mark.execute(
                "SELECT * FROM {entete}cohort_members WHERE cohortid = %(cohortid)s AND userid = %(userid)s"
                .format(entete=db.entete),
                params={
                    'cohortid': cohort_id,
                    'userid': eleve_id
                })
            result_cohort_enrollment = db.mark.fetchone()
            assert result_cohort_enrollment is not None
            assert result_cohort_enrollment[2] == eleve_id
    def test_eleve_passage_lycee(self, ldap: Ldap, db: Database,
                                 config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        college = ldap.get_structure("0291595B")
        lycee = ldap.get_structure("0290009C")
        eleves = ldap.search_eleve(None, "0291595B")
        eleve = eleves[0]
        college_context = synchronizer.handle_etablissement(college.uai)
        lycee_context = synchronizer.handle_etablissement(lycee.uai)
        synchronizer.handle_eleve(college_context, eleve)

        db.mark.execute(
            "SELECT * FROM {entete}user WHERE username = %(username)s".format(
                entete=db.entete),
            params={'username': str(eleve.uid).lower()})
        result = db.mark.fetchone()
        eleve_id = result[0]
        db.mark.execute(
            "SELECT * FROM {entete}role_assignments WHERE userid = %(userid)s".
            format(entete=db.entete),
            params={'userid': eleve_id})
        roles_results = db.mark.fetchall()
        assert len(roles_results) == 1
        assert roles_results[0][1] == 14

        eleve.uai_courant = "0290009C"
        synchronizer.handle_eleve(lycee_context, eleve)
        db.mark.execute(
            "SELECT * FROM {entete}role_assignments WHERE userid = %(userid)s".
            format(entete=db.entete),
            params={'userid': eleve_id})
        roles_results = db.mark.fetchall()
        assert len(roles_results) == 0
    def test_maj_enseignant(self, ldap: Ldap, db: Database, config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        structure = ldap.get_structure("0290009C")
        enseignants = ldap.search_enseignant(None, "0290009C")
        enseignant = enseignants[1]
        etab_context = synchronizer.handle_etablissement(structure.uai)
        synchronizer.handle_enseignant(etab_context, enseignant)

        db.mark.execute(
            "SELECT * FROM {entete}user WHERE username = %(username)s".format(
                entete=db.entete),
            params={'username': str(enseignant.uid).lower()})
        result = db.mark.fetchone()
        assert result is not None
        assert result[10] == 'Jules'
        assert result[11] == 'PICARD'
        assert result[12] == '*****@*****.**'
        assert result[27] == '0290009c'
        enseignant_id = result[0]

        db.mark.execute(
            "SELECT * FROM {entete}role_assignments WHERE userid = %(userid)s".
            format(entete=db.entete),
            params={'userid': enseignant_id})
        roles_results = db.mark.fetchall()
        assert len(roles_results) == 3
        assert roles_results[0][1] == 2
        assert roles_results[0][2] == 3
        assert roles_results[1][1] == 2
        assert roles_results[1][2] == 1184277
        assert roles_results[2][1] == 5
        assert roles_results[2][2] == 1184278
    def test_course_backup(self, ldap: Ldap, db: Database, config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        os = platform.system()
        if os == "Linux":
            config.webservice.backup_cmd = "sh backup.sh --courseid=%courseid% --destination=/MoodleBackups"
        elif os == "Windows":
            config.webservice.backup_cmd = "backup.bat --courseid=%courseid% --destination=/MoodleBackups"

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        etab_context = synchronizer.handle_etablissement("0290009C")

        ldap_eleves = ldap.search_eleve(uai="0290009C")
        ldap_enseignants = ldap.search_enseignant(uai="0290009C")
        enseignant = ldap_enseignants[0]
        enseignant2 = ldap_enseignants[1]
        for eleve in ldap_eleves:
            synchronizer.handle_eleve(etab_context, eleve)
        for enseignant in ldap_enseignants:
            synchronizer.handle_enseignant(etab_context, enseignant)

        db.mark.execute(
            "SELECT id FROM {entete}user WHERE username = %(username)s".format(
                entete=db.entete),
            params={'username': str(enseignant.uid).lower()})
        enseignant_db = db.mark.fetchone()

        db.mark.execute(
            "SELECT id FROM {entete}user WHERE username = %(username)s".format(
                entete=db.entete),
            params={'username': str(enseignant2.uid).lower()})
        enseignant2_db = db.mark.fetchone()

        now = synchronizer.context.timestamp_now_sql
        db.mark.execute(
            "INSERT INTO {entete}course (fullname, timemodified) VALUES ('cours de test 1',"
            " %(timemodified)s)".format(entete=db.entete),
            params={'timemodified': now})
        db.mark.execute(
            "INSERT INTO {entete}course (fullname, timemodified) VALUES ('cours de test 2',"
            " %(timemodified)s)".format(entete=db.entete),
            params={'timemodified': now - 31622400})
        db.mark.execute(
            "INSERT INTO {entete}course (fullname, timemodified) VALUES ('cours de test 3',"
            " %(timemodified)s)".format(entete=db.entete),
            params={'timemodified': now - 31622400})
        db.mark.execute(
            "SELECT id, fullname, timemodified FROM {entete}course ORDER BY id DESC LIMIT 3"
            .format(entete=db.entete))
        courses = db.mark.fetchall()

        for course in courses:
            db.mark.execute(
                "INSERT INTO {entete}context (contextlevel, instanceid) VALUES (50, %(instanceid)s)"
                .format(entete=db.entete),
                params={'instanceid': course[0]})
            db.mark.execute(
                "SELECT id FROM {entete}context ORDER BY id DESC LIMIT 1".
                format(entete=db.entete))
            contextid = db.mark.fetchone()
            db.add_role_to_user(config.constantes.id_role_proprietaire_cours,
                                contextid[0], enseignant_db[0])

        db.mark.execute(
            "INSERT INTO {entete}context (contextlevel, instanceid) VALUES (60, %(instanceid)s)"
            .format(entete=db.entete),
            params={'instanceid': courses[1][0]})

        db.mark.execute(
            "SELECT id FROM {entete}context ORDER BY id DESC LIMIT 1".format(
                entete=db.entete))
        contextid = db.mark.fetchone()

        db.add_role_to_user(config.constantes.id_role_proprietaire_cours,
                            contextid[0], enseignant2_db[0])

        synchronizer.check_and_process_user_courses(enseignant_db[0])

        db.mark.execute(
            "SELECT id FROM {entete}course WHERE fullname LIKE 'cours de test%'"
            .format(entete=db.entete))
        new_courses = db.mark.fetchall()
        new_courses_ids = [new_course[0] for new_course in new_courses]
        assert len(new_courses_ids) == 2
        assert courses[0][0] not in new_courses_ids
    def test_anonymize_useless_users(self, ldap: Ldap, db: Database,
                                     config: Config):
        ldap_utils.run_ldif('data/default-structures.ldif', ldap)
        ldap_utils.run_ldif('data/default-personnes-short.ldif', ldap)
        ldap_utils.run_ldif('data/default-groups.ldif', ldap)
        db_utils.run_script('data/default-context.sql', db, connect=False)

        synchronizer = Synchronizer(ldap, db, config)
        synchronizer.initialize()
        etab_context = synchronizer.handle_etablissement("0290009C")

        ldap_eleves = ldap.search_eleve(uai="0290009C")
        ldap_enseignants = ldap.search_enseignant(uai="0290009C")
        for eleve in ldap_eleves:
            synchronizer.handle_eleve(etab_context, eleve)
        for enseignant in ldap_enseignants:
            synchronizer.handle_enseignant(etab_context, enseignant)

        ldap_users = ldap.search_personne()
        db_valid_users = db.get_all_valid_users()

        users_to_anon = []
        for i in range(0, 3):
            users_to_anon.append(ldap_users[i])

        for user_to_anon in users_to_anon:
            ldap_users.remove(user_to_anon)

        age = db.get_timestamp_now() - (config.delete.delay_anonymize_student *
                                        86400) - 1
        db_valid_users = [(db_valid_user[0], db_valid_user[1], age)
                          for db_valid_user in db_valid_users]

        synchronizer._Synchronizer__webservice.delete_users = lambda arg: None
        synchronizer.anonymize_or_delete_users(ldap_users, db_valid_users)

        db.mark.execute(
            "SELECT username, deleted, firstname, lastname, email, skype, yahoo, aim, msn, phone1, phone2,"
            " department, address, city, description, lastnamephonetic, firstnamephonetic, middlename,"
            " alternatename"
            " FROM {entete}user ORDER BY id LIMIT 3".format(entete=db.entete))
        db_users = db.mark.fetchall()

        assert db_users[0][0] == 'f1700ivg'
        assert db_users[1][0] == 'f1700ivh'
        assert db_users[2][0] == 'f1700ivi'

        for x in range(0, 3):
            assert db_users[x][2] == config.constantes.anonymous_name
            assert db_users[x][3] == config.constantes.anonymous_name
            assert db_users[x][4] == config.constantes.anonymous_mail
            assert db_users[x][5] == config.constantes.anonymous_name
            assert db_users[x][6] == config.constantes.anonymous_name
            assert db_users[x][7] == config.constantes.anonymous_name
            assert db_users[x][8] == config.constantes.anonymous_name
            assert db_users[x][9] == config.constantes.anonymous_phone
            assert db_users[x][10] == config.constantes.anonymous_phone
            assert db_users[x][11] == config.constantes.anonymous_name
            assert db_users[x][12] == config.constantes.anonymous_name
            assert db_users[x][13] == config.constantes.anonymous_name
            assert db_users[x][14] is None
            assert db_users[x][15] == config.constantes.anonymous_name
            assert db_users[x][16] == config.constantes.anonymous_name
            assert db_users[x][17] == config.constantes.anonymous_name
            assert db_users[x][18] == config.constantes.anonymous_name