Linguaggi / Perl

Perl web automation (seconda parte)

Abstract
Grazie ad alcuni moduli Perl vedremo come sia semplice creare (registrare) degli script per automatizzare l'accesso a risorse on-line. Le applicazioni sono molteplici, dal controllo periodico della vostra casella di web-mail, mandare sms on-line, fino alla registrazione di una serie di macro per il testing di una web application e molto altro.

Data di stesura: 20/02/2005
Data di pubblicazione: 18/03/2005
Ultima modifica: 04/04/2006

di Marco Lamberto

Contenuti

Web testing
Registrare
HTTP::Proxy
HTTP::Recorder
Riproduzione e testing
Conclusioni

Web testing

Nella parte precedente^[4] abbiamo visto come realizzare degli script per simulare e quindi automatizzare l'interazione con un sito web. In questa seconda parte vedremo come ridurre al minimo l'intervento di natura programmativa per generare gli script stessi.

È indubbio che operare realmente su un sito da testare, visitare la nostra web-mail, etc. sono tutte azioni più comode e veloci da realizzare con un mouse che non scrivendo il codice.

Quando tuttavia un'operazione particolare diventa ripetitiva, magari con una frequenza costante o comunque elevata, può diventare utile semplificarsi la vita e trovare qualcuno che lo faccia per noi. In alternativa alla persona fisica c'è sempre il nostro calcolatore che è decisamente adatto a fare operazioni in maniera iterativa e soprattutto non si stanca (al massimo scalda un po' più del solito!).

Registrare

Premessa la volontà di non realizzare manualmente tutte le righe di codice perché l'agente LWP::UserAgent o WWW::Mechanize facciano le operazioni volute, la sola strada percorribile è intercettare e registrare l'attività di un utente reale sull'interfaccia web voluta.

Successivamente sarà possibile la modifica e la parametrizzazione di alcune parti dell'elenco di operazioni ottenuto.

HTTP::Proxy

Intercettare, interporsi, sono compiti che un proxy fa per definizione! Il primo modulo modulo che useremo sarà proprio un oggetto che ci permette di realizzare dei proxy. La sintassi è semplice e sono una manciata i metodi che interessano per il nostro scopo.

L'esempio successivo mostra un piccolo script per creare un proxy HTTP che risponda alla porta 9876.

```
use HTTP::Proxy; 
```
```
 
```
```
my $proxy = HTTP::Proxy->new; 
```
```
$proxy->port(9876); 
```
```
$proxy->start; 
```

Sintesi estrema, il tutto potrebbe essere condensato ad un comando impartibile da un prompt di shell:

perl -MHTTP::Proxy -e 'HTTP::Proxy->new(port => 9876)->start'

Il proxy è pronto, ma così com'è ci serve ben poco, raccoglie le richieste dei client, le inoltra autonomamente, ritorna i dati e nulla più.

Figura 1

HTTP::Proxy opera le richieste tramite una propria istanza di LWP::UserAgent, è possibile sostituirla tramite il metodo agent di HTTP::Proxy con un altro oggetto, la cui classe sia derivata da LWP::UserAgent.

HTTP::Recorder

Un'istanza di HTTP::Recorder può essere utilizzata allo scopo. Il modulo in questione marca il documento HTML ritornato da una richiesta in modo da potersi accorgere quali links vengano seguiti o quali forms inviati.

Di default registra le azioni in codice Perl adatto all'esecuzione con WWW::Mechanize, nel particolare presuppone l'esistenza di un'istanza con nome $agent.

HTTP::Recorder permette di specificare un file di destinazione in cui salvare gli eventi registrati (n.b. lo script viene aperto in modalità "append", se esiste già non viene sovrascritto ma le nuove righe verranno aggiunte in coda).

Bastano poche righe ed il proxy per registrare è pronto:

```
#!/usr/bin/perl -w 
```
```
 
```
```
use strict; 
```
```
use HTTP::Proxy; 
```
```
use HTTP::Recorder; 
```
```
 
```
```
 
```
```
my $proxy = HTTP::Proxy->new; 
```
```
my $agent = HTTP::Recorder->new; 
```
```
 
```
```
$agent->file('session.pl'); 
```
```
 
```
```
$proxy->port(8080); 
```
```
$proxy->agent($agent); 
```
```
$proxy->start; 
```

Per provarlo ho eseguito il browser testuale lynx e registrato una ricerca con Google.

$ ./recorder0.pl &
$ export http_proxy=http://localhost:8080
$ lynx http://www.google.com

Quello che segue è il file session.pl generato:

```
 
```

$agent->get("http://www.google.com/");

```
 
```

$agent->get("http://www.google.it/cxfer?c=PREF%3D:TM%3D1109256170:S%3D861XClBC

3FksuGrw&prev=/");

```
 
```
```
$agent->get("http://www.google.it/"); 
```
```
$agent->form_name("f"); 
```
```
$agent->field("hl", "it"); 
```
```
$agent->field("ie", "ISO-8859-1"); 
```
```
$agent->field("q", "ginko biloba"); 
```

$agent->submit_form(form_name => "f");

Nel file una linea vuota separa tutti gli eventi relativi ad una specifica pagina dai precedenti.

A questo punto il file ottenuto può essere epurato dalle operazione spurie ed eventualmente parametrizzato, in questo esempio si potrebbe sostituire l'argomento della query "ginko biloba" con una variabile.

Nota: suggerisco vivamente l'uso della versione di sviluppo di HTTP::Recorder, che al momento è la 0.03_01. La versione stabile è invero afflitta da alcuni bugs sui forms e non supporta l'uso di SSL.

Riproduzione e testing

Con qualche riga in più del programma precedente possiamo scrivere un semplice esecutore di sequenze:

```
#!/usr/bin/perl -w 
```
```
 
```
```
use strict; 
```
```
use WWW::Mechanize; 
```
```
 
```
```
 
```
```
unless ($#ARGV == 0) { 
```
```
  print STDERR <<"EOT"; 
```
```
usage: $0 [sessionfile] [...] 
```
```
EOT 
```
```
  exit 1; 
```
```
} 
```
```
 
```
```
 
```
```
my $agent = WWW::Mechanize->new( 
```
```
  keep_alive  => 1, 
```
```
  agent       => 'SIBot/1.2', 
```
```
  autocheck   => 1, 
```
```
); 
```
```
 
```
```
$agent->env_proxy; 
```
```
 
```
```
 
```
```
print "starting\n"; 
```
```
local *IS; 
```
```
local $\ = undef; 
```
```
foreach (@ARGV) { 
```
```
  print "  $_ ... "; 
```
```
  open(IS, "< $_") or die $!; 
```
```
  eval <IS>; 
```
```
  close IS; 
```
```
  print $@ ? 'error' : 'passed'; 
```
```
  print "\n"; 
```
```
} 
```
```
print "all done\n"; 
```

L'esempio è piuttosto semplice, prende come argomenti dei file generati con HTTP::Recorder e li esegue sequenzialmente dopo aver istanziato WWW::Mechanize. Il contenuto degli script viene eseguito tramite la funzione di eval, in caso di errore viene mostrato un messaggio di test non passato, come in una sorta di HTTP-unit "povero".

$ ./player0.pl session.pl 
starting
  session.pl ... passed
all done

Conclusioni

Certamente il modulo HTTP::Recorder non sarà la soluzione completa per tutti resta tuttavia indubbia di questo strumento che in una manciata di righe permette di risparmiare gran parte del tempo normalmente dedicato alla generazione manuale di sequenze di test.

Perl è ormai disponibile su moltissime piattaforme e, come abbiamo potuto vedere in questi primi articoli, non fa solo CGI e manipolazione di testi!

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

Sorgente dell'esempio.
http://www.siforge.org/articles/2005/03/perl_web_automation2/recorder0.pl (1Kb)
Sorgente della sessione registrata.
http://www.siforge.org/articles/2005/03/perl_web_automation2/session.pl (1Kb)
Sorgente del player.
http://www.siforge.org/articles/2005/03/perl_web_automation2/player0.pl (1Kb)
Perl web automation, prima parte.
http://www.siforge.org/articles/2005/02/17-perl_web_automation.html