Comment dire “any_instance” “should_receive” un certain nombre de fois dans RSpec

J'ai une importation de contrôleur dans les rails que les importations de plusieurs fichiers csv avec plusieurs enregistrements dans ma base de données. Je voudrais tester dans RSpec si les enregistrements sont effectivement enregistrées à l'aide de RSpec:

<Model>.any_instance.should_receive(:save).at_least(:once)

Cependant, je reçois le message d'erreur disant:

The message 'save' was received by <model instance> but has already been received by <another model instance>

Un exemple artificiel du contrôleur:

rows = CSV.parse(uploaded_file.tempfile, col_sep: "|")

  ActiveRecord::Base.transaction do
    rows.each do |row| 
    mutation = Mutation.new
    row.each_with_index do |value, index| 
      Mutation.send("#{attribute_order[index]}=", value)
    end
  mutation.save          
end

Est-il possible de tester cette aide RSpec ou est-il une solution de contournement?

Quelle est la version de RSpec utilisez-vous et quel est le message d'erreur que vous voyez?
rspec (2.8.0) et le message est le suivant: Le message "enregistrer" a été reçu par <instance du modèle> mais il a déjà été reçu par <une autre instance du modèle>
C'est le comportement attendu. Le point de any_instance est pas de savoir quelle instance unique est à attendre quelque chose, mais c'est encore limite à une seule instance.
C'est le comportement attendu - acquis - mais il n'est pas très utile si vous souhaitez tester cette. Et il ne semble pas être une autre méthode, comme "many_instances" qui relaxe la contrainte d'une instance.

InformationsquelleAutor Harm de Wit | 2012-03-21

45

Il y a une nouvelle syntaxe pour que cela:
```
expect_any_instance_of(Model).to receive(:save).at_least(:once)
```
- Les concepteurs de rspec de décourager l'utilisation de expect_any_instance_of. Voici un lien vers la doc.
- ouais, je suis totalement d'accord. À partir de ce doc: "l'Utilisation de cette fonctionnalité est souvent une conception de l'odorat. Il se peut que votre test est d'essayer d'en faire trop, ou que l'objet soumis à l'essai est trop complexe."
- En fait, cela ne fonctionne pas pour moi; même erreur que question d'origine. à l'aide de RSpec 3.3.3.
- Alors cela ressemble à une pièce de théâtre de l'échec. Il y a deux cas qui reçoivent le message.
InformationsquelleAutor muirbot
45

Voici une meilleure réponse qui évite d'avoir à remplacer l' :nouvelle méthode:
```
save_count = 0
<Model>.any_instance.stub(:save) do |arg|
    # The evaluation context is the rspec group instance,
    # arg are the arguments to the function. I can't see a
    # way to get the actual <Model> instance :(
    save_count+=1
end
.... run the test here ...
save_count.should > 0
```
Semble que le talon de la méthode peut être attaché à n'importe quelle instance w/o la contrainte, et de le faire bloc peut faire un compte que vous pouvez vérifier pour affirmer qu'il a été appelé le bon nombre de fois.

Mise à jour - nouvelle rspec version requiert la syntaxe suivante:
```
save_count = 0
allow_any_instance_of(Model).to receive(:save) do |arg|
    # The evaluation context is the rspec group instance,
    # arg are the arguments to the function. I can't see a
    # way to get the actual <Model> instance :(
    save_count+=1
end
.... run the test here ...
save_count.should > 0
```
- Ah nice, en utilisant les talons sur any_instance! Semble plus agréable et plus dynamique que ma solution.
- Même si le vôtre est moins hacky, je n'aime pas les compteurs, par l'utilisation de proxy à une méthode de classe [ici][stackoverflow.com/a/15038406/619510] j'ai gardé la même syntaxe.
- Génial! Prendre +1 pour l'. 😀
InformationsquelleAutor Rob
15

J'ai enfin réussi à faire un test qui fonctionne pour moi:
```
  mutation = FactoryGirl.build(:mutation)
  Mutation.stub(:new).and_return(mutation)
  mutation.should_receive(:save).at_least(:once)
```
Le stub méthode retourne une instance unique qui reçoit la méthode enregistrer plusieurs fois. Parce que c'est une instance unique je peux laisser le any_instance méthode et l'utilisation de la at_least méthode normalement.
- yuk. dommage que vous ne pouvez pas dire "many_instances".
InformationsquelleAutor Harm de Wit
10

Stub comme ce
```
User.stub(:save) # Could be any class method in any class
User.any_instance.stub(:save) { |*args| User.save(*args) }
```
Puis attendre comme ceci:
```
# User.any_instance.should_receive(:save).at_least(:once)
User.should_receive(:save).at_least(:once)
```
C'est une simplification de ce gist, à utiliser any_instance, puisque vous n'avez pas besoin de proxy à la méthode d'origine. Reportez-vous à qui gist pour d'autres utilisations.
- Excellent. L'utilisation de proxy de la méthode à travers un exemple connu de grandes œuvres. Vous pouvez tout aussi facilement stub(:enregistrer) sur un test de la double à la place de l'Utilisateur de la classe.
- Fonctionne comme un charme! Merci! 🙂
- Utilisez simplement allow et allow_any_instance_of au lieu de stub et any_instance.stub puisque les anciens sont désormais obsolète (voir: github.com/rspec/...)
InformationsquelleAutor michelpm

C'est Rob exemple à l'aide de RSpec 3.3, qui ne prend plus en charge Foo.any_instance. J'ai trouvé ce utile lorsque dans une boucle de la création d'objets

# code (simplified version)
array_of_hashes.each { |hash| Model.new(hash).write! }

# spec
it "calls write! for each instance of Model" do 
  call_count = 0
  allow_any_instance_of(Model).to receive(:write!) { call_count += 1 }

  response.process # run the test
  expect(call_count).to eq(2)
end

InformationsquelleAutor sp89

2

Mon cas est un peu différent, mais je l'ai retrouvé à cette question pensé à abandonner ma réponse ici aussi. Dans mon cas, je voulais stub n'importe quelle instance d'une classe donnée. J'ai eu le même message d'erreur lorsque je l'ai utilisé expect_any_instance_of(Model).to. Quand je l'ai changé pour allow_any_instance_of(Model).to, mon problème a été résolu.

Consultez la documentation pour plus d'arrière-plan: https://github.com/rspec/rspec-mocks#settings-mocks-or-stubs-on-any-instance-of-a-class

InformationsquelleAutor Rick Pastoor
0

Vous pouvez essayer de compter le nombre de new sur la classe. Ce n'est pas fait de tests, le nombre de saves, mais peut être assez
```
    expect(Mutation).to receive(:new).at_least(:once)
```
Si il est le seul espoir de combien de fois il a été enregistré. Ensuite, vous voudrez probablement utiliser spy() au lieu de entièrement le fonctionnement de l'usine, comme dans Harm de Wit propre réponse
```
    allow(Mutation).to receive(:new).and_return(spy)
    ...
    expect(Mutation.new).to have_received(:save).at_least(:once)
```
InformationsquelleAutor Brazhnyk Yuriy

Vous devez vous connecter pour publier un commentaire.