[RUBY] RSpec-Testing 'Benutzervalidierung'

Ergebnisse der Überprüfung des Testcodes von RSpec - 'Benutzervalidierung'

Bewertung von @jnchito! Wenn Sie möchten, folgen Sie bitte dem Link oben!

Hintergrund

Freut mich, dich kennenzulernen. Ich bin neu in Qiita Posts, Rails und Rspec. Bitte sei nett zu mir. Während meines Studiums bei railstutorial schreibe ich die "Modellspezifikation" von "app / models / user.rb". Ich wollte es zu einem coolen und schönen Testcode machen, also las ich Artikel darüber, wie man rspec für verschiedene Leute schreibt. Ich schrieb die Spezifikation, während ich meinen eigenen Weg entwarf, und während ich mir diese Art des Schreibens überlegte: "Ist es nicht ziemlich cool?" Wenn ich auf meinen Code zurückblicke, während ich mich auf den Artikel beziehe, fühle ich etwas Feines. Ich habe mich verlaufen und gefragt: "Was ist der Testcode, der den Regeln folgt?" Ich kann mich nicht leicht festlegen und wandere in der Hölle herum. Wenn Sie möchten, würde ich mich freuen, wenn Sie den Testcode überprüfen und darauf hinweisen könnten.

Referenz

Für den Testcode habe ich hauptsächlich auf Folgendes von jnchito verwiesen.

• Youtube-Video -Die erste Hälfte von dailyrailsrspec
• Einführung in RSpec, das verwendet werden kann, Teil 2 "Beherrschen häufig verwendeter Matcher"

Lassen Sie mich das Obige sehen, und es wird der Code sein, den ich auf meine eigene Weise geschrieben habe. Ich habe mich nicht auf Folgendes bezogen, aber der Artikel, den ich gesehen habe, und mein Code schienen Müll zu sein.

• Grundregel für das ordentliche Schreiben von RSpec

Verschachteltes Bild

--describe: Wenn "# create (action)" von "User (model)", ist "attribute: name" --context: name sollte vorhanden sein Der Name sollte existieren. --it: Überprüfen Sie das Muster "gültig" oder "ungültig".

In der Testerstellung wird das Bild der Verschachtelung (?) model > action > attribute > validates: presence:true > valid or invalid Ich habe die Spezifikation unter Berücksichtigung der Gruppierung geschrieben. (Als weiteres Bild scheint das Ausführungsergebnis von "$ bundle exec rspec" am Ende des Artikels wunderschön auszusehen.)

Warum kommst du nicht aus der Hölle raus?

• Korrekte Verwendung von "beschreiben", "Kontext" und "es". Ich wollte es in Anbetracht des Falls, in dem andere Leute es lesen, leicht verständlich schreiben. Siehe Grundregel für das schöne Schreiben von RSpec "Das ist nicht gut." (Gibt es überhaupt eine Regel? Das kann ein Problem sein, da ich mir bewusst bin, dass ich einige Regeln selbst erstellen und erstellen werde.)
• Mein Testcode aus professioneller Sicht Der Testcode, den ich geschrieben habe, ist grün und ich denke, es ist okay Ich möchte wissen "Ich werde das tun!" ――Ist es nicht erforderlich, in jedem Testfall "Was kann gespeichert werden oder was kann nicht gespeichert werden" durchzuführen? Grundsätzlich als "user.valid?", Um sicherzustellen, dass der Zieltest fehlgeschlagen ist Ich überprüfe den Inhalt des Fehlers (error [: name]) wie include (" kann nicht leer sein "), Danach, als user.save!, (! Ich denke, dass dies eine Ausnahme ist, aber ...) Ich frage mich, ob ich Folgendes überprüfen soll:
• Der Fall "gültig" kann gespeichert werden
• Der Fall "ungültig" kann nicht gespeichert werden

Unten finden Sie einen Auszug aus dem Code, der bestätigt, "was gespeichert werden kann oder nicht".

#Ungültig, wenn der Name nicht existiert
it 'is invalid because the name value does not exists' do
  user.name = nil
  user.valid?
  expect(user.errors[:name]).to include("can't be blank")

  expect(user.save).to be_falsey # ...Stellen Sie sicher, dass diese eine Zeile nicht gespeichert werden kann

end

Testcode

Der Inhalt des Tests ist die Validierung der allgemeinen "users.name", "user.email". railstutorial Es wird hier.

Na dann sofort, aber ...

Das Folgende ist die aktuelle Validierung.

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]+\z/i
  validates :email,
            presence: true,
            length: { maximum: 255 },
            format: { with: VALID_EMAIL_REGEX },
            uniqueness: { case_sensitive: false }

  private

    def downcase_email
      self.email.downcase!
    end
end

Das Folgende ist der in "FactoryBot" definierte "Benutzer".

spec/factories/users.rb

FactoryBot.define do
  factory :user do
    name { "hoge" }
    email { "[email protected]" }
  end
end

Unten ist der tatsächliche Testcode.

spec/models/user_spec.rb

require 'rails_helper'
require 'pry'

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

  describe '#create' do
    describe 'attribute: name' do
      context 'name should be present' do
        #Wenn der Name existiert, muss er gültig sein
        it 'is valid because the name has the correct value' do
          expect(user).to be_valid
          expect(user.save).to be_truthy
        end
        #Ungültig, wenn der Name nicht existiert
        it 'is invalid because the name value does not exists' do
          user.name = nil
          user.valid?
          expect(user.errors[:name]).to include("can't be blank")
          expect(user.save).to be_falsey
        end
      end

      context 'name should be length is 50 characters or less' do
        #Muss gültig sein, wenn der Name 50 Zeichen oder weniger enthält
        it 'is valid because the name length is 50 characters or less' do
          user.name = 'a' * 50
          user.valid?
          expect(user.errors[:name]).not_to include('is too long (maximum is 50 characters)')
          expect(user.save).to be_truthy
        end
        #Ungültig, wenn der Name mehr als 50 Zeichen enthält
        it 'is invalid because the name length is 50 characters over' do
          user.name = 'a' * 51
          user.valid?
          expect(user.errors[:name]).to include('is too long (maximum is 50 characters)')
          expect(user.save).to be_falsey
        end
      end

      context 'name should be not blank' do
        #Wenn der Name leer ist, ist er ungültig
        it 'is invalid because the name is blank' do
          user.name = ' '
          user.valid?
          expect(user.errors[:name]).to include("can't be blank")
          expect(user.save).to be_falsey
        end
      end
    end

    context 'attribute: email' do
      context 'email should be present' do
        #Ungültig, wenn keine E-Mail vorhanden ist
        it 'is invalid because the email value does not exists' do
          user.email = nil
          user.valid?
          expect(user.errors[:email]).to include("can't be blank")
          expect(user.save).to be_falsey
        end
      end

      context 'email should be length is 50 characters or less' do
        #Gültig, wenn die E-Mail-Adresse maximal 255 Zeichen beträgt
        it 'is valid because the email length is 255 characters or less' do
          user.email = 'a' * 243 + '@example.com'
          user.valid?
          expect(user.errors[:email]).not_to include('is too long (maximum is 255 characters)')
          expect(user.save).to be_truthy
        end
        #Ungültig, wenn E-Mail mehr als 255 Zeichen enthält
        it 'is invalid because the email length is 255 characters over' do
          user.email = 'a' * 244 + '@example.com'
          user.valid?
          expect(user.errors[:email]).to include('is too long (maximum is 255 characters)')
          expect(user.save).to be_falsey
        end
      end

      context 'email should be correct format' do
        #Wenn das E-Mail-Format korrekt ist, ist es gültig
        it 'is valid because the email is the correct format' do
          user.email = '[email protected]'
          expect(user).to be_valid
          expect(user.save).to be_truthy

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

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

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

          user.email = '[email protected]'
          expect(user).to be_valid
          expect(user.save).to be_truthy
        end
        #Ungültig, wenn das E-Mail-Format falsch ist
        it 'is invalid because the email format is incorrect' do
          user.email = 'user@example,com'
          expect(user).not_to be_valid
          expect(user.save).to be_falsey

          user.email = 'user_at_foo.org'
          expect(user).not_to be_valid
          expect(user.save).to be_falsey

          user.email = 'user.name@example.'
          expect(user).not_to be_valid
          expect(user.save).to be_falsey

          user.email = 'foo@bar_baz.com'
          expect(user).not_to be_valid
          expect(user.save).to be_falsey

          user.email = 'foo@bar+baz.com'
          expect(user).not_to be_valid
          expect(user.save).to be_falsey
        end
      end

      context 'email should be unique' do
        #Wenn dieselbe E-Mail bereits registriert ist, muss sie ungültig sein
        it 'is Invalid because the same email already exists' do
          dup_user = user.dup
          dup_user.email = dup_user.email.upcase
          dup_user.save!
          user.valid?
          expect(user.errors[:email]).to include('has already been taken')
          expect(user.save).to be_falsey
        end
      end

      #Die E-Mail wird in Kleinbuchstaben gespeichert
      context 'email should be saved in lowercase' do
        it 'is valid because the email saved in lowercase' do
          user.email = '[email protected]'
          user.save!
          expect(user.reload.email).to eq '[email protected]'
        end
      end

      context 'email should be not blank' do
        #Wenn die E-Mail leer ist, ist sie ungültig
        it 'is invalid because the email is blank' do
          user.email = ' '
          user.valid?
          expect(user.errors[:email]).to include("can't be blank")
          expect(user.save).to be_falsey
        end
      end
    end

  end
end

Im obigen Test ist die Ausgabe der Ausführung von "$ bundle exec rspec" (grün) wie folgt. Die korrekte Verwendung von "beschreiben", "Kontext" und "es" im Testcode scheint verschachtelt zu sein, damit die folgende Ausgabe leichter zu sehen ist.

User
  #create
    attribute: name
      name should be present
        is valid because the name has the correct value
        is invalid because the name value does not exists
      name should be length is 50 characters or less
        is valid because the name length is 50 characters or less
        is invalid because the name length is 50 characters over
      name should be not blank
        is invalid because the name is blank
    attribute: email
      email should be present
        is invalid because the email value does not exists
      email should be length is 50 characters or less
        is valid because the email length is 255 characters or less
        is invalid because the email length is 255 characters over
      email should be correct format
        is valid because the email is the correct format
        is invalid because the email format is incorrect
      email should be unique
        is Invalid because the same email already exists
      email should be saved in lowercase
        is valid because the email saved in lowercase
      email should be not blank
        is invalid because the email is blank

Danke für Ihre Kooperation.