Traduzione: prima di modificare il codice di un’applicazione che non conosci, magari scritta male, generalmente da un’altro, è buona norma scrivere un programma che simuli l’intervento dell’utente e svolga tutte le operazioni più importanti sull’applicazione stessa.

Con Selenium è possibile pilotare il browser e quindi muoversi tra le pagine di un sito, compilare form, cliccare link, draggare elementi. Quando facciamo questo sulla nostra applicazione stiamo eseguendo un test automatico per verificare che si comporti come ci aspettiamo. Quando invece lo facciamo su un altro sito per raggiungere delle informazioni ed estrarle periodicamente, stiamo facendo web scraping.

La leggenda narra che con il Selenium IDE sia possibile registrare delle macro, mentre un utente reale esegue le operazioni sull’applicazione, per poi rieseguirle in un secondo momento e verificare che questa continui a comportarsi nello stesso modo, nonostante il programmatore abbia cambiato la sua struttura interna.

Ad oggi questo mito è stato ormai sfatato poiché è evidente che il modo più pratico per utilizzare Selenium è quello di programmare manualmente le operazioni da eseguire attraverso una delle varie librerie a disposizione per ciascuno linguaggio di programmazione.

Per funzionare Selenium deve poter pilotare un browser, ad esempio Firefox, ed un browser ha bisogno di un ambiente grafico per funzionare. Su un server web però non abbiamo un ambiente grafico. Sul proprio computer invece è piuttosto difficile ed irritante fare qualsiasi altra cosa mentre Firefox continua ad aprirsi e a sbilinare da solo.

Possiamo però simulare l’ambiente grafico e dire a Selenium di usarlo. La parolina magica, suggeritami da Giorgio Sironi all’AgileDay2013, è xvfb.

Installiamo Xvfb e facciamo in modo che venga lanciato all’avvio della macchina:

sudo apt-get install xvfb
sudo vim /etc/init.d/xvfb

# /etc/init.d/xvfb

#!/bin/bash

if [ -z "$1" ]; then
echo "`basename $0` {start|stop}"
exit
fi

case "$1" in
start)
/usr/bin/Xvfb :99 -ac -screen 0 1024x768x8 > /dev/null &
;;

stop)
killall Xvfb
;;
esac

sudo chmod 755 /etc/init.d/xvfb
vim ~/.bash_aliases

# ~/.bash_aliases

...
alias xvfb='etc/init.d/xvfb'

sudo /etc/init.d/update-rc.d xvfb default 10

Ora è possibile avviare xvfb tramite il comando xvfb start e fermarlo tramite xvfb stop

Ora installiamo Selenium.
scarichiamo da http://docs.seleniumhq.org/download/ l’ultima versione di Selenium Server (formerly the Selenium RC Server):
Lo mettiamo tra le nostre librerie e poi facciamo la stessa cosa che abbiamo fatto per xvfb, ne semplifichiamo l’esecuzione.

wget http://selenium.googlecode.com/files/selenium-server-standalone-2.39.0.jar
sudo mkdir /var/lib/selenium
sudo mv selenium-server-standalone-2.39.0.jar /var/lib/selenium
cd /var/lib/selenium
sudo ln -s selenium-server-standalone-2.39.0.jar selenium-server.jar
sudo vim /etc/init.d/selenium

# /etc/init.d/selenium

#!/bin/bash

if [ -z "$1" ]; then
echo "`basename $0` {start|stop}"
exit
fi

export DISPLAY=":99"
case "$2" in
show)
export DISPLAY=":0"
;;
esac

case "$1" in
start)
java -jar /var/lib/selenium/selenium-server.jar -browserSessionReuse > /dev/null &
;;

stop)
curl http://localhost:4444/selenium-server/driver/?cmd=shutDownSeleniumServer
;;
esac

sudo 755 selenium
vim ~/.bash_aliases

# ~/.bash_aliases
...
alias selenium='etc/init.d/selenium'

Ora è possibile avviare selenium nell’ambiente grafico generato da xvfb con il comando selenium start oppure in quello reale (se c’è) con selenium start show, e fermarlo con selenium stop

In alcuni casi potrebbe essere interessante lanciarlo all’avvio del server: lo si può fare con

sudo /etc/init.d/update-rc.d selenium default 20

Se non l’avete fatto non rimane che installare Firefox

sudo apt-get install firefox

Ora possiamo creare test funzionali con Selenium2 PHPUnit Extension oppure far web scraping con Mink

Questo articolo non è altro che un’assemblaggio ed una personalizzazione delle pratiche lette nei seguenti:

http://www.installationpage.com/selenium/how-to-run-selenium-headless-firefox-in-ubuntu/
http://www.labelmedia.co.uk/blog/setting-up-selenium-server-on-a-headless-jenkins-ci-build-machine.html
http://testerinyou.blogspot.it/2011/05/run-selenium-rc-using-command-prompt.html

Direi che è tutto. Ciao!

Beh, avevo letto del Composite Pattern e mi era venuta in mente un’idea per metter in pratica quanto appreso.
Cercavo un modo per dedicare il giusto tempo alle mille attività che dovevo/volevo svolgere senza trascurare nulla, ma soprattutto senza trascurare le cose più importanti:

Quanto tempo devo dedicare alla pulizia della casa? Quanto ne posso dedicare alle attività della mia associazione? Ma della pulizia della casa, quanto tempo dedico alla cucina e quanto alla camera da letto?

Insomma volevo costruire una gerarchia (un albero) di attività da svolgere, in cui ogni attività potesse essere suddivisa in sottoattività e così via. Ad ogni attività avrei quindi assegnato un livello di priorità (da 1 a 10 per esempio). Avrei infine scelto un monte ore di riferimento (ad esempio 100 ore) da distribuire automaticamente a ciascuna attività in base alle loro priorità. Il Composite Pattern era perfetto per gestire gerarchie di elementi e avrei potuto sperimentare un approccio TDD. Il nome che gli avrei dato sarebbe stato Prioritree.

Non mi ci volle molto per realizzare un prototipo. Sarebbe stato impossibile implementare le classi che gestiscono una gerarchia senza l’ausilio di test unitari.
Praticamente si doveva definire la propria gerarchia di attività con le loro priorità ed il monte ore assegnato su un file Yaml:

// mytasks.yml
Root:
  data: timeBox=100
  children:
     Casa:
        data: priority=10
        children:
           Camera da letto:
              data: priority=6
           Bagno:
              data: priority=10
           Cucina:
              data: priority=8
     Associazione:
        data: priority=6
        children:
           Sito:
              data: priority=2
           Facebook:
              data: priority=4
           Eventi:
              data: priority=10

eseguendo un semplice php index.php il file veniva arricchito con le ore assegnate a ciascuna attività.

// mytasks.yml
Root:
   data: usedTime=0; timeBox=100; progress=0%; time=0/100
   children:
      Casa:
         data: usedTime=0; priority=10; progress=0%; time=0/62.5
         children:
            Camera da letto:
               data: usedTime=0; priority=6; progress=0%; time=0/15.63
            Bagno:
               data: usedTime=0; priority=10; progress=0%; time=0/26.04
            Cucina:
               data: usedTime=0; priority=8; progress=0%; time=0/20.83
      Associazione:
         data: usedTime=0; priority=6; progress=0%; time=0/37.5
         children:
            Sito:
               data: usedTime=0; priority=2; progress=0%; time=0/4.69
            Facebook:
               data: usedTime=0; priority=4; progress=0%; time=0/9.38
            Eventi:
               data: usedTime=0; priority=10; progress=0%; time=0/23.44

Successivamente era possibile specificare il tempo utilizzato per ciascuna attività  a qualsiasi livello di dettaglio impostando usedTime; rilanciando php index.php veniva aggiornato il progresso percentuale e le ore assegnate su tutte le attività discendenti ed ascendenti.

// mytasks.yml
Root:
   data: usedTime=0; timeBox=100; progress=11%; time=11/100
   children:
      Casa:
         data: usedTime=2; priority=10; progress=17.6%; time=11/62.5
         children:
            Camera da letto:
               data: usedTime=4; priority=6; progress=29.87%; time=4.67/15.63
            Bagno:
               data: usedTime=5; priority=10; progress=21.76%; time=5.67/26.04
            Cucina:
               data: usedTime=0; priority=8; progress=3.2%; time=0.67/20.83
      Associazione:
         data: usedTime=0; priority=6; progress=0%; time=0/37.5
         children:
            Sito:
               data: usedTime=0; priority=2; progress=0%; time=0/4.69
            Facebook:
               data: usedTime=0; priority=4; progress=0%; time=0/9.38
            Eventi:
               data: usedTime=0; priority=10; progress=0%; time=0/23.44

Era possibile cambiare le priorità delle attività oppure cambiare la struttura dell’albero in qualsiasi momento: le ore assegnate cambiavano, nessun problema.

Faceva altre cose ovviamente, come resettare il monte ore portandosi dietro i debiti e i crediti del monte ore precedente, ma l’idea in soldoni era questa.

Utilizzai come contenitore un microframework che stavo realizzando per i miei progetti personali ispirato a quanto avevo letto di Symfony e dell’archiettura MVC. Solo l’anno scorso imparai ad utilizzare Git e Github e vi pubblicai il mio Prioritree.

Quest’estate, però, ho imparato ad utilizzare Silex, il fratellino minore di Symfony 2, grazie ad un lavoretto con Ideato. Quindi ho pensato di riprendere il Prioritree e sostituire il mio incompleto e rozzo microframework con Silex, al fine di costruire in un secondo momento una’interfaccia web decente per quello che ora è solo un set di classi.

Grazie ai vecchi test il porting è stato rapido e indolore e questo è il risultato.

Ho cercato di fare commit piccole e significative in modo da mettere in evidenza tutti i passaggi fatti per cambiare contenitore. I tag v1.0 e v2.0  corrispondono rispettivamente al Prioritree prima e dopo il travaso in Silex.

Ora manca il Readme in markdown e buttar su un’interfaccia web semplice semplice per poterlo pubblicare e rendere disponibile a tutti. E’ la prima volta che a distanza di anni riesco a riprendere del vecchio codice e a riutilizzarlo senza che mi faccia schifo.

Nota: quando un comando apre un editor di testo segue il testo da inserirvi indentato.

Hardware

Un portatile Asus X54C con disco a stato solido e 6Gb di RAM.

Il DSS è un buon investimento dato che fa risparmiare da subito tanto tempo e stress/frustrazione, quindi lo consiglio vivamente.

Sistema Operativo

Ubuntu 12.x

LAMP

L’installazione di un sistema LAMP si trova ovunque come per esempio qui . Ecco i comandi in rapida sequenza senza ulteriori spiegazioni:

sudo apt-get install apache2

verifica: Apache funziona?
Browser -> http://localhost

$ sudo apt-get install php5 libapache2-mod-php5
$ sudo service apache2 restart
$ sudo gedit /var/www/testphp.php
    <?php phpinfo(); ?>

verifica: PHP funziona?
Browser -> http://localhost/test.php

$ sudo apt-get install mysql-server
$ sudo apt-get install libapache2-mod-auth-mysql php5-mysql
$ sudo apt-get install phpmyadmin
$ sudo service apache2 restart

PhpMyAdmin

Abbiamo già installato PHPMyAdmin. Rendiamolo accessibile da
http://phpmyadmin

$ sudo gedit /etc/apache2/sites-available/phpmyadmin
    <VirtualHost *:80>
        ServerAdmin myemail@email.com
        ServerName phpmyadmin
        ServerAlias phpmyadmin.local.com
        DocumentRoot /usr/share/phpmyadmin
        DirectoryIndex app.php index.php index.html
        <Directory /usr/share/phpmyadmin>
            AllowOverride all
        </Directory>
        ErrorLog ${APACHE_LOG_DIR}/phpmyadmin.error.log
        # Possible values include: debug, info, notice, warn, error, crit,
        # alert, emerg
        LogLevel notice
        CustomLog ${APACHE_LOG_DIR}/phpmyadmin.access.log combined
    </VirtualHost>
$ sudo a2ensite phpmyadmin
$ sudo gedit /etc/hosts
    127.0.0.1 phpmyadmin
$ sudo a2enmod rewrite
$ sudo service apache2 restart

verifica: PhpMyAdmin funziona?
Browser -> http://phpmyadmin

NetBeans

Per lo sviluppo PHP, l’IDE che ho scelto, dopo anni di Eclipse, è NetBeans.

Download Netbeans:
Browser -> http://netbeans.org/downloads/start.html?platform=linux&lang=en&option=php

$ cd ~/Scaricati
$ sudo chmod 777 netbeans-7.1-ml-php-linux.sh
$ ./netbeans-7.1-ml-php-linux.sh

Permissions

Il vostro utente dovrebbe essere proprietario della cartella www

$ sudo chown -R myuser /var/www

Nota: recentemente l’ho spostata in ~/www e quindi è già di proprietà del l’utente.

Symfony2

Installando Symfony potrò usarne il tool di configurazione e ottimizzare il sistema per ospitarlo. Per un’applicazione complessa Symfony 2 è il framwork ideale. Per qualcosa di un po’ più semplice c’è Silex

donwload

Browser -> http://symfony.com/download

$ cd ~/Scaricati
$ cp Symfony_Standard_Vendors_2.0.x.tgz /var/www/
$ cd /var/www/
$ tar -xf Symfony_Standard_Vendors_2.0.x.tgz

Browser -> http://localhost/Symfony/web/config.php

$ cd /var/www/Symfony

permissions

$ chmod -R 777 app/cache
$ chmod -R 777 app/logs

Lanciando Symfony (ma anche qualsiasi altro script PHP) da client (per i test ad esempio) l’utente è quello di sistema, mentre da browser è www-data; i file scritti in cache nel primo non sono accessibili nel secondo e viceversa creando non pochi problemi. Quindi:

$ setfacl -R -m u:www-data:rwx -m u:`whoami`:rwx app/cache app/logs
$ setfacl -dR -m u:www-data:rwx -m u:`whoami`:rwx app/cache app/logs

configuration

$ sudo apt-get install php5-sqlite
$ cd /etc/php5/conf.d/
$ sudo mv sqlite.ini sqlite.ini~
$ sudo service apache2 restart

$ sudo apt-get install php-apc
$ sudo service apache2 restart

$ sudo apt-get install php5-intl
$ sudo service apache2 restart

$ sudo gedit /etc/php5/apache2/php.ini
   short_open_tag = Off
   date.timezone = Europe/Paris
$ sudo service apache2 restart

Git

Dopo anni di SVN mi hanno fatto scoprire Git e l’ho scelto per la velocità e perché… c’è GitHub . Insomma se non hai un account GitHub sei fuori.

$ sudo apt-get install git-core git-gui git-doc
$ sudo apt-get install gitg
$ git config --global color.ui true

Browser -> http://help.github.com/linux-set-up-git/

Pear

Pear serve per reperire i pacchetti PHP presenti su Pear, fondamentalmente PHPUnit.

$ sudo apt-get install php-pear
$ pear config-set auto_discover 1

PHPUnit

Per testare il codice PHP lo standard de facto è PHPUnit. Per testare il proprio codice ci vuole disciplina, ma ancora prima è necessario che non ci siano ostacoli alla gestione di una suite di test. In questo Symfony  2 ci aiuta molto.

$ sudo pear channel-discover pear.phpunit.de
$ pear install --alldeps phpunit/PHPUnit

Tools

I seguenti tools sono utilità molto avanzate di controllo del codice non particolarmente utili se non si utilizza Jenkins  e attualmente non lo uso.

$ pdepend --help
$ sudo pear channel-discover pear.pdepend.org
$ sudo pear install pdepend/PHP_Depend

$ phpmd --help
$ sudo pear channel-discover pear.phpmd.org
$ sudo pear install --alldeps phpmd/PHP_PMD

$ phpcs --help
$ sudo pear install PHP_CodeSniffer
$ phpcs
$ pear config-show | grep php_dir
$ cd /usr/share/php/PHP/CodeSniffer/Standards/
$ sudo git clone git://github.com/opensky/Symfony2-coding-standard.git Symfony2
$ sudo phpcs --config-set default_standard Symfony2

$ phpcpd --help
$ pear install pear.phpunit.de/phpcpd

$ phpdoc --help
$ sudo pear install PhpDocumentor

$ phpcb --help
$ sudo pear install phpunit/PHP_CodeBrowser

Phing

Phing permette di definire comandi che eseguono task ripetitivi, utili per la continous integration ma anche per facilitare la distribuzione del progetto su macchine di sviluppo differenti

$ sudo pear channel-discover pear.phing.info
$ pear install phing/phing

Ruby on Rails, Capifony e Less

Ruby serve principalmente per poter utilizzare Capistrano/Capifony per il deploy e Less, il CSS dinamico.

Seguire il tutorial per installare l’rvm e quindi ruby 1.9.2:

Browser -> http://www.the-tech-tutorial.com/?p=1868

Fermarsi prima dell’installazione di Rails. Non eseguire  $ gem install rails
Eseguire invece

$ gem install capifony

Aggiungere a ~/.bashrc
    if [ -f /etc/profile.d/rvm.sh ]; then
        source /etc/profile.d/rvm.sh
    fi $ sudo apt-get install libnode-less
$ sudo apt-get install npm nodejs
$ sudo npm install -g less

Virtual Host

$ sudo gedit /etc/apache2/sites-available/myproject
    <VirtualHost *:80>
        ServerAdmin myemail@email.com
        ServerName myproject
        ServerAlias myproject.local.com
        DocumentRoot /var/www/myproject/web
        DirectoryIndex app.php index.php index.html
        <Directory /var/www/myproject/web>
            AllowOverride all
        </Directory>
        ErrorLog ${APACHE_LOG_DIR}/myproject.error.log
        # Possible values include: debug, info, notice, warn, error, crit,
        # alert, emerg
        LogLevel notice
        CustomLog ${APACHE_LOG_DIR}/myproject.access.log combined
    </VirtualHost>
$ sudo a2ensite myproject
$ sudo gedit /etc/hosts
    127.0.0.1 myproject myproject.local.com
$ sudo a2enmod rewrite
$ sudo service apache2 restart

XDebug

$ sudo pecl install xdebug
$ find / -name 'xdebug.so' 2> /dev/null /usr/lib/php5/20090626+lfs/xdebug.so
$ sudo gedit /etc/php5/conf.d/xdebug.ini
    zend_extension="/usr/lib/php5/20090626+lfs/xdebug.so"
    xdebub.max_nesting_level=200
$ sudo service apache2 restart

Capifony

Ho trovato molto comodo Capifony per il deploy su Servergrove. Precedentemente lo abbiamo installato, qui si parla di come utilizzarlo per il deploy di un progetto Symfony 2 su ServerGrove:
http://blog.servergrove.com/2011/09/07/deploying-symfony2-projects-on-shared-hosting-with-capifony/ 

Inoltre:

$ gem install capifony capistrano-ext
$ gem install inifile

Controllare con

$ cap -vT

e verificare che ci sia la lista dei task disponibili.

Ora copiamo parameters.ini in parameters.yml (e lo convertiamo in uno yml file) e lanciamo
cap production database:move:to_local
Questo task copia in locale il db remoto.

CURL

$ sudo apt-get install php5-curl
$ sudo service apache2 restart

Nesting level

Ricontrollare phpinfo() -> xdebug.max_nesting_level=200
eventualmente riscriverlo in

$sudo gedit /etc/php5/conf.d/xdebug.ini

e

$ sudo service apache2 restart