Selenium wiki formatter (textile e altri)

Di recente avevo necessità di copiare dei test case creati con Selenium IDE su Redmine, si potrebbe allegarli ma l’intenzione è quella di mostrali come una tabella.

Ho cosi’ consultato velocemente la pagina su come creare un custom format.

Da li’, a meno di eccezioni (quali l’escape della pipe | ) ho creato questo semplice script da aggiungere nel menu opzioni di Selenium IDE nel tab formats (inserite Wiki nel campo wiki format name e sovrascrivete con il seguente contenuto):

var wiki = {
confluence:{
  start_table: "",
  end_table: "",
  header: "||Command||Target||Value||\n",
  header_row:"||#",
  start_row: "| ",
  end_row: " |\n",
  separator: " | ",
},
dokuwiki:{
  start_table: "",
  end_table: "",
  header: "^ Command ^ Target ^ Value ^\n",
  header_row:"^ # ",
  start_row: "| ",
  end_row: " |\n",
  separator: " | ",
},
mediawiki:{
  start_table: "{|border=\"1\" \n",
  end_table: "|}",
  header: "!Command\n!Target\n!Value\n",
  header_row:"!#\n",
  start_row: "|-\n|",
  end_row: "\n",
  separator: "\n|",
},
moinmoin:{
  start_table: "",
  end_table: "",
  header: "||\'\'\'Command\'\'\'||\'\'\'Target\'\'\'||\'\'\'Value\'\'\'||\n",
  header_row:"||\'\'\'#\'\'\'",
  start_row: "||",
  end_row: "||\n",
  separator: "||",
},
textile:{
  start_table: "",
  end_table: "",
  header: "|_. Command|_. Target|_. Value|\n",
  header_row:"|_. #",
  start_row: "|",
  end_row: "|\n",
  separator: "|",
},
trac:{
  start_table: "",
  end_table: "",
  header: "||= Command =||=  Target =||=  Value =||\n",
  header_row:"||= # =",
  start_row: "||",
  end_row: "||\n",
  separator: "||",
},
twiki:{
  start_table: "",
  end_table: "",
  header: "|  *Command*  |  *Target*  |  *Value*  |\n",
  header_row:"| *#*",
  start_row: "|  ",
  end_row: "  |\n",
  separator: "  |  ",
},
xwiki:{
  start_table: "",
  end_table: "",
  header: "|=Command|=Target|=Value\n",
  header_row:"|=#",
  start_row: "|",
  end_row: "\n",
  separator: "|",
}
};

function formatCommands(commands) {
  var result = '';
  var start_table =  wiki[options['wiki']]["start_table"];
  var end_table =  wiki[options['wiki']]["end_table"];
  var header = wiki[options['wiki']]["header"];
  var header_row = wiki[options['wiki']]["header_row"];
  var start_row = wiki[options['wiki']]["start_row"];
  var end_row = wiki[options['wiki']]["end_row"];
  var sep = wiki[options['wiki']]["separator"];
  var row_num = '';
  for (var i = 0; i < commands.length; i++) {
    var command = commands[i];
    if('true' == options.row)
            row_num= i+sep;
    if (command.type == 'command') {
      result += start_row + row_num+ command.command + sep + command.target + sep + command.value + end_row;
    }
  }
    if('true' == options.row)
         header = header_row+header;
    result = start_table + header + result + end_table;
  return result;
}

function parse(testCase, source) {
  var doc = source;
  var commands = [];
  var start_row = wiki[options['wiki']]["start_row"];
  var sep = wiki[options['wiki']]["separator"];
  while (doc.length > 0) {
    var line = /(.*)(\r\n|[\r\n])?/.exec(doc);
    var line2 = line[1].slice(start_row.length);
    var array = line2.split(sep);
    if (array.length >= 3) {
      var command = new Command();
      command.command = array[0];
      command.target = array[1];
      command.value = array[2];
      commands.push(command);
    }
    doc = doc.substr(line[0].length);
  }
  testCase.setCommands(commands);
}

function format(testCase, name) {
  return formatCommands(testCase.commands);
}

options = {wiki: 'confluence', row:"false"};

configForm = '<description>Choose a wiki syntax:</description>' + '<menulist id="options_wiki">'
+ 	'<menuitem label="Confluence" value="confluence"/>' +
+ 	'<menuitem label="DokuWiki" value="dokuwiki"/>' +
	'<menuitem label="MediaWiki" value="mediawiki"/>' +
	'<menuitem label="MoinMoin" value="moinmoin"/>' + '<menuitem label="Textile" value="textile"/>' + '<menuitem label="Trac" value="trac"/>' + '<menuitem label="Twiki" value="twiki"/>' + '<menuitem label="Xwiki" value="xwiki"/>' + '</menupopup>' + '</menulist>'+ '<separator class="groove"/>' + '<checkbox id="options_row" label="Row number"/>';

Dal menu delle opzioni, vedete che confluence  è impostato di default (potete abilitare anche i numeri di riga tramite la checkbox) e potete scegliere tra Confluence, DokuWiki, MediaWiki, MoinMoin, Textile (Redmine), Trac, Twiki e Xwiki.

Una volta salvato, andate in Options -> Format e scegliete Wiki, cliccate poi sul tab Source e vedete il test case nel formato wiki da voi scelto, potete poi copiare e incollare nel vostro wiki preferito.

Redmine e Coldfusion: syntax highlighting e icone

Ultimamente sto lavorando su un software scritto in Coldfusion e contemporaneamente sto usando Redmine come bug tracking tool.

Redmine permette di vedere il repository Subversion e supporta anche il syntax highlighting per diversi linguaggi di programmazione, eccetto Coldfusion che, tra l’altro, segue la sintassi XML.

Inoltre Redmine ha delle icone customizzate che permettono di distinguere i tipi di file come per PHP o XML.

Ho prima di tutto avuto un piccolo problema in quanto nella configurazione di Apache avevo messo Redmine come virtual host e, avendo incluso il modulo Jrun per Coldfusion, Redmine lasciava interpretare a Coldfusion il codice invece di mostralo, di conseguenza ho dovuto disabilitarlo per Redmine come evidenziato nella configurazione seguente:

# JRun Settings
LoadModule jrun_module /opt/coldfusion8/runtime/lib/wsconfig/1/mod_jrun22.so
<IfModule mod_jrun22.c>
    JRunConfig Verbose false
    JRunConfig Apialloc false
    JRunConfig Ignoresuffixmap false
    JRunConfig Serverstore /opt/coldfusion8/runtime/lib/wsconfig/1/jrunserver.store
    JRunConfig Bootstrap 127.0.0.1:51800
    #JRunConfig Errorurl url
    #JRunConfig ProxyRetryInterval 600
    #JRunConfig ConnectTimeout 15
    #JRunConfig RecvTimeout 300
    #JRunConfig SendTimeout 15
    AddHandler jrun-handler .jsp .jws .cfm .cfml .cfc .cfr .cfswf
</IfModule>
Listen 81
<VirtualHost *:81>
        ServerName redmine
        DocumentRoot /var/www/redmine/public
        ServerAdmin user@server.com
        LogLevel warn
        ErrorLog /var/log/apache2/redmine_error
        CustomLog /var/log/apache2/redmine_access combined

        RemoveHandler jrun-handler
        SetHandler default-handler
        <Directory /var/www/redmine/public>
                Options Indexes FollowSymLinks MultiViews
                AllowOverride None
                Order allow,deny
                allow from all
        </Directory>
</VirtualHost>

Ho poi associato le estensioni cfm e cfc alla sintassi per xml modificando il file file_type.rb che si trova in /redmine/plugins/coderay-0.7.6.227/lib/coderay/helpers/  modificando la parte della struttura TypeFromExt e aggiungendo i campi:
'cfm' => :xml,
'cfc' => :xml,

In questa maniera i file coldfusion avranno la sintassi colorata come un file XML.

Per quanto riguarda le icone dovete sapere che Redmine assegna degli stili ai tipi di file e come stile assegna infatti le icone.

Ho prima di tutto modificato il file mime_type.rb nella cartella /redmine/lib/redmine/, aggiungendo le 2 seguenti righe nella struttura MIME_TYPES:

'application/x-coldfusion' => 'cfc',
'magnus-internal/cold-fusion' => 'cfm',

e poi ho aggiunto i 2 stili con 2 icone (fatte da me su 2 piedi :-) ) nel file application.css in /redmine/public/stylesheets/, aggiungendo le seguenti righe (cercate la sezioen .icon-file):

.icon-file.magnus-internal-cold-fusion { background-image: url(../images/files/cfm.png); }
.icon-file.application-x-coldfusion { background-image: url(../images/files/cfc.png); }

Come avete notato Redmine trasforma il mime type in uno stile (convertendo / in – ) ogni volta che incontra un file indicato che poi potete plasmare.Le 2 icone da mettere nella cartella /redmine/public/images/files sono le seguenti:

Riavviate Apache non appena avete fatto le modifiche.

A presto !

Redmine: non solo bug tracking

Cercavo un sistema web di bug tracking e avevo già notato Trac e lo consideravo per via dei suoi innumerrevoli plugin il migliore, tuttavia il caso della vita vuole che scopro Redmine principalmente per 3 ragioni:

  • supporto multiprogetto cosa che Trac sembra non avere (in tal caso si dovrebbbero creare più istanze di Trac)
  • dipendenza tra bug, cosa che Trac sembra non avere
  • possibilità di inviare un bug anche tramite email, non so se Trac ha questa funzionalità.

Googlando trovo Redmine che a sorpresa vedo gestire più revision control systems (SVN, CVS, GIT, Bazaar, Mercurial, Darcs), supporta LDAP ed è multilinguaggio.

Redmine è scritto in Ruby on Rails ed rilasciato con licenza GPL.

Per poterlo provare esiste una demo:

http://demo.redmine.org/

oppure installarlo velocemente in locale con lo stack Bitnami:

http://bitnami.org/stack/redmine

Una volta loggati l’interfaccia risulta pulita, in alto a sinistra vedere My Page (issue assegnati a voi), Projects (per creare o vedere i vostri progetti), Administrations (dove potete gestire utenti e ruoli, assegnare i ruoli alle atttività di Bug, Feature o Support), impostare lo stile del sito, notifiche email, autenticazione LDAP.

Una delle caratteristiche interessanti è il diagramma di Gantt che si viene a creare per ogni progetto per ogni bug aggiunto in tal modo si può avere una visione di insieme di come sta evolvendo il progetto. Potete salvare il diagramma in PDF e PNG. Avete comunque una visione a calendario.

Tra i progetti che usano Redmine trovate Ruby, Lighttpd, Typo3 e PHPBB

Piccola nota:Esiste un plugin per Hudson.

Lascio a voi il piacere di scoprire il resto! Ovviamente se avete una vostra esperienza con Redmine fatemi sapere!