[RUBY] RSpec-Résultats de la révision du code de test pour la «validation des utilisateurs»

introduction

Bonjour à tous! Message de Qiita, rubis, rails, rspec débutant J! L'autre jour, je m'inquiétais de "Et mes spécifications d'un point de vue professionnel?" J'ai posté RSpec-Testing'users validation ' comme question. Et la vidéo sur ruby et rspec est diffusée sur youtube, J'ai demandé à mon professeur @jnchito de réviser le code! Le code de test était assez long, mais je leur ai demandé de bien les signaler. Il a poliment expliqué "J'écrirais ceci!" Merci à toi,

Je me suis perdu en me demandant "quel est le code de test qui suit les règles?" Je ne peux pas m'engager facilement et je me promène en enfer.

J'ai l'impression d'être au paradis maintenant! Merci beaucoup pour votre avis. .. Pleurs

À propos de @jnchito

C'est célèbre, donc vous le savez peut-être, mais ...

• Introduction à Ruby pour ceux qui veulent devenir un professionnel J'ai publié un livre sur le rubis,
• Everyday Rails-Introduction to Rails Testing with RSpec Traduction japonaise de livres sur rspec,
• Essayez d'extraire uniquement le compte Twitter dans le texte avec des expressions régulières Il y avait aussi des vidéos qui ont été distribuées sur youtube et ont organisé des sessions d'étude!
• (1/2) J'ai examiné le code de test RSpec publié sur Qiita Cliquez ici pour la vidéo examinée cette fois!

Un professeur dandy vraiment cool! !!

Donc, cet article est aussi une sortie pour moi de devenir un specker, Être une référence pour les boursiers qui ont toujours les mêmes compétences que moi D'après ce qui a été signalé et expliqué, j'ai regardé mon propre code et j'ai essayé de corriger les mauvais points! Veuillez vous y référer si vous le souhaitez!

Mon code poubelle avant correction

Si vous mettez les codes de test avant et après avec le code précédent, la base de données Qiita peut être perforée. ← (・ ・.) Donc, si vous voulez comparer Mon code poubelle avant modification, veuillez dupliquer l'onglet!

Image imbriquée de Spec

«N'est-ce pas normal que le nid ne soit pas trop profond?

RSpec.describe User, type: :model do
  describe 'attribute: name'
    context 'when present'
      it 'is valid'
        # ...réduction
      end
    end
  end
end

Le contenu ci-dessus est, ʻUser> name> when present> it is valid` Cela semble étrange dans la traduction anglaise, mais chaque nid est ... Re-imbriqué pour le rendre plus facile à comprendre avec la nuance de "valide si le nom d'utilisateur existe". Ceci est juste une image!

modifié

Modèle utilisateur

app/models/user.rb

class User < ApplicationRecord
  before_save :downcase_email

  validates :name,
            presence: true,
            length: { maximum: 50 }
  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
  validates :email,
            presence: true,
            length: { maximum: 255 },
            format: { with: VALID_EMAIL_REGEX },
            uniqueness: { case_sensitive: false }

  private

    def downcase_email
      self.email = self.email.downcase
    end
end

Supplément

• VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
  Depuis railstutorial "Ne correspond pas à deux points consécutifs" Correction de cette expression régulière. --self.email.downcase! Et les méthodes destructives sont rarement utilisées. Il est plus sûr de ne pas utiliser de méthodes destructrices car on ne sait pas quand et où elles seront référencées à l'avenir. ,,,Certainement. (Donc, cela a été corrigé ci-dessous.)

def downcase_email
  self.email = self.email.downcase
end

FactoryBot

spec/factories/users.rb

FactoryBot.define do
  factory :user do
    name { 'Tony Stark' }
    email { '[email protected]' }
  end
end

Supplément

--Avant modification: nom {'hoge'}, ʻemail {"[email protected]"} La partie domaine de l'adresse e-mail que je pensais impossible. .. Oh ça? [bar.com](https://www.bar.com/) Cliquez! Je jure d'utiliser ,,,@ example.com`.

Spec

spec/models/user_spec.rb

require 'rails_helper'

RSpec.describe User, type: :model do
  let(:user) { FactoryBot.build(:user) }

  describe 'attribute: name' do
    context 'when present' do
      #Si le nom existe, il doit être valide
      it 'is valid' do
        user.name = 'Tony Stark'
        expect(user).to be_valid
      end
    end

    context 'when blank' do
      #Si le nom est vide, il n'est pas valide
      it 'is invalid' do
        user.name = ' '
        expect(user).to be_invalid
        expect(user.errors[:name]).to include("can't be blank")
      end
    end

    context 'when empty' do
      #Si le nom est vide, il n'est pas valide
      it 'is invalid' do
        user.name = ''
        expect(user).to be_invalid
        expect(user.errors[:name]).to include("can't be blank")
      end
    end

    context 'when nil' do
      #Invalide si le nom n'existe pas
      it 'is invalid' do
        user.name = nil
        expect(user).to be_invalid
        expect(user.errors[:name]).to include("can't be blank")
      end
    end

    context 'when length is 50 characters or less' do
      #Doit être valide si le nom comporte 50 caractères ou moins
      it 'is valid' do
        user.name = 'a' * 50
        expect(user).to be_valid
      end
    end

    context 'when length is more than 50 characters' do
      #Non valide si le nom dépasse 50 caractères
      it 'is invalid' do
        user.name = 'a' * 51
        expect(user).to be_invalid
        expect(user.errors[:name]).to include('is too long (maximum is 50 characters)')
      end
    end
  end

  describe 'attribute: email' do
    context 'when present' do
      #Si l'e-mail existe, il doit être valide
      it 'is invalid' do
        user.email = '[email protected]'
        expect(user).to be_valid
      end
    end

    context 'when blank' do
      #Si l'e-mail est vide, il n'est pas valide
      it 'is invalid' do
        user.email = ' '
        expect(user).to be_invalid
        expect(user.errors[:email]).to include("can't be blank")
      end
    end

    context 'when empty' do
      #Non valide si l'e-mail est vide
      it 'is invalid' do
        user.email = ''
        expect(user).to be_invalid
        expect(user.errors[:email]).to include("can't be blank")
      end
    end

    context 'when nil' do
      #Non valide si l'e-mail n'existe pas
      it 'is invalid' do
        user.email = nil
        expect(user).to be_invalid
        expect(user.errors[:email]).to include("can't be blank")
      end
    end

    context 'when length is 50 characters or less' do
      #Valide si l'e-mail contient 255 caractères ou moins
      it 'is valid' do
        user.email = 'a' * 243 + '@example.com'
        expect(user).to be_valid
      end
    end

    context 'when length is more than 50 characters' do
      #Non valide si l'e-mail dépasse 255 caractères
      it 'is invalid' do
        user.email = 'a' * 244 + '@example.com'
        expect(user).to be_invalid
        expect(user.errors[:email]).to include('is too long (maximum is 255 characters)')
      end
    end

    context 'when correct format' do
      #Si le format de l'e-mail est correct, il est valide
      it 'is valid' do
        user.email = '[email protected]'
        expect(user).to be_valid

        user.email = '[email protected]'
        expect(user).to be_valid

        user.email = '[email protected]'
        expect(user).to be_valid

        user.email = '[email protected]'
        expect(user).to be_valid

        user.email = '[email protected]'
        expect(user).to be_valid
      end
    end

    context 'when is incorrect format' do
      #Non valide si le format de l'e-mail est incorrect
      it 'is invalid' do
        user.email = 'user@example,com'
        expect(user).to be_invalid

        user.email = 'user_at_foo.org'
        expect(user).to be_invalid

        user.email = 'user.name@example.'
        expect(user).to be_invalid

        user.email = 'foo@bar_baz.com'
        expect(user).to be_invalid

        user.email = 'foo@bar+baz.com'
        expect(user).to be_invalid
      end
    end

    context 'when already taken' do
      #Si le même email est déjà enregistré, il doit être invalide
      it 'is invalid' do
        FactoryBot.create(:user, email: '[email protected]')
        user.email = '[email protected]'
        expect(user).to be_invalid
        expect(user.errors[:email]).to include('has already been taken')
      end
    end

    context 'when case insensitive and not unipue' do
      #L'e-mail est insensible à la casse et invalide s'il n'est pas unique
      it 'is invalid' do
        FactoryBot.create(:user, email: '[email protected]')
        user.email = '[email protected]'
        expect(user).to be_invalid
        expect(user.errors[:email]).to include('has already been taken')
      end
    end

    #L'e-mail est enregistré en minuscules
    it 'is saved in lowercase' do
      user.email = '[email protected]'
      user.save!
      expect(user.reload.email).to eq '[email protected]'
    end
  end
end

Supplément

• Enseignant: Supprimez les codes de débogage inutiles. Moi: Ah oui! Mais lors des tests, pry est utile!
• Enseignant: Il n'est pas bon d'aller voir les utilisateurs de FactoryBot. Moi: Même si vous définissez un utilisateur avec FactoryBot, mettez définitivement une valeur dans le nom avant d'écrire l'exspection! --I: Correction du texte de «context» et «it»! --context: groupe 'quand ~' quand ~ --it: Valider un modèle valide Valider un modèle invalide L'image est la nuance du contexte de la partie de l'image imbriquée. ―― Enseignant: Je me demande si vous n'avez pas besoin de vérifier l'enregistrement. .. Il est rare que la validation passe et enregistre, et s'il y a un bug de rails ou quelque chose du genre. Moi: je vois! (Supprimé ou moins.) Extrait du code non modifié: ʻexpect (user.save) .to be_falsey`
• Enseignant: Résumons le test ici. "Invalide si le nom n'existe pas" -- name = '' '(espace uniquement) --name = '' (vide)
• name = nil（nil）

    context 'when name is blank' do
      #Si le nom n'existe pas, il est invalide
      it 'is invalid' do
        user.name = ' '
        expect(user).to be_invalid
        expect(user.errors[:name]).to include("can't be blank")

        user.name = ''
        expect(user).to be_invalid
        expect(user.errors[:name]).to include("can't be blank")

        user.name = nil
        expect(user).to be_invalid
        expect(user.errors[:name]).to include("can't be blank")
      end
    end

Moi: Je voulais écrire ceci sans le mettre ensemble, donc je l'ai divisé en «vide», «vide» et «nul»!

--I: Je pensais que les messages ne seraient pas inclus dans le message d'erreur à moins que je ne demande ʻuser.valid? , Donc, écrivez simplement ʻexpect sans demander ʻuser.valid? `! ―― Enseignant: test d'expression régulière, c'est bien! Moi: Azasu!

• Enseignant: Jetez-le à sec et rangez-le dans une variable et ne faites pas ceci ou cela! Si vous construisez une logique, une erreur se produira dans cette logique et un accident inattendu se produira. .. ..
• Enseignant: ʻunicité: {case_sensitive: false} `Dois-je le tester? Moi: (2/2) J'ai examiné le code de test RSpec publié sur Qiita Comme vous pouvez le voir ...
• Enregistrez les utilisateurs valides avec des adresses e-mail inférieures.
• Saisissez à nouveau l'adresse e-mail en majuscules de l'utilisateur enregistrée ci-dessus dans l'e-mail de l'utilisateur --user n'est pas valide.
• De plus, le message d'erreur contient «a déjà été pris». Est le code ci-dessous.

context 'when case insensitive and not unipue' do
  #L'e-mail est insensible à la casse et invalide s'il n'est pas unique
  it 'is invalid' do
    FactoryBot.create(:user, email: '[email protected]')
    user.email = '[email protected]'
    expect(user).to be_invalid
    expect(user.errors[:email]).to include('has already been taken')
  end
end

Résumé

J'ai beaucoup plus de points, mais je n'ai pas encore atteint le niveau professionnel, donc Je vais revoir la vidéo que vous avez revue et expliquée et décrire la partie que j'ai comprise plus clairement! Pour ceux qui commencent à écrire des tests, il semble qu'il y ait beaucoup de camarades qui ne savent pas combien il faut "tester" comme moi. Je pense qu'ils ont des opinions différentes, mais c'est parfait pour les débutants!

«Croyez en la validation des rails et testez votre propre logique et celle des autres! '

C'est vrai! Je pensais que c'était un gaspillage de se donner la peine de tester la vérification des rails ... De plus, comme l'a dit l'enseignant, il y a des choses que vous ne pouvez pas dire quand vous le dites. Je pense que la capacité de réduire les points de test est plus importante. Je pense que le test pour cette validation a un code de test presque 100% correct, donc Ce sera une pratique future de tester la logique que vous et les membres de votre équipe avez créée!

Alors tout le monde!

Jeter à sec pour tester sauf si vous en avez besoin!

Tout le monde peut lire le code facilement et être heureux Plus que tout,, Cela n'a pas de sens si TEST est faux, w

à plus!

Sortie de test

User
  attribute: name
    when present
      is valid
    when blank
      is invalid
    when empty
      is invalid
    when nil
      is invalid
    when length is 50 characters or less
      is valid
    when length is more than 50 characters
      is invalid
  attribute: email
    is saved in lowercase
    when present
      is invalid
    when blank
      is invalid
    when empty
      is invalid
    when nil
      is invalid
    when length is 50 characters or less
      is valid
    when length is more than 50 characters
      is invalid
    when correct format
      is valid
    when is incorrect format
      is invalid
    when already taken
      is invalid
    when case insensitive and not unipue
      is invalid