Linguaggi / Perl

Perl web automation

Abstract
Per molti Perl è stato ed è il linguaggio per i CGI o uno dei tools indispensabili per analizzare i log di un server.
In questo articolo verrà presentato quello che si può fare con Perl non solo dentro o dietro le quinte di un web server.

Data di stesura: 08/02/2005
Data di pubblicazione: 17/02/2005
Ultima modifica: 04/04/2006

di Marco Lamberto

Contenuti

Web automation
Un esempio concreto
Un primo approccio
LWP::UserAgent
WWW::Mechanize
Installazione dei moduli Perl mancanti
Conclusioni

Web automation

Simulare l'interazione di un utente mediante un browser è un'esigenza che nasce in diversi ambiti per trovare una collocazione quanto mai naturale all'interno delle attività di testing.

In questo documento verranno presentate una serie di moduli per il linguaggio Perl, liberamente disponibili, che possono essere usati nell'ottica della web automation.

Un esempio concreto

Prendiamo ad esempio la pagina principale di un sito sicuramente noto ai più: freshmeat.net. Il sito permette agli utenti registrati di vedere le notizie e le releases in maniera selettiva.

Supponiamo di voler realizzare un micro agente in Perl che operi una login sul sito, acceda alla sezione degli articoli e stampi a video i primi dieci titoli con i relativi links.

Nella figura successiva potete vederne una porzione, è stato evidenziato in rosso il form di login.

Figura 1: La pagina principale di freshmeat.net

Gli utenti dei browser Mozilla, Netscape e Firefox, possono accedere a delle informazioni dettagliate sulla pagina tramite la funzione di "View Page Info". Di particolare utilità è il tab "Forms".

Nella pagina principale del sito sono presenti quattro forms, essendo tutti anonimi, un breve confronto con la pagina relativa permette di scoprire che il quarto è quello che c'interessa.

Figura 2

Dei campi contenuti "username" e "password" sono gli unici che verranno usati.
È importante non dimenticare il campo "Form Action", perché è la pagina a cui devono essere mandati i dati della form mediante una richiesta con metodo POST.

L'algoritmica della soluzione all'esempio proposto, visti i fini didattici, è molto semplice, nulla vieta di estenderla per permettere il salvataggio dei cookies tra un'esecuzione e l'altra e sfruttare il meccanismo di login persistente fornito da freshmeat.net.

Un primo approccio

Inizialmente si potrebbe pensare di ricorrere all'uso del modulo Socket o meglio ancora di IO::Socket, quest'ultimo infatti fornisce un'interfaccia ad oggetti per l'uso delle socket.

L'esempio successivo mostra un uso di IO::Socket per ottenere la pagina all'indirizzo http://localhost/.

```
#!/usr/bin/perl -w 
```
```
use IO::Socket; 
```
```
 
```
```
$remote = IO::Socket::INET->new( 
```
```
    Proto    => "tcp", 
```
```
    PeerAddr => "localhost", 
```
```
    PeerPort => "http(80)", 
```

  ) or die "cannot connect to http port at localhost";

```
 
```
```
print $remote <<'EOT'; 
```
```
GET / HTTP/1.0 
```
```
Host: localhost 
```
```
 
```
```
 
```
```
EOT 
```
```
 
```
```
while (<$remote>) { 
```
```
  print; 
```
```
} 
```

Risulta più che mai evidente lo svantaggio maggiore di un approccio eccessivamente a basso livello che porta alla gestione manuale non solo della connessione TCP/IP ma anche di tutto il protocollo HTTP, senza dimenticare la gestione degli errori per entrambi i protocolli (con conseguenti deliri e follia).

La situazione con Socket è peggiore, poiché questo modulo non fa altro che esporre in Perl le primitive C di socket.h, tanto vale scrivere il tutto direttamente in C!

Ovviamente lo scopo primario per uno sviluppatore dovrebbe essere semplificarsi la vita per concentrarsi sul problema e non sui problemi necessari per ottenere un contesto risolutivo del problema ... anche se non sempre è così.
Per fortuna in questo caso ne possiamo uscire con tutti i capelli attaccati alla testa! (E non perché abbiamo strappato quelli del nostro compagno di "pair programming"!)

LWP::UserAgent

Dimentichiamoci delle socket TCP e passiamo poco sopra ad HTTP: esiste da parecchi anni libwww-perl ^[4], una collezione di moduli che permettono la programmazione in maniera agevole e completa di web clients.

Nello specifico il modulo LWP::UserAgent permette di simulare un client web.
Questo fornisce il supporto per richieste GET, POST e HEAD, redirezioni, proxy, cookies e molto altro, il tutto, ovviamente, con un approccio ad oggetti.

```
require LWP::UserAgent; 
```
```
 
```
```
my $ua  = LWP::UserAgent->new; 
```
```
 
```
```
$ua->env_proxy; 
```
```
 
```

my $res = $ua->get('http://localhost/');

```
 
```

die $res->status_line unless $res->is_success;

```
 
```
```
print $res->content; 
```

Segnalo il modulo LWP::Simple che espone un'interfaccia procedurale equivalente a LWP::UserAgent.

Ecco dunque cosa accade quando si usa questo modulo per tentare di risolvere il nostro problema:

fm_lwp.pl

```
#!/usr/bin/perl -w 
```
```
 
```
```
use strict; 
```
```
use LWP::UserAgent; 
```
```
use HTTP::Cookies; 
```
```
use IO::Handle; 
```
```
 
```
```
autoflush STDERR 1; 
```
```
 
```
```
# 
```
```
# LWP::UserAgent setup 
```
```
# 
```
```
 
```
```
my $cookies = HTTP::Cookies->new; 
```
```
my $ua      = LWP::UserAgent->new( 
```
```
  keep_alive              => 1, 
```

  agent                   => 'SIBot/1.0',

  requests_redirectable   => ['HEAD', 'GET', 'POST'],

  cookie_jar              => $cookies,

```
); 
```
```
 
```
```
$ua->env_proxy; 
```
```
 
```
```
 
```
```
# 
```
```
# quick'n'dirty user/pass request 
```
```
# 
```
```
 
```
```
print STDERR "Login: "; 
```
```
my $user = <STDIN>; 
```
```
chomp $user; 
```
```
 
```
```
print STDERR "Password: "; 
```
```
my $pass = <STDIN>; 
```
```
chomp $pass; 
```
```
 
```
```
 
```
```
# 
```
```
# login 
```
```
# 
```
```
 
```

my $login = $ua->post('http://freshmeat.net/login', {

```
  url         => '/', 
```
```
  username    => $user, 
```
```
  password    => $pass, 
```
```
  persistent  => 1, 
```
```
  submit      => 'Login', 
```
```
}); 
```
```
 
```
```
die "login failed" unless 
```

  $login->is_success or $login->content =~ /logged in as user /;

```
 
```
```
 
```
```
# 
```
```
# retrieve data 
```
```
# 
```
```
 
```

my $articles  = $ua->get('http://freshmeat.net/lounge/articles/');

```
 
```

die "failed retrieving articles" unless $articles->is_success;

```
 
```
```
 
```
```
# 
```
```
# content parsing 
```
```
# 
```
```
 
```

my @list = grep(m#<a href="[^"]+"><b>[^<]+</b></a>#,

  split(/[\r\n]/, $articles->content));

```
 
```
```
foreach (@list[0 .. 9]) { 
```

  m#<a href="([^"]+)"><b>([^<]+)</b></a>#;

  print "$2\nhttp://freshmeat.net$1\n";

```
} 
```

Confrontando l'esempio iniziale di LWP::UserAgent con quest'ultimo esempio, è possibile notare come la complessità del sorgente sia ovviamente aumentata, in particolare si rende necessario tenere traccia di una serie di riferimenti ad oggetti creati lungo il flusso d'esecuzione.
Quest'ultima esigenza non è un grosso problema, tuttavia una serie di tare legate allo sviluppo con LWP::UserAgent sono superabili grazie all'adozione di un altro modulo.

WWW::Mechanize

WWW::Mechanize^[5] è un'estensione di LWP::UserAgent e rende decisamente più agile la realizzazione di scripts di automazione in virtù di una serie di metodi che permettono di navigare con continuità attraverso i links ed i documenti html scaricati.

Una delle prime cose da notare è che WWW::Mechanize tenta di emulare un web client "classico", l'interfaccia esposta è sicuramente più ad alto livello di LWP::UserAgent, poiché ad esempio tiene traccia della sequenza di link visitati in maniera analoga alla history di un browser, gestisce i cookies in maniera automatica (il default di LWP::UserAgent è di non gestirli, da qui la necessità nell'esempio precedente di passargli un cookie_jar).

Altro punto a favore di WWW::Mechanize è la possibilità di compilare i forms e farne il submit più comodamente di quanto non si riesca con LWP::UserAgent.

fm_mec.pl

```
#!/usr/bin/perl -w 
```
```
 
```
```
use strict; 
```
```
use WWW::Mechanize; 
```
```
use IO::Handle; 
```
```
 
```
```
autoflush STDERR 1; 
```
```
 
```
```
# 
```
```
# WWW::Mechanize setup 
```
```
# 
```
```
 
```
```
my $mech    = WWW::Mechanize->new( 
```
```
  keep_alive              => 1, 
```

  agent                   => 'SIBot/1.1',

```
  autocheck               => 1, 
```
```
); 
```
```
 
```
```
$mech->env_proxy; 
```
```
 
```
```
 
```
```
# 
```
```
# quick'n'dirty user/pass request 
```
```
# 
```
```
 
```
```
print STDERR "Login: "; 
```
```
my $user = <STDIN>; 
```
```
chomp $user; 
```
```
 
```
```
print STDERR "Password: "; 
```
```
my $pass = <STDIN>; 
```
```
chomp $pass; 
```
```
 
```
```
 
```
```
# 
```
```
# login 
```
```
# 
```
```
 
```
```
$mech->get('http://freshmeat.net/'); 
```
```
$mech->submit_form( 
```
```
  form_number => 4, 
```
```
  fields      => { 
```
```
    username  => $user, 
```
```
    password  => $pass, 
```
```
  } 
```
```
); 
```
```
 
```

die "login failed" unless $mech->content =~ /logged in as user /;

```
 
```
```
 
```
```
# 
```
```
# retrieve data 
```
```
# 
```
```
 
```

$mech->follow_link(text_regex => qr/\[My\]/) or die;

$mech->follow_link(text_regex => qr/\d+ new articles/) or die;

```
 
```
```
 
```
```
# 
```
```
# content parsing 
```
```
# 
```
```
 
```

my @list = grep(m#<a href="[^"]+"><b>[^<]+</b></a>#,

```
  split(/[\r\n]/, $mech->content)); 
```
```
 
```
```
foreach (@list[0 .. 9]) { 
```

  m#<a href="([^"]+)"><b>([^<]+)</b></a>#;

  print "$2\nhttp://freshmeat.net$1\n";

```
} 
```

Rispetto al precedente esempio cambiano una serie di cose, la prima che spicca è l'assenza di variabili temporanee per le operazioni di "navigazione", WWW::Mechanize mantiene tutto al suo interno ed è possibile interrogarlo solo quando servono realmente i dati.

Altra cosa importante è la gestione automatica degli errori di connessione tramite l'impostazione ad 1 del valore di autocheck.
Così facendo non è più necessario valutare ad ogni operazione se è andata a buon fine o meno.
La gestione degli errori si può quindi spostare un po' più in alto e limitarsi a controllare che la pagina ottenuta sia quella voluta:

LWP::UserAgent

```
die "login failed" unless 
```

  $login->is_success or $login->content =~ /logged in as user /;

WWW::Mechanize

die "login failed" unless $mech->content =~ /logged in as user /;

L'altra cosa che ho cercato di rendere evidente è l'approccio differente alla navigazione che si ha con WWW:Mechanize, è possibile seguire i links senza dover inserire le url di cui fare GET o POST.

$mech->follow_link(text_regex => qr/\[My\]/) or die;

$mech->follow_link(text_regex => qr/\d+ new articles/) or die;

Altrettanto utile è la possibilità di fare il submit di un form semplicemente specificare solo i campi che si vogliono modificare o riempire, per gli altri userà il valore di default specificato nel documento HTML.

Installazione dei moduli Perl mancanti

Non tutte le distribuzioni di Perl includono i moduli presentati.
L'installazione, anche da utente semplice, può essere fatta appoggiandosi al modulo CPAN.

$ perl -MCPAN -e shell
Terminal does not support AddHistory.

cpan shell -- CPAN exploration and modules installation (v1.7601)
ReadLine support available (try 'install Bundle::CPAN')

cpan>

A questo punto basterà scrivere il comando "install WWW::Mechanize" (e confermarlo con il tasto di invio!) per procedere con l'installazione del modulo e delle sue eventuali dipendenze mancanti.

Per ulteriori dettagli suggerisco la lettura della pagina di manuale relativa al modulo CPAN mediante il comando "perldoc CPAN".

Conclusioni

Come accennato all'inizio del documento, l'automazione è molto utile durante il web testing. A partire dalla generazione dei singoli test fino alla loro esecuzione, sono problematiche decisamente pressanti. In molti casi ricorrere a soluzioni script-based può costituire un risparmio notevole in tempo e grattacapi.
Nel prossimo articolo affronteremo la problematica dell'automazione del testing (registrazione ed esecuzione) con Perl grazie all'ausilio di WWW::Mechanize ed un paio di moduli di supporto.

Informazioni sull'autore

Marco Lamberto, laureato in Informatica presso la Statale di Milano, con diversi anni di esperienza sistemistica, di sicurezza e sviluppo prevalentemente in ambienti UNIX (Linux in primis) con linguaggi come C, Java, Perl, PHP, XML, HTML, ...

È possibile consultare l'elenco degli articoli scritti da Marco Lamberto.

Altri articoli sul tema Linguaggi / Perl.

Risorse

Sorgenti del primo esempio con LWP::UserAgent.
http://www.siforge.org/articles/2005/02/perl_web_automation/fm_lwp.pl (2Kb)
Sorgenti del secondo esempio con WWW::Mechanize.
http://www.siforge.org/articles/2005/02/perl_web_automation/fm_mec.pl (2Kb)
Sito ufficiale del progetto libwww-perl.
http://www.linpro.no/lwp/
Pagina del CPAN relativa al pacchetto di libwww-perl.
http://search.cpan.org/~gaas/libwww-perl/
Pagina del CPAN relativa al pacchetto di WWW::Mechanize.
http://search.cpan.org/~petdance/WWW-Mechanize/

Perl web automation

Web automation

Un esempio concreto

Un primo approccio

LWP::UserAgent

WWW::Mechanize

Installazione dei moduli Perl mancanti

Conclusioni

Informazioni sull'autore

Risorse

Cosa ne pensi di questo articolo?

Discussioni

	Articoli Manifesto Tools Links Canali Libri Contatti ?
	Autori Temi Società e associazioni