Le kit du bon développeur Rails

Capybara est une gem permettant de tester votre site ou votre application tel que le ferait un utilisateur en navigant. Cela permet donc d'avoir des tests suivant des scénarios précis et adaptés à l'usage qui sera fait de votre site. Des informations sont disponibles sur le Github de Capybara.

Vous pouvez donc, au travers de vos tests, établir des scénarios de navigation afin de tester différentes parties de votre site ou application. Il est par exemple possible de tester le processus de connexion :

if "signs user in" do
  within("#login") do
    fill_in 'Login', :with => 'user@example.com'
    fill_in 'Password', :with => 'password'
  end

  click_link 'Sign in'
end

Ici, on remplit les champs login et password avec les informations souhaitées puis on clique sur le bouton de soumission du formulaire.

Il est également possible de tester des éléments JavaScript avec Capybara. Il suffit pour cela de le spécifier lors de votre test :

describe 'js tests', :js => true do
  it 'test a specific js part'
end

Afin de vous familiariser davantage avec cette gem, vous pouvez lire l'article consacré à Capybara sur notre blog.

Là encore, Capybara n'est pas la seule gem disponible, il y a une multitude de gems disponibles pour tester votre application.

Pour ce qui est des tests unitaires, il est possible d'utiliser différentes gems. Nous avons choisi dans notre cas Minitest qui est livré avec Ruby 1.9. Si vous avez un projet en 1.8 il vous suffit de l'ajouter à votre Gemfile :

group :test, :development do
  gem 'minitest'
end

Minitest est une bibliothèque de test permettant de créer des tests unitaires pour votre site ou application, des informations sont disponibles sur la page Github.

Afin de mieux comprendre comment fonctionne cette gem, je vous conseille de lire l'article consacré à Minitest sur notre blog.

Minitest::Spec▲

require 'minitest/spec'
require 'minitest/autorun'

require 'rake/testtask'

Rake::TestTask.new do |t|
  t.name = "spec"
  t.libs.push 'spec', Dir.pwd
  t.test_files = FileList['spec/**/*_spec.rb']
end

Lorsque vous avez des tests automatisés dans votre application, il est toujours bon de savoir s'ils couvrent une proportion raisonnable de votre application ou bien s'ils ne concernent qu'une petite partie du code.

Simplecov est une gem qui vous permet de savoir quel pourcentage de votre code est couvert par les tests. Cette dernière est très simple d'utilisation et vous apporte des informations très utiles.

Afin d'installer cette gem, il suffit de l'ajouter au Gemfile :

group :test do
  gem 'simplecov', :require => :false
end

Après avoir lancé un bundle install vous pouvez donc utiliser Simplecov ou presque. En effet, il est nécessaire d'ajouter cette gem dans le votre test_helper pour pouvoir l'utiliser.

require 'simplecov'
SimpleCov.start

Attention, ces deux lignes doivent être ajoutées tout en haut de votre fichier.

Enfin, il vous suffit de lancer vos tests via rake test:units par exemple et vous allez pouvoir savoir quel est le pourcentage de votre code qui est couvert par vos tests. Un répertoire coverage est créé dans votre application et si vous consultez le fichier coverage/index.html vous pouvez avoir toutes les informations dont vous aurez besoin.

Spork est une gem permettant d'avoir un serveur de test, mais contrairement à ce que fait Rails habituellement, il ne recharge pas tous les fichiers mais uniquement ceux qui ont changé. Ceci permet un gain de temps lors de l'exécution des tests (qui peut parfois s'avérer très long si le nombre de tests est important).

Spork fonctionne avec différentes bibliothèques de tests telles que RSpec, Cucumber. Il est également possible de l'utiliser avec guard via la gem guard-spork.

Pour utiliser spork dans votre application Rails il suffit d'ajouter la gem à votre Gemfile :

gem 'spork-rails'

ou, si vous utilisez un TestUnit

gem 'spork-testunit'

Ensuite, pour lancer spork, il vous suffit de taper la commande suivante :

spork

Puis lorsque vous lancerez vos tests, spork se chargera de ne recharger que les fichiers nécessaires.

Vous pouvez trouver davantage d'informations sur cette gem sur la page Github de spork.

Whenever est une gem qui vous permet de gérer les tâches récurrentes de votre projet. En effet, elle vous offre la possibilité de créer des crons jobs pour votre application, le tout dans une syntaxe simplifiée.

Dans un premier temps, il vous suffit de l'ajouter à votre Gemfile puis de l'installer via un bundle install :

gem 'whenever', :require => false

Ensuite, une commande vous permet de générer le fichier config/schedule.rb dans lequel vous spécifierez vos crons après que vous vous soyez rendu à la racine de votre projet :

wheneverize

Vous pouvez maintenant créer les crons jobs que vous souhaitez sous la forme suivante :

every 2.hours do
  runner "MyModel.my_process"
end

every 1.week, :at => '1:00 am' do
  rake "my:rake:task"
end

every :hour do
  command "/usr/bin/my_great_command"
end

Il est également possible d'intégrer whenever avec Capistrano pour le déploiement de votre application comme cela est expliqué sur le Github de cette gem.

Resque est une gem permettant de gérer des tâches asynchrones, en différant certaines actions à l'aide d'un système de files d'attente (ou queues).

Cela permet de rendre la main à l'utilisateur rapidement en déportant l'exécution d'un traitement lourd. On peut imaginer par exemple un envoi d'image qui sera par la suite compressée.

Plutôt que d'exécuter le traitement directement après l'envoi on crée une tâche asynchrone d'encodage et l'utilisateur peut immédiatement envoyer une autre image. Il est averti quand le traitement a été exécuté.

Avant de pouvoir utiliser Resque, il y a quelques prérequis. Il faut en effet avoir installé redis. Ensuite, il vous faut le lancer via la commande suivante :

redis-server /usr/local/etc/redis.conf

Maintenant, vous allez pouvoir ajouter Resque à votre Gemfile puis lancer un bundle install.

Une fois installé, vous devez créer la tâche Rake correspondante pour pouvoir utiliser Resque. Pour cela, il suffit de créer le ficher /lib/tasks/resque.rake et d'y coller le code suivant :

task "resque:setup" => :environment

Les workers peuvent donc être lancés via la tâche suivante :

# Sans spécifier de queue
QUEUE='*' rake environment resque:workers
# Pour spécifier une queue
QUEUE=my_queue rake environment resque:workers

# Pour limiter le nombre de workers
QUEUE=my_queue COUNT=5 rake environment resque:workers

Vous pouvez donc maintenant mettre dans les files d'attente des tâches de votre application afin qu'elles soient différées via la méthode suivante, par exemple depuis le model :

Resque.enqueue(Model, self.id)

Plus d'exemples et d'informations sont disponibles sur la page Github de resque ou bien dans le Railscast sur cette gem.

Tout comme la gem précédente, Delayed Job permet d'exécuter des tâches différées, que ce soit pour envoyer des mails, retoucher des images ou encore bien d'autres choses. Vous pouvez trouver différentes informations à propos de cette gem sur la page Github.

Après avoir installé la gem (en l'ajoutant à votre Gemfile et en lançant la commande bundle install), une commande vous permet de créer la table nécessaire au fonctionnement de cette gem :

script/generate delayed_job
rails generate delayed_job

Vous pouvez ensuite configurer le fonctionnement de delayed_job à travers un initializer : config/initializers/delayed_job_config.rb.

Pour lancer les workers, il vous suffit de taper la commande suivante :

rake jobs:work

Il est dorénavant possible d'ajouter des tâches à la liste d'attente afin qu'elles soient effectuées en différé. Pour cela, comme pour resque, vous devez les ajouter à la queue via une méthode :

Delayed::Job.enqueue NewsletterJob.new('My newsletter...', Customers.all.map(&:email))

Cocaine est une gem permettant l'exécution de commandes. Pour l'installer, il suffit de l'ajouter à votre Gemfile puis de lancer la commande bundle install :

gem "cocaine"

Ensuite, vous pouvez donc exécuter des lignes de commandes depuis votre application Rails au travers des lignes suivantes :

c = Cocaine::CommandLine.new("my_command", "my 'simple' options")
c.command        # renvoie la commande, dans notre cas : "my_command my 'simple' options"
output = c.run    # exécute la commande et renvoie le résultat

Si une commande ne fonctionne pas, alors une exception est levée, il est donc possible de les récupérer :

c = Cocaine::CommandLine.new("my_command", "my 'simple' options")

begin
  c.run
rescue Cocaine::ExitStatusError => e
  e.message
end

Il est donc possible d'exécuter les commandes que vous souhaitez dans votre projet via cette gem. Vous pourrez trouver d'autres exemples et informations sur la page Github de cocaine.

Guard permet de savoir si des modifications ont eu lieu sur des fichiers de votre application afin d'exécuter différentes commandes en fonction de ces dernières. Par exemple, cette gem fonctionne avec minitest dans le but de relancer les tests quand le fichier est modifié, ou même de relancer les tests en rapport avec le model qui a changé.

Afin de pouvoir utiliser guard, il vous suffit de l'ajouter à votre Gemfile :

gem 'guard'

Puis de l'installer via la commande bundle install. Ensuite, la commande guard init vous permet de créer un fichier Guardfile. C'est dans ce dernier que vous allez pouvoir configurer la gem selon vos souhaits.

Une fois votre Guardfile à jour, il ne vous reste plus qu'à exécuter la commande guard pour lancer la gem. De nombreuses options sont disponibles suivant vos besoins (vous pouvez le voir sur la page github).

Guard vous permet également de convertir des fichiers .coffee en .js si cela est nécessaire.

La page Github de guard vous permettra d'en savoir plus sur cette gem si vous souhaitez l'utiliser.