stephane-klein.info

Introduction

Je viens de commencer à utiliser Selenium pour tester des formulaires, divers pages de listes de données… dans une application métier.

Mes objectifs :

• tester l'ajout de nouvelles entités (1)
  • les données sont injectées dans un formulaire d'une page html
  • une page de résultat est utilisées pour vérifier que les données ont bien été enregistré (ça peut être une page d'édition)
• tester la modification d'une entités (2)
  • les données sont injectées dans un formulaire d'une page html
  • une page de résultat est utilisées pour vérifier que les données ont bien été enregistré (ça peut être une page d'édition)
• tester la validité d'une page de liste (3)
• tester la validité des résultats d'un moteur de recherche (4)

Pour le moment je me suis concentré uniquement sur les points 1 et 2.

Première méthode (à l'arrache)

J'ai commencé par réaliser des fonctions du type :

• login()
• add_customer(data)
• edit_customer(data)
• check_customer(data)
• add_customer(data)
• edit_customer(data)
• check_customer(data)
• …

Les fonctions de type "add" et "edit" prennent en paramètre des données à injecter dans des pages. Les fonctions de type "add" correspondent aux pages d'ajout d'entités, les fonctions de type "edit" correspondent aux pages de modification d'entités.

Ensuite j'ai des fonctions "check", là aussi je passe en paramètre des données qui seront utilisées comme valeur de vérification face à des pages de résultats ou pages d'éditions (une page d'édition contient déjà des données, le but ici est de vérifier leurs validitées).

Ma variable "data" est du type :

data = [
    ("reference", u"C1345"),
    ("firstname", u"Stéphane),
    ("lastname", u"Klein"),
    ...
]

Dans mes fonctions ("add", "check"…) j'ai une boucle qui parcourt la structure de données et utilise les fonctions suivantes soit pour injecter des données, soit pour tester la validité des données.

def inject_value(driver, name, value):
    element = driver.find_element_by_id(name)
    if element.tag_name == 'input':
        if element.get_attribute("type") == "checkbox":
            if element.is_enabled() != value:
                element.click()
        else:
            element.clear()
            element.send_keys(value)

    elif element.tag_name == 'select':
        option_element = element.find_element_by_xpath(".//option[@value='%s']" % value)
        option_element.click()

    elif element.tag_name == 'textarea':
        element.clear()
        element.send_keys(value)

def check_value(driver, name, value):
    element = driver.find_element_by_id(name)
    if element.tag_name == 'input':
        if element.get_attribute("type") == "checkbox":
            return element.is_enabled() == value
        else:
            return element.get_attribute("value") == value

    elif element.tag_name == 'select':
        return element.get_attribute("value") == value

    elif element.tag_name == 'textarea':
        return element.text == value

Pour le moment, cela fonctionne correctement mais je trouve mon code fastidieux pour plusieurs raisons :

• j'aimerais pouvoir définir des valeurs par défaut pour les formulaires
• j'aimerais pouvoir choisir d'autres types de "selecteur", pour le moment je fais des recherches uniquement par ID
• j'aimerais pouvoir facilement indiquer le type de champ, car pour le moment je fais de l'auto détection… mais cela ne sera pas toujours faisable

Ce que j'aimerais avoir

À noter que ce code n'est pas complet… c'est un brouillon.

from sealchemy import Form, TextField, SelectField, BooleanField

...

class AddCustomer(Form):
    __submit__ = Submit(name="_same")

    reference = TextField(default=u"C1345")
    type_user = SelectField(default=u"external")
    firstname = TextField(required=True)
    lastname = TextField(required=True)
    activated = BooleanField(default=True)
    comment = TextAreaField(default=u"")

    def go_to_page(self):
        self.driver.get("/customers/add/")

class EditCustomer(Form):
    __submit__ = Submit(name="_same")

    reference = TextField(default=u"C1345")
    type_user = SelectField(default=u"external")
    firstname = TextField(required=True)
    lastname = TextField(required=True)
    activated = BooleanField(default=True)
    comment = TextAreaField(default=u"")

    def go_to_page(self, id):
        self.driver.get("/customers/%s/" % id)

    def go_to_last_inserted(self):
        """Va sur la page du dernier client qui a été ajouté"""
        ...

Cela ressemble beaucoup à l'API de wtforms que j'utilise dans mon projet. Cela ressemble aussi à FormAlchemy que j'aime aussi.

__submit__ permet d'indiquer le champ à utiliser par la commande submit.

Note : je n'utilise pas une seule classe pour faire mes traitements "add" et "edit" car les formulaires d'ajouts et d'édition sont en pratique souvent différents.

L'interface de la classe de type Form :

class IForm(zope.interface.Interface):
    def inject():
        """Cette méthode injecte les données vers le formulaire HTML"""

    def submit():
        """Cette méthode lance le submit du formulaire"""

    def inject_and_submit():
        """Exécute inject et ensuite submit"""

    def check():
        """Cette méthode retourne True si les données correspondent aux
           données présentes dans le formulaire HTML"""

    def clear():
        """Réinitialise la valeur de tous les champs de l'instance avec
           les valeurs par défauts"""

    def populate(values):
        """Affecte des valeurs aux champs de l'objet."""

La classe Session de mon projet :

class MyProject(Session):
    def __init__(self, login, password):
        ...

    def login(self):
        ...

    add_customer = AddCustomer()
    edit_customer = EditCustomer()

Dans MyProject, j'ai ajouté les propriétés add_customer et edit_customer afin que ces objets aient accès à l'objet driver de Selenium.

Exemple d'utilisation :

session = MyProject(login="username", password="password", url="http://localhost:5000/")
session.login()

values = {
    "reference": u"C1871",
    "firstname": u"Stéphane",
    "lastname": u"Klein",
}
session.add_customer.populate(values)
session.add_customer.go_to_page()
session.add_customer.inject_and_submit()
session.edit_customer.go_to_last_inserted()
session.edit_customer.populate(values)
assert session.edit_customer.check()

Plus d'informations à propos des classes Field

Les classes de type Field comme TextField, BooleanField … ont un constructeur avec plusieurs paramètres :

• name (optionnel) : définit la méthode de recherche du champ par l'attribut "name"
• id (optionnel) : définit la méthode de recherche du champ par l'attirbut "id"
• xpath (optionnel) : définit la méthode de recherche via xpath
• required (optionnel) : définit si le champ est requis ou non
• default (optionnel) : définit la valeur par défaut du champ

Par défaut, si j'ai ceci :

class ...(Form):
    firstname = TextField()

C'est équivalent à cela :

class ...(Form):
    firstname = TextField(name="firstname")

Conclusion, questions

Je vous ai donc présenté l'API que j'imagine créer sous le nom de "sealchemy".

J'ai plusieurs questions :

• est-ce que vous pensez que cette librairie serait utile ?
• est-ce que l'API, le mode de fonctionnement est judicieux ?
• est-ce que cela vous intéresse ?
• est-ce que vous avez déjà créé quelque chose du même genre ?
• quelle est votre méthode pour faire ce genre de test ?

Merci d'avance pour vos commentaires.

Liste des applications / outils que j'utilise

Il y a quelques semaines, sur mon site, j'ai créé une nouvelle page qui s'intitule « Liste des applications / outils que j'utilise ».

Quelles sont les motivations qui m'ont poussé à réaliser cette page ?

• je trouve intéressant de savoir quels sont les outils que X ou Y utilise au quotidien… on y découvre souvent des choses intéressantes (donc n'hésitez pas à réaliser ce type de page). Un site qui a le même esprit est « Ils utilisent ça ».
• il arrive que l'on me demande quelle librairie j'ai choisi pour réaliser telle ou telle tâche
• parfois, je ne sais plus quelle librairie javascript j'ai choisi pour réaliser une tâche, dans ce cas cette page me sert de "pense-bête"

Dans le même esprit, j'ai commencé la page « Liste des applications Android que j'utilise » mais pour le moment elle n'est pas très étendue.

virtualenvwrapper

Depuis 3 semaines, j'utilise de plus en plus régulièrement virtualenvwrapper.

Cet outil est vraiment très pratique. Un petit résumé rapide d'utilisation (mais je vous conseille fortement de lire la documentation pour en savoir plus sur les divers fonctionnalités de l'outil, comment l'installer…) :

Je crée le dossier qui contiendra mon projet :

$ mkdir ~/projets/mon_projet/

Je crée un nouvel environement qui porte le même nom que mon projet :

$ mkvirtualenv mon_projet
New python executable in mon_projet/bin/python
Installing setuptools............done.
virtualenvwrapper.user_scripts creating /home/harobed/.virtualenvs/mon_projet/bin/predeactivate
virtualenvwrapper.user_scripts creating /home/harobed/.virtualenvs/mon_projet/bin/postdeactivate
virtualenvwrapper.user_scripts creating /home/harobed/.virtualenvs/mon_projet/bin/preactivate
virtualenvwrapper.user_scripts creating /home/harobed/.virtualenvs/mon_projet/bin/postactivate
virtualenvwrapper.user_scripts creating /home/harobed/.virtualenvs/mon_projet/bin/get_env_details

Quand j'active l'environement mon_projet je souhaite être déplacé directement dans le dossier ~/projets/mon_projet :

$ echo "cd ~/projets/mon_projet" >> /home/harobed/.virtualenvs/mon_projet/bin/postactivate

J'active l'environement mon_projet :

$ workon mon_projet
(mon_projet)$ pwd
/home/harobed/projets/mon_projet

À noter que les commandes fournies par virtualenvwrapper supportent pour la plupart l'auto complétion, par exemple workon <tab> affiche les environements disponibles sur votre système.

Consultez la documentation de virtualenvwrapper pour en savoir plus.

Mozilla Sync

Depuis que je suis passé à Firefox 4, j'utilise Firefox Sync pour centraliser mes bookmarks.

Avant cela, j'utilisais avec plaisir delicious mais l'extension delicious pour Firefox 4 n'est pas disponible.

En tout les cas, Firefox Sync fonctionne vraiment très bien, c'est très facile à configurer, c'est totalement transparent à l'usage… un très beau travail, réalisé entre autre par Tarek Ziade pour la partie serveur (codé en Python).

Critères de choix

Mes critères de sélection sont les suivants :

• Un laptop : cela fait des années que ma machine personnelle est un laptop et je trouve cela extrêmement plus pratique qu'une tour. Possiblité de se déplacer, silencieux…
• CPU : Intel Core i3 ou i5 ou i7
• Taille écran : entre 13" et 15"
• Définition écran : entre 1280x800px et 1680x1050px
• Traitement de surface : si possible mat
• Mémoire : minimum 4Go
• Disque dur : minimum 250 Go, si possible 7200 tours minutes
• Carte graphique : Intel (Intel HD Graphics…)
• Ethernet, Wifi… : si possible que du Intel
• Autres critères :
  • quelque chose d'assez solide (mon MacBook perso me fait toujours peur niveau solidité)
  • une sortie moniteur externe qui accepte un connecteur VGA
  • un bon support sous GNU/Linux (Ubuntu en particulier)
  • si il est possible d'ajouter un disque SSD, ça serait bien… mais bon ce n'est pas obligatoire
  • je veux quelque chose de silencieux
  • je veux quelque chose qui ne chauffe pas trop
  • au minimum trois sorties USB

Ma recherche

Dans un premier temps, j'étais désespéré, je ne trouvais aucun laptop < 17" qui avait une résolution verticale suppérieur à 768px. J'ai cherché sur RueDuCommerce, LDLC, Fnac … (les filtres de ces sites sont très limités).

Suite à une discussion sur LinuxFR, j'ai découvert Laptop Spirit.

Dans un premier temps, mon choix s'est porté sur le modèle suivant « Dell Latitude E5510 - Advanced » :

• Marque : Dell
• Taille : 15,6"
• Définition : 1600x900px
• Traitement surface : Mat
• Processeur : Core i5-560 2,66 GHz
• Carte graphique : Intel GMA HD
• Mémoire : 4 Go
• Disque dur : 250 Go 7200rpm
• Poids : 2,6 Kg

En fait, c'était le seul et l'unique portable qui correspondait à mes critères de recherche.

Ensuite via Wikipedia, j'ai découvert qu'il existait d'autres modèles avec une bonne définition écran : la série Dell Latitude .

En fait, la plupart du temps les hautes définitions sont en options, c'est donc pour cela qu'ils ne sont pas visibles sur les sites de ventes "généralistes".

De fil en aiguille, je suis tombé sur le wiki consacré aux ThinkPad de Lenovo : ThinkWiki, liste de tous les modèles ThinkPad .

En consultant les divers modèles présents sur ce wiki, j'ai découvert que les Lenovo ThinkPad Series T ont des résolutions écrans intéressantes.

Mon choix numéro 1

Mon choix s'est porté sur le modèle Lenovo ThinkPad T410 avec les caractéristiques suivantes :

• Intel Core i5-560M Processor (2.66GHz, 3MB L3)
• 14.1 WXGA+ TFT (1440x900px), w/ LED Backlight (WWAN antenna)
• Intel Graphics Media Accelerator 5700MHD
• 4 GB PC3-8500 DDR3 SDRAM 1067MHz SODIMM Memory (2 DIMM)
• UltraNav (TrackPoint and TouchPad) with Fingerprint Reader
• 320GB 7200rpm 2.5" SATA HDD
• DVD Recordable 8x Max Dual Layer, Ultrabay Slim (Serial ATA)5
• 9 cell 2.8Ah Li-Ion Battery - Dual Mode60
• Intel Centrino Advanced-N 6200 (2x2 AGN)10

Pourquoi un ThinkPad ?

Bien que j'ai l'impression que la tendance soit aux Apple MacBook Pro même chez les geeks sous GNU/Linux, les ThinkPad anciennement de marque IBM et maintenant Lenovo jouissent d'une très grande réputation chez les libristes.

Cette réputation est dû à la qualité matériel de ces portables, ils sont parmi les plus solides et fiables du marché. Illustration :

• Vidéo de comparaison de la solidité de l'écran LCD d'un ThinkPad avec celui d'un Dell
• Vidéo de comparaison de la résistance à l'eau entre un ThinkPad T410 et un HP 8440p
• Vidéo d'un crash test d'un ThinkPad
• Vidéo de test de poussière
• Autre vidéo de résistance à l'eau
• …

Je ne sais pas si ces vidéos sont des trucages marketing ou non, mais cela va dans le sens des sentiments des possesseurs de ThinkPad.

Comme je suis assez design "allemand de l'est", je trouve ces portables très beaux.

Les ThinkPad sont très populaire parmit les développeurs de logiciels libres, par conséquent les systèmes d'exploitation GNU/Linux sont généralement très biens supportés sur ces machines.

Paul Rouget a un ThinkPad T410, je lui ai demandé par mail si un OS GNU/Linux fonctionne bien sur cette machine, il m'a répondu qu'il n'avait aucun problème.

Où acheter un Lenevo ThinkPad T410 en France ?

Sur le site USA de Lenovo, il est possible de définir précisément la configuration de sa machine.

Avec la configuration suivante :

• System components
• Intel Core i5-560M Processor (2.66GHz, 3MB L3)
• Genuine Windows 7 Home Premium 32
• 14.1 WXGA+ TFT, w/ LED Backlight (WWAN antenna)
• Intel Graphics Media Accelerator 5700MHD - AMT
• 4 GB PC3-10600 DDR3 SDRAM 1333MHz SODIMM Memory (1 DIMM)
• UltraNav (TrackPoint and TouchPad) with Fingerprint Reader
• Camera, 2.0 MP
• 320 GB Hard Disk Drive, 7200rpm
• DVD Recordable 8x Max Dual Layer, Ultrabay Slim (Serial ATA)
• Smart Card
• 6 cell 2.6Ah Li-Ion Battery - Dual Mode
• Country Pack North America with Line cord & 65W AC adapter
• Bluetooth w/ antenna
• Intel Centrino Ultimate-N 6300 (3x3 AGN)
• Integrated Mobile Broadband - Upgradable

le numéro de produit est 2516CTO et le prix est à $1,169.00.

• Compufirst
• Ebizcuss
• GammeWeb
• Inmac Webstore

Actuellement, le seul modèle en stock chez l'un de ces revendeurs qui correspond un peu au modèle que je souhaite est le suivant : Lenovo ThinkPad T410I CI5/480M-2.4G. Il a les caractéristique suivantes :

• Contrôleur graphique : NVIDIA Quadro NVS 3100M / Intel HD Graphics
• Mémoire vidéo : 512 Mo
• Sortie audio : Carte son
• RAM : 4 Go (installé) / 8 Go (maximum) - DDR3 SDRAM - 1066 MHz - PC3-8500 ( 1 x 4 Go )
• Réseaux : Adaptateur réseau - Ethernet, Fast Ethernet, Gigabit Ethernet, IEEE 802.11b, IEEE 802.11g, IEEE 802.11n, Bluetooth 2.1
• Alimentation : CA 120/230 V ( 50/60 Hz )
• Disque dur : 320 Go - Serial ATA-300 - 5400 tours/min
• Poids : 2.3 kg
• Stockage optique : DVD±RW (+R double couche) - module enfichable amovible
• Affichage 14.1" rétroéclairage par LED TFT 1440 x 900 ( WXGA+ )
• Processeur : Intel Core i5 480M / 2.66 GHz ( à deux noyaux )
• Télécommunications : Fax / modem / modem cellulaire
• Transmission à large bande sans fil : Haut débit 3G Mobile
• Périphérique(s) d'entrée : Clavier, TrackPoint, UltraNav
• Batterie : 6 éléments Lithium Ion
• Système d'exploitation : Microsoft Windows 7 Professionnel Édition 64 bits --
• Dimensions (LxPxH) 33.6 cm x 23.9 cm x 3.2 cm
• Normes environnementales : ENERGY STAR , EPEAT Gold
• Garantie du fabricant : 3 ans de garantie --
• Mémoire cache : 3 Mo - L3
• Sécurité intégrée : Trusted Platform Module (TPM 1.2) Security Chip , lecteur d'empreintes digitales
• Localisation : Français / France
• Périphériques intégrés : Haut-parleurs stéréo, antenne LAN sans fil, ThinkLight, antenne Bluetooth, antenne cellulaire, Lecteur de carte SIM
• Lecteur de carte : 5 en 1
• Carte NIC sans fil : Intel Centrino Wireless-N 1000
• Autonomie (jusqu'à) : 6.5 heure(s)
• Caméra de portable : Intégré(e) - 2 mégapixels

Voici les points qui ne correspondent pas à mon besoin :

• Disque dur : "5400 tours/min" alors que je veux 7200 tours/min
• Contrôleur graphique : "NVIDIA Quadro NVS 3100M / Intel HD Graphics" alors que je veux uniquement une carte "Intel HD Graphics"
• Transmission à large bande sans fil : "Haut débit 3G Mobile" j'ai pas besoin de cela

Le prix de ce modèle : 1,294.00 € HT, 1,547.62 € TTC

Le modèle qui correspondait plus à mes souhait était le suivant Lenovo ThinkPad T410 Réf 2537-25G i5-540M(2.53GHz) à 1,043.07€ HT, 1,247.51€ TTC mais il est en rupture de stock. J'ai essayé de le commander, mais le vendeur m'a informé que ce n'est pas possible ils n'en auront plus.

Je trouve tout même triste que Lenovo ne vendent pas directement leurs produits en Europe comme le fait Dell. Je pense que Lenovo perd beaucoup de ventes potentiels en Europe.

Autres choix

Si je ne prends pas le Lenovo ThinkPad T410, j'ai identifié quatre modèles intéressants chez Dell.

Conclusion

Face à tant de difficulté pour trouver le modèle de ThinkPad que je veux, je pense prendre le modèle « Dell Latitude E6510 avec OS Ubuntu ». D'autant plus que chez Lenovo, ça me fait chier de devoir payer la "taxe" Microsoft pour un système d'exploitation que je n'utilise pas.

Mes questions

• Où achetez vous vos Laptop Lenovo en France ?
• Est-ce que la définition 1920 X 1080px est trop importante pour un 15" ?