[RUBY] [Rails] Comment implémenter un test unitaire d'un modèle

Conditions préalables

Cette fois, nous sortirons la méthode tout en implémentant un test unitaire du modèle pour l'enregistrement d'un nouvel utilisateur. Les spécifications pour l'enregistrement des utilisateurs sont les suivantes.

Pseudo requis
L'adresse e-mail est unique
l'adresse e-mail [email protected] le domaine doit être inclus
Mot de passe requis
Le mot de passe doit contenir au moins 7 caractères
Entrez le mot de passe deux fois, y compris pour confirmation
Le nom réel de l'utilisateur est requis pour le prénom et le nom
Laissez le vrai nom de l'utilisateur être entré en pleine largeur
Frigana du vrai nom de l'utilisateur est requis pour le prénom et le nom
Laissez le vrai nom de l'utilisateur Frigana être entré en pleine largeur
La date de naissance est requise

Le fichier de migration est le suivant.

20200823050614_devise_create_users.rb


class DeviseCreateUsers < ActiveRecord::Migration[5.2]
  def change
    create_table :users do |t|
      ## Database authenticatable
      t.string  :nickname,              null: false
      t.string  :email,                 null: false, default: ""
      t.string  :encrypted_password,    null: false, default: ""
      t.string  :family_name,           null: false
      t.string  :family_name_kana,      null: false
      t.string  :first_name,            null: false
      t.string  :first_name_kana,       null: false
      t.date    :birth_day,             null: false

      ## Recoverable
      t.string   :reset_password_token
      t.datetime :reset_password_sent_at

      ## Rememberable
      t.datetime :remember_created_at

      ## Trackable
      # t.integer  :sign_in_count, default: 0, null: false
      # t.datetime :current_sign_in_at
      # t.datetime :last_sign_in_at
      # t.string   :current_sign_in_ip
      # t.string   :last_sign_in_ip

      ## Confirmable
      # t.string   :confirmation_token
      # t.datetime :confirmed_at
      # t.datetime :confirmation_sent_at
      # t.string   :unconfirmed_email # Only if using reconfirmable

      ## Lockable
      # t.integer  :failed_attempts, default: 0, null: false # Only if lock strategy is :failed_attempts
      # t.string   :unlock_token # Only if unlock strategy is :email or :both
      # t.datetime :locked_at
      t.timestamps null: false
    end

    add_index :users, :email,                 unique: true
    add_index :users, :reset_password_token,  unique: true
    # add_index :users, :confirmation_token,   unique: true
    # add_index :users, :unlock_token,         unique: true
  end
end

Le modèle est le suivant.

user.rb


class User < ApplicationRecord
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable

    #Paramètres de validation(Contrainte d'unicité pour empêcher l'enregistrement de chaînes de caractères vides)
    validates :nickname,               presence: true
    validates :encrypted_password,     presence: true
    validates :family_name,            presence: true
    validates :family_name_kana,       presence: true
    validates :first_name,             presence: true
    validates :first_name_kana,        presence: true
    validates :birth_day,              presence: true
    
    #association
    has_many :cards,          dependent: :destroy
    has_many :shipping_infos, dependent: :destroy
    has_many :comments,       dependent: :destroy
    has_many :items
end

Procédure de montage

** ① Préparation pour RSpec ** ** ② Paramètres RSpec ** ** ③ Présentez factory_bot ** ** ④ Implémentation de factory_bot ** ** ⑤ Description de l'expression régulière ** ** ⑥ Implémentation du code de test ** ** ⑦ Exécution du code de test **

Préparation RSpec

Installez d'abord Gem.

Gemfile.rb


group :development, :test do
  
  #réduction

  gem 'rspec-rails'
end

group :development do
  gem 'web-console'
end

# web_Si la console a déjà une description, déplacez simplement l'emplacement de la description. Veuillez noter que si vous l'ajoutez, il peut être dupliqué.

Après avoir édité le Gemfile, n'oubliez pas d'exécuter l'installation du bundle.

Paramètres RSpec

Ensuite, définissez les paramètres de base pour RSpec. Commencez par créer un fichier de paramètres pour RSpec.

Terminal.


$ rails g rspec:install

#Succès si le fichier est créé comme suit ▼
 create  .rspec
 create  spec
 create  spec/spec_helper.rb
 create  spec/rails_helper.rb

Ensuite, ajoutez ce qui suit à .rspec.

.rspec.


--format documentation

Ensuite, définissez le répertoire pour RSpec.

Le fichier dans lequel le code de test de RSpec est écrit est appelé un fichier de spécification, et tous les fichiers de spécification sont stockés dans le répertoire de spécification généré par la commande précédente rails g rspec: install, alors créez-le ici. Gardons-le.

Un fichier de test pour les modèles est stocké sous spec / models /, et un fichier de test pour les contrôleurs est stocké sous spec / controllers /. Ce répertoire est l'endroit où se trouve tout le code du répertoire de l'application à tester.

Le fichier de spécification sera nommé _spec.rb avec la classe correspondante. Cette fois, nous allons d'abord créer un fichier de spécification pour "user.rb", donc le nom dans ce cas sera "" user_spec.rb "`.

Après avoir créé le répertoire, vérifiez une fois à ce stade si ** RSpec ** peut être utilisé normalement.

Terminal.


$ bundle exec rspec

#Si le résultat est le suivant, il est OK car il fonctionne normalement.
No examples found.

Finished in 0.00031 seconds (files took 0.19956 seconds to load)
0 examples, 0 failures

Factory_bot introduit

Ensuite, installez ** factory_bot **. Installez Gem.

Gemfile.rb


group :development, :test do
  
  #réduction

  gem 'rspec-rails'
  gem 'factory_bot_rails'
end

Ensuite, exécutez l'installation du bundle.

Implémentation de factory_bot

Ensuite, créez un répertoire appelé usines directement sous le répertoire spec, et créez un fichier Ruby dedans avec le nom de fichier au pluriel de l'instance créée. Dans ce cas, ce sera ʻusers.rb`.

Modifiez ʻusers.rb` comme suit.

users.rb


FactoryBot.define do

  factory :user do
    nickname              {"tarou"}
    email                 {"[email protected]"}
    password              {"1234567"}
    encrypted_password    {"1234567"}
    family_name           {"Yamada"}
    family_name_kana      {"Yamada"}
    first_name            {"Taro"}
    first_name_kana       {"Taro"}
    birth_day             {"2000-01-01"}
  end
end

Cette description crée le contenu selon les spécifications en tant que données factices, de sorte que vous pouvez facilement créer une instance par une méthode spécifique (construire ou créer) dans le fichier de spécifications ou l'enregistrer dans la base de données. Ce sera comme.

Description des expressions régulières

Ensuite, définissez l'expression régulière dans la validation selon les spécifications. Les expressions régulières requises sont:

Le mot de passe doit contenir au moins 7 caractères
Laissez le vrai nom de l'utilisateur être entré en pleine largeur
Laissez le vrai nom de l'utilisateur Frigana être entré en pleine largeur

Sur la base de ceux-ci, la description dans le modèle est la suivante.

user.rb


class User < ApplicationRecord
    #réduction

    validates :nickname,               presence: true
    validates :encrypted_password,     presence: true, length: { minimum: 7 } #Voici l'expression régulière pour le nombre de caractères
    validates :family_name,            presence: true, format: {with: /\A[Ah-Hmm-Un-龥]/ } #Il s'agit de l'expression régulière pleine largeur du vrai nom de l'utilisateur
    validates :family_name_kana,       presence: true, format: {with: /\A[UNE-Voiture-]+\z/ } #Il s'agit d'une expression régulière pleine largeur de Frigana
    validates :first_name,             presence: true, format: {with: /\A[Ah-Hmm-Un-龥]/ } #Il s'agit de l'expression régulière pleine largeur du vrai nom de l'utilisateur
    validates :first_name_kana,        presence: true, format: {with: /\A[UNE-Voiture-]+\z/ } #Il s'agit d'une expression régulière pleine largeur de Frigana

    #réduction
end

Veuillez vous référer au site suivant pour les expressions régulières Ruby. https://gist.github.com/nashirox/38323d5b51063ede1d41

Implémentation du code de test

Il est maintenant temps d'implémenter le code de test! Voici quelques points à garder à l'esprit lors de l'écriture du code de test:

① Une valeur est attendue dans chaque exemple
② Décrivez clairement et clairement le résultat attendu
③ Testez à la fois ce que vous voulez et ce que vous ne voulez pas qu'il se passe
④ Faites sécher modérément tout en tenant compte de la lisibilité

Écrivez le code suivant dans user_spec.rb.

user_spec.rb


require 'rails_helper'

describe User do
  describe '#create' do

  end
end

Puisqu'il s'agit d'un test unitaire du modèle utilisateur, il sera décrire l'utilisateur do, et comme il créera un nouvel utilisateur, il sera décrire '# create' do, et le code de test sera écrit dans la description sur la deuxième ligne.

Tout d'abord, vérifiez que ** peut être enregistré si tous les éléments sont saisis **. Le code et son explication sont les suivants.

user_spec.rb


require 'rails_helper'

describe User do
  describe '#create' do
    #Test une fois entré ▼

    it "L'enregistrement est possible si tous les éléments sont saisis" do #Ce que vous voulez tester
      user = build(:user)  #Utilisation de la méthode de construction sur l'utilisateur variable, usine_Remplacer les données factices du bot
      expect(user).to be_valid #Exécutez un test pour voir si l'enregistrement est fait avec les informations de l'utilisateur variable
    end
  end
end

Le test suivant est le suivant.

Impossible de s'inscrire sans pseudo
Impossible de s'inscrire sans e-mail
Impossible de s'inscrire sans mot de passe
encrypted_Impossible de s'inscrire sans mot de passe
family_Impossible de s'inscrire sans nom
family_name_Impossible de s'inscrire sans kana
first_Impossible de s'inscrire sans nom
first_name_Impossible de s'inscrire sans kana
birth_Impossible de s'inscrire s'il n'y a pas de jour

Ces conditions permettent de tester les éléments requis (null: false, présence: true) dans la spécification. Décrivons-le. L'explication sera donnée dans la partie test de ** Ne peut pas être enregistré sans pseudo **.

user.spec.rb


require 'rails_helper'

describe User do
  describe '#create' do

      #Test une fois entré ▼

      it "L'enregistrement est possible si tous les éléments sont saisis" do
        user = build(:user)
        expect(user).to be_valid
      end

      # nul:false, presence:Test vrai ▼

      it "Impossible de s'inscrire sans pseudo" do #Ce que vous voulez tester
        user = build(:user, nickname: nil) #Utilisation de la méthode de construction sur l'utilisateur variable, usine_Remplacer les données factices du bot(Dans ce cas, la valeur de nickname est intentionnellement définie sur)
        user.valid? #Utilisez la méthode de validation pour tester "s'il ne peut pas être enregistré en raison de la validation"
        expect(user.errors[:nickname]).to include("Entrez s'il vous plait") #Utilisez la méthode des erreurs pour cocher "Pourquoi ne puis-je pas enregistrer si la validation ne fonctionne pas?".to include("Entrez s'il vous plait")Écrivez l'instruction d'erreur dans(Puisque ce Rails est traduit en japonais, la phrase d'erreur est également en japonais)
      end

      it "Impossible de s'inscrire sans e-mail" do
        user = build(:user, email: nil)
        user.valid?
        expect(user.errors[:email]).to include("Entrez s'il vous plait")
      end

      it "Impossible de s'inscrire sans mot de passe" do
        user = build(:user, password: nil)
        user.valid?
        expect(user.errors[:password]).to include("Entrez s'il vous plait")
      end

      it "encrypted_Impossible de s'inscrire sans mot de passe" do
        user = build(:user, encrypted_password: nil)
        user.valid?
        expect(user.errors[:encrypted_password]).to include("Entrez s'il vous plait")
      end

      it "family_Impossible de s'inscrire sans nom" do
        user = build(:user, family_name: nil)
        user.valid?
        expect(user.errors[:family_name]).to include("Entrez s'il vous plait")
      end

      it "family_name_Impossible de s'inscrire sans kana" do
        user = build(:user, family_name_kana: nil)
        user.valid?
        expect(user.errors[:family_name_kana]).to include("Entrez s'il vous plait")
      end

      it "first_Impossible de s'inscrire sans nom" do
        user = build(:user, first_name: nil)
        user.valid?
        expect(user.errors[:first_name]).to include("Entrez s'il vous plait")
      end

      it "first_name_Impossible de s'inscrire sans kana" do
        user = build(:user, first_name_kana: nil)
        user.valid?
        expect(user.errors[:first_name_kana]).to include("Entrez s'il vous plait")
      end

      it "birth_Impossible de s'inscrire s'il n'y a pas de jour" do
        user = build(:user, birth_day: nil)
        user.valid?
        expect(user.errors[:birth_day]).to include("Entrez s'il vous plait")
      end
  end
end

Ensuite, nous testerons la contrainte d'unicité du courrier électronique.

user.spec.rb


require 'rails_helper'

describe User do
  describe '#create' do

      #réduction

      #e-mail test de contrainte d'unicité ▼

      it "Impossible de s'inscrire s'il y a des e-mails en double" do
        user = create(:user) #Usine en utilisateur variable et base de données en utilisant la méthode de création_Enregistrer les données factices du bot
        another_user = build(:user, email: user.email) #Seconde une autre_Créez un utilisateur en tant que variable et utilisez la méthode de construction pour dupliquer intentionnellement le contenu de l'e-mail
        another_user.valid? # another_Utilisateur de test "Impossible d'enregistrer en raison de la validation"
        expect(another_user.errors[:email]).to include("Existe déjà") #Utilisez la méthode des erreurs pour vérifier l'e-mail «Pourquoi ne puis-je pas enregistrer en raison de la validation?» Et écrivez la déclaration d'erreur qui l'a provoquée.
      end
  end
end

Ensuite, exécutez un test qui ne peut pas être enregistré sans un mot de passe de confirmation.

user.spec.rb


require 'rails_helper'

describe User do
  describe '#create' do

      #réduction

      #Test nécessitant une confirmation du mot de passe ▼
      
      it "crypté même si le mot de passe existe_Impossible de s'inscrire sans mot de passe" do
        user = build(:user, encrypted_password: "") #Vider intentionnellement la valeur du mot de passe de confirmation
        user.valid?
        expect(user.errors[:encrypted_password]).to include("Entrez s'il vous plait", "Veuillez saisir au moins 7 caractères")
      end
  end
end

À ce stade, les tests suivants ont été effectués.

#Test terminé ▼

Pseudo requis#Terminé
L'adresse e-mail est unique#Terminé
l'adresse e-mail [email protected] le domaine doit être inclus#Terminé
Mot de passe requis#Terminé
Entrez le mot de passe deux fois, y compris pour confirmation#Terminé
Le nom réel de l'utilisateur est requis pour le prénom et le nom#Terminé
Frigana du vrai nom de l'utilisateur est requis pour le prénom et le nom#Terminé
La date de naissance est requise#Terminé

#Test à mettre en œuvre à partir de maintenant ▼

Le mot de passe doit contenir au moins 7 caractères
Laissez le vrai nom de l'utilisateur être entré en pleine largeur
Laissez le vrai nom de l'utilisateur Frigana être entré en pleine largeur

Maintenant, testons l'expression régulière décrite précédemment. Tout d'abord, le mot de passe est un test de 7 caractères ou plus.

Testez à la fois ** ce que vous voulez et ce que vous ne voulez pas qu'il se passe **.

user.spec.rb


require 'rails_helper'

describe User do
  describe '#create' do

      #réduction

      #Test du nombre de caractères du mot de passe ▼

      it "Vous pouvez vous inscrire si le mot de passe contient 7 caractères ou plus" do
        user = build(:user, password: "1234567", encrypted_password: "1234567") #Définissez un mot de passe de 7 caractères à l'aide de la méthode de construction
        expect(user).to be_valid
      end
      
      it "Impossible d'enregistrer si le mot de passe est de 7 caractères ou moins" do
        user = build(:user, password: "123456", encrypted_password: "123456") #Définissez intentionnellement un mot de passe à 6 caractères pour tester si une erreur se produit
        user.valid?
        expect(user.errors[:encrypted_password]).to include("Veuillez saisir au moins 7 caractères")
      end
  end
end

Enfin, nous testerons une entrée pleine largeur et une entrée kana pleine largeur.

user.spec.rb


require 'rails_helper'

describe User do
  describe '#create' do

      #réduction

      #Nom du test d'entrée pleine largeur ▼

      it 'family_L'enregistrement n'est possible que si le nom est entré en pleine largeur' do
        user = build(:user, family_name: "Aio") #Entrez intentionnellement demi-largeur et générez une erreur
        user.valid?
        expect(user.errors[:family_name]).to include("Est une valeur non valide")
      end

      it 'first_L'enregistrement n'est possible que si le nom est entré en pleine largeur' do
        user = build(:user, first_name: "Aio") #Entrez intentionnellement demi-largeur et générez une erreur
        user.valid?
        expect(user.errors[:first_name]).to include("Est une valeur non valide")
      end

      #Test d'entrée pleine largeur Katakana ▼

      it 'family_name_Seul le Katakana pleine largeur peut être enregistré pour le kana' do
        user = build(:user, family_name_kana: "AIUEO") #Entrez intentionnellement hiragana pour générer une erreur
        user.valid?
        expect(user.errors[:family_name_kana]).to include("Est une valeur non valide")
      end
      
      it 'first_name_Seul le Katakana pleine largeur peut être enregistré pour le kana' do
        user = build(:user, first_name_kana: "AIUEO") #Entrez intentionnellement hiragana pour générer une erreur
        user.valid?
        expect(user.errors[:first_name_kana]).to include("Est une valeur non valide")
      end
  end
end

Ceci complète le test fonctionnel selon les spécifications. Le résultat final est le suivant.

user.spec.rb


require 'rails_helper'

describe User do
  describe '#create' do

      #Test une fois entré ▼

      it "L'enregistrement est possible si tous les éléments sont saisis" do
        user = build(:user)
        expect(user).to be_valid
      end

      # nul:false, presence:Test vrai ▼

      it "Impossible de s'inscrire sans pseudo" do
        user = build(:user, nickname: nil)
        user.valid?
        expect(user.errors[:nickname]).to include("Entrez s'il vous plait")
      end

      it "Impossible de s'inscrire sans e-mail" do
        user = build(:user, email: nil)
        user.valid?
        expect(user.errors[:email]).to include("Entrez s'il vous plait")
      end

      it "Impossible de s'inscrire sans mot de passe" do
        user = build(:user, password: nil)
        user.valid?
        expect(user.errors[:password]).to include("Entrez s'il vous plait")
      end

      it "encrypted_Impossible de s'inscrire sans mot de passe" do
        user = build(:user, encrypted_password: nil)
        user.valid?
        expect(user.errors[:encrypted_password]).to include("Entrez s'il vous plait")
      end

      it "family_Impossible de s'inscrire sans nom" do
        user = build(:user, family_name: nil)
        user.valid?
        expect(user.errors[:family_name]).to include("Entrez s'il vous plait")
      end

      it "family_name_Impossible de s'inscrire sans kana" do
        user = build(:user, family_name_kana: nil)
        user.valid?
        expect(user.errors[:family_name_kana]).to include("Entrez s'il vous plait")
      end

      it "first_Impossible de s'inscrire sans nom" do
        user = build(:user, first_name: nil)
        user.valid?
        expect(user.errors[:first_name]).to include("Entrez s'il vous plait")
      end

      it "first_name_Impossible de s'inscrire sans kana" do
        user = build(:user, first_name_kana: nil)
        user.valid?
        expect(user.errors[:first_name_kana]).to include("Entrez s'il vous plait")
      end

      it "birth_Impossible de s'inscrire s'il n'y a pas de jour" do
        user = build(:user, birth_day: nil)
        user.valid?
        expect(user.errors[:birth_day]).to include("Entrez s'il vous plait")
      end
      
      #Test du nombre de caractères du mot de passe ▼

      it "Vous pouvez vous inscrire si le mot de passe contient 7 caractères ou plus" do
        user = build(:user, password: "1234567", encrypted_password: "1234567")
        expect(user).to be_valid
      end
      
      it "Impossible d'enregistrer si le mot de passe est de 7 caractères ou moins" do
        user = build(:user, password: "123456", encrypted_password: "123456")
        user.valid?
        expect(user.errors[:encrypted_password]).to include("Veuillez saisir au moins 7 caractères")
      end

      #e-mail test de contrainte d'unicité ▼

      it "Impossible de s'inscrire s'il y a des e-mails en double" do
        user = create(:user)
        another_user = build(:user, email: user.email)
        another_user.valid?
        expect(another_user.errors[:email]).to include("Existe déjà")
      end

      #Test nécessitant une confirmation du mot de passe ▼
      
      it "crypté même si le mot de passe existe_Impossible de s'inscrire sans mot de passe" do
        user = build(:user, encrypted_password: "")
        user.valid?
        expect(user.errors[:encrypted_password]).to include("Entrez s'il vous plait", "Veuillez saisir au moins 7 caractères")
      end

      #Test d'entrée pleine largeur du nom de vérification d'identité ▼

      it 'family_L'enregistrement n'est possible que si le nom est entré en pleine largeur' do
        user = build(:user, family_name: "Aio")
        user.valid?
        expect(user.errors[:family_name]).to include("Est une valeur non valide")
      end

      it 'first_L'enregistrement n'est possible que si le nom est entré en pleine largeur' do
        user = build(:user, first_name: "Aio")
        user.valid?
        expect(user.errors[:first_name]).to include("Est une valeur non valide")
      end

      #Vérification d'identité Test d'entrée pleine largeur Katakana ▼

      it 'family_name_Seul le Katakana pleine largeur peut être enregistré pour le kana' do
        user = build(:user, family_name_kana: "AIUEO")
        user.valid?
        expect(user.errors[:family_name_kana]).to include("Est une valeur non valide")
      end
      
      it 'first_name_Seul le Katakana pleine largeur peut être enregistré pour le kana' do
        user = build(:user, first_name_kana: "AIUEO")
        user.valid?
        expect(user.errors[:first_name_kana]).to include("Est une valeur non valide")
      end
  end
end

Exécution du code de test

Exécutez la commande suivante dans le terminal du répertoire de l'application qui décrit le test.

Terminal.


$ bundle exec rspec         

Ensuite, si le traitement est effectué comme indiqué dans l'image ci-dessous, le test est réussi. image.png

finalement

Dans le test unitaire du modèle, si vous pouvez comprendre la grammaire de base, le processus qui provoque une erreur et le processus qui ne se produit pas, et comprendre chaque méthode, vous pouvez écrire du code même si une nouvelle fonction est ajoutée.

Si vous avez des inquiétudes, faites-le nous savoir dans les commentaires! Merci d'avoir regardé jusqu'au bout!

Recommended Posts

[Rails] Comment implémenter un test unitaire d'un modèle
[Rails] Comment mettre en œuvre le scraping
[Rails] Comment mettre en œuvre le classement par étoiles
Comment implémenter la fonctionnalité de recherche dans Rails
Comment implémenter la fonctionnalité de classement dans Rails
Pour implémenter la publication d'images à l'aide de rails
Comment écrire des rails
[Pour les débutants] Comment implémenter la fonction de suppression
Comment désinstaller Rails
Comment implémenter une fonctionnalité similaire dans Rails
Comment implémenter la pagination dans GraphQL (pour ruby)
Comment implémenter une fonctionnalité intéressante dans Ajax avec Rails
Comment écrire un test unitaire pour Spring Boot 2
[Rails, JS] Comment implémenter l'affichage asynchrone des commentaires
Comment faire un test unitaire Java (JUnit & Mockito & PowerMock)
(Ruby on Rails6) Comment créer un modèle et une table
[rails] Comment publier des images
[Rails] Comment utiliser enum
[Rails] Comment utiliser enum
Comment lire les itinéraires des rails
Comment utiliser la jonction de rails
Comment terminer le serveur de rails
Comment écrire des graines de Rails
[Rails] Comment utiliser la validation
[Rails] Comment désactiver les turbolinks
[Rails] Comment utiliser authenticate_user!
[Rails] Comment faire des graines
Comment écrire le routage Rails
[Rails] Comment installer simple_calendar
[Java] Comment implémenter le multithreading
[Rails] Comment installer reCAPTCHA
[Rails] Comment utiliser Scope
[Ruby on Rails] Comment implémenter la fonction de balisage / recherche incrémentielle pour les articles (sans gemme)
[Rails] Comment utiliser la "devise" des gemmes
Comment faire un test unitaire de Spring AOP
[Rails] Comment utiliser l'appareil (Remarque)
[Rails] Comment utiliser les messages flash
[rails] Comment afficher les informations de base de données
Comment spécifier la validation pour time_field
Comment installer JMeter pour Mac
[Rails] Comment empêcher la transition d'écran
Comment utiliser Ruby on Rails
Comment déployer Bootstrap sur Rails
[Rails] Comment accélérer la composition de docker
[Rails] Comment ajouter de nouvelles pages
[Rails] Comment écrire la gestion des exceptions?
[Rails] Comment installer ImageMagick (RMajick)