La solution pour le défi recrutement de Libéo

libeo.py

# coding: utf-8

# Nous devons importer le module unittest
import unittest

# et créer une classe qui hérite de TestCase
class LibeoCode(unittest.TestCase):
    def setUp(self):
        """
        Fonction appelé avant chacun des tests de la classe
        courante. Elle nous permet de mettre en place des variables
        à tester par exemple.
        """
        self.encoded_email = "nheryvr.qvba-tnhgvre@yvorb.pbz"
        pass

    def tearDown(self):
        """
        Fonction appelé à après chacun des tests de la classe
        courante
        """
        pass

    def test_p_to_c(self):
        self.assertEqual(libeo_decoder("p"), "c")

    def test_pbz_to_com(self):
        self.assertEqual(libeo_decoder("pbz"), "com")

    def test_obaar_punapr_to_bonne_chance(self):
        self.assertEqual(libeo_decoder("Obaar punapr"), "Bonne chance")

    def test_decoded_email(self):
        self.assertEqual(
            libeo_decoder("nheryvr.qvba-tnhgvre@yvorb.pbz"),
            "aurelie.dion-gautier@libeo.com"
        )

    def test_encoded_email(self):
        self.assertEqual(
            libeo_encoder("aurelie.dion-gautier@libeo.com"),
            "nheryvr.qvba-tnhgvre@yvorb.pbz"
        )


alphabet = list("abcdefghijklmnopqrstuvwxyz")

def libeo_decoder(encoded):
    # pour recueillir le résultat du décodage
    decoded = []

    # parcourons maintenant chacune des lettres du paramètre
    # encoded
    for letter in list(encoded):
        is_uppercased = False

        if letter == letter.upper():
            is_uppercased = True
            letter = letter.lower()

        if letter in alphabet:
            encoded_index = alphabet.index(letter)
            decoded_index = encoded_index - 13

            decoded_letter = alphabet[decoded_index]

            if is_uppercased:
                decoded_letter = decoded_letter.upper()

            decoded.append(decoded_letter)
        else:
            decoded.append(letter)

    # transformons la list decoded en chaîne
    # de caractère
    return "".join(decoded)

def libeo_encoder(decoded):
    encoded = []

    # pour chacune des lettres
    for letter in list(decoded):
        is_uppercased = False

        # vérifier si la lettre courante est en majuscule
        if letter == letter.upper():
            is_uppercased = True
            letter = letter.lower()

        if letter in alphabet:
            decoded_index = alphabet.index(letter)
            encoded_index = decoded_index + 13

            # vérifier si l'index calculé est
            # plus grand que la la longueur de l'alphabet
            if encoded_index >= len(alphabet):
                encoded_index = encoded_index - len(alphabet)

            encoded_letter = alphabet[encoded_index]

            if is_uppercased:
                encoded_letter = encoded_letter.upper()

            encoded.append(encoded_letter)
        else:
            encoded.append(letter)

    return "".join(encoded)

if __name__ == '__main__':
    unittest.main()