Rails & RSpec - Test Concerne les méthodes de la classe

J'ai le texte suivant (simplifié) des Rails de Préoccupation:

module HasTerms
  extend ActiveSupport::Concern

  module ClassMethods
    def optional_agreement
      # Attributes
      #----------------------------------------------------------------------------
      attr_accessible :agrees_to_terms
    end

    def required_agreement
      # Attributes
      #----------------------------------------------------------------------------
      attr_accessible :agrees_to_terms

      # Validations
      #----------------------------------------------------------------------------
      validates :agrees_to_terms, :acceptance => true, :allow_nil => :false, :on => :create
    end
  end
end

Je ne peux pas trouver un bon moyen de tester ce module dans RSpec cependant - si je viens de créer un mannequin de classe, je reçois de l'enregistrement actif des erreurs lorsque j'essaye de vérifier que les validations sont de travail. Quelqu'un d'autre a été confronté à ce problème?

InformationsquelleAutor Bryce | 2013-05-09

39

Découvrez RSpec partagé des exemples.

De cette façon, vous pouvez écrire le code suivant:
```
# spec/support/has_terms_tests.rb
shared_examples "has terms" do
   # Your tests here
end


# spec/wherever/has_terms_spec.rb
module TestTemps
  class HasTermsDouble
    include ActiveModel::Validations
    include HasTerms
  end
end

describe HasTerms do

  context "when included in a class" do
    subject(:with_terms) { TestTemps::HasTermsDouble.new }

    it_behaves_like "has terms"
  end

end


# spec/model/contract_spec.rb
describe Contract do

  it_behaves_like "has terms"

end
```
- C'est clairement la meilleure réponse. On peut être explicite dans le cas fictif ET le test de la même API de la classe parent spécifications. Cela fait toute la différence lorsque l'on traite avec toute la "flexibilité" des Api (lire: method_missing). Il y a tout simplement certains cas, on ne peut pas penser jusqu'à ce qu'il est en cours d'utilisation dans une "vraie" (non fictif) de la classe, et le partage d'exemples vont faire un bon travail de l'exercice d'un code dans chaque contexte.
- Cela tombe à l'eau lorsque votre module ajoute des attributs dynamiques. Disons que votre module permet à la méthode de classe: allows_upload :csv, qui ajoute des méthodes comme csv_file_path et csv_file_size. Mais vous avez un autre modèle qui appelle le fichier téléchargé :attachment. Maintenant, votre "agit comme télécharger" spec est voué à l'échec parce que l'un est d'ajouter csv_file_path et on a attachment_file_path. Pour cette raison, je me sens comme dans beaucoup de cas, il va répondre à vos besoins préférable d'utiliser un mannequin de classe pour tester le module de comportement comme dans @Martijn 's réponse
- pour être clair, le module n'est pas l'ajout de la méthode, l'enfant de la classe est explicitement. Si partagé des exemples est approprié ici est un jugement d'appel spécifique à la base de code. Cependant, vous pouvez toujours les utiliser de cette manière. Il est possible de passer l'info à eux, comme vous le faites dans l'appel: it_behaves_like 'acts as upload', :csv
- Oh! Je ne savais pas, vous pouvez passer une valeur à elle. Vous pouvez aussi lui donner un bloc de donner l'partagée exemple un certain contexte. Quelque chose comme: it_behaves_like 'an upload', :csv do; subject{ Upload.new(file: some_dummy_file) }; end Merci pour l'astuce 😛
InformationsquelleAutor Aaron K
6

Vous pouviez juste de tester le module implicitement en laissant vos tests dans les classes qui comprennent ce module. Alternativement, vous pouvez inclure d'autres modules nécessaires dans votre classe factice. Par exemple, le validates méthodes dans l'AR modèles sont fournis par ActiveModel::Validations. Donc, pour vos tests:
```
class DummyClass
  include ActiveModel::Validations
  include HasTerms
end
```
Il y a peut être d'autres modules que vous devez apporter en fonction des dépendances vous implicitement comptez dans votre HasTerms module.
- Je suis d'accord qu'implicite de test est facile, mais je sens que j'ai besoin d'être en mesure de tester des choses explicitement en tant que bien. Cela est particulièrement pertinent quand il s'agit de l'écriture de fonctions de classe qu'aucun de mes classes sont en utilisant encore.
- Quelque chose comme la DummyClass est l'alternative que vous êtes à la recherche pour puis.
InformationsquelleAutor rossta
5

J'ai eu du mal avec moi-même et évoqué la solution suivante, qui est un peu comme rossta de l'idée, mais utilise une classe anonyme la place:
```
it 'validates terms' do
  dummy_class = Class.new do
    include ActiveModel::Validations
    include HasTerms

    attr_accessor :agrees_to_terms

    def self.model_name
      ActiveModel::Name.new(self, nil, "dummy")
    end
  end

  dummy = dummy_class.new
  dummy.should_not be_valid
end
```
- C'est la seule solution que j'ai trouvé de travail. Quand vous allez avec le nom factice de classe de vos spécifications techniques commencent à saigner les uns des autres si l'on appelle une méthode qui modifie la classe, alors la prochaine spec va voir que la classe de modification de trop. Bien que la mienne est plus comme let(:dummy_class){ Class.new (... ) } par opposition à l'insertion, à droite dans les it bloc.
InformationsquelleAutor Martijn

Voici un autre exemple (à l'aide de Factorygirl "créer" la méthode" et shared_examples_for)

préoccupation spec

#spec/support/concerns/commentable_spec
require 'spec_helper'
shared_examples_for 'commentable' do
  let (:model) { create ( described_class.to_s.underscore ) }
  let (:user) { create (:user) }

  it 'has comments' do
    expect { model.comments }.to_not raise_error
  end
  it 'comment method returns Comment object as association' do
    model.comment(user, "description")
    expect(model.comments.length).to eq(1)
  end
  it 'user can make multiple comments' do
    model.comment(user, "description")
    model.comment(user, "description")
    expect(model.comments.length).to eq(2)
  end
end

commentable préoccupation

module Commentable
  extend ActiveSupport::Concern
  included do
    has_many :comments, as: :commentable
  end

  def comment(user, description)
    Comment.create(commentable_id: self.id,
                  commentable_type: self.class.name,
                  user_id: user.id,
                  description: description
                  )
  end

end

et restraunt_spec peut ressembler à quelque chose comme ça (je ne suis pas Rspec guru donc ne pense pas que ma façon d'écrire des specs est bon, la chose la plus importante est au début):

require 'rails_helper'

RSpec.describe Restraunt, type: :model do
  it_behaves_like 'commentable'

  describe 'with valid data' do
    let (:restraunt) { create(:restraunt) }
    it 'has valid factory' do
      expect(restraunt).to be_valid
    end
    it 'has many comments' do
      expect { restraunt.comments }.to_not raise_error
    end
  end
  describe 'with invalid data' do
    it 'is invalid without a name' do
      restraunt = build(:restraunt, name: nil)
      restraunt.save
      expect(restraunt.errors[:name].length).to eq(1)
    end
    it 'is invalid without description' do
      restraunt = build(:restraunt, description: nil)
      restraunt.save
      expect(restraunt.errors[:description].length).to eq(1)
    end
    it 'is invalid without location' do
      restraunt = build(:restraunt, location: nil)
      restraunt.save
      expect(restraunt.errors[:location].length).to eq(1)
    end
    it 'does not allow duplicated name' do
      restraunt = create(:restraunt, name: 'test_name')
      restraunt2 = build(:restraunt, name: 'test_name')
      restraunt2.save
      expect(restraunt2.errors[:name].length).to eq(1)
    end
  end
end

InformationsquelleAutor Konrad Janczyk

Bâtiment sur Aaron K est une excellente réponse ici, il y a quelques astuces intéressantes que vous pouvez utiliser avec described_class que RSpec fournit à faire vos méthodes omniprésent et faire des usines de travailler pour vous. Voici un extrait d'un exemple, j'ai récemment fait une demande:

shared_examples 'token authenticatable' do
  describe '.find_by_authentication_token' do
    context 'valid token' do
      it 'finds correct user' do
        class_symbol = described_class.name.underscore
        item = create(class_symbol, :authentication_token)
        create(class_symbol, :authentication_token)

        item_found = described_class.find_by_authentication_token(
          item.authentication_token
        )

        expect(item_found).to eq item
      end
    end

    context 'nil token' do
      it 'returns nil' do
        class_symbol = described_class.name.underscore
        create(class_symbol)

        item_found = described_class.find_by_authentication_token(nil)

        expect(item_found).to be_nil
      end
    end
  end
end

InformationsquelleAutor Neal

Vous devez vous connecter pour publier un commentaire.