Comment créer des associations has_and_belongs_to_many dans Factory Girl

Compte tenu de ce qui suit

class User < ActiveRecord::Base
  has_and_belongs_to_many :companies
end

class Company < ActiveRecord::Base
  has_and_belongs_to_many :users
end

comment définissez-vous les usines pour les entreprises et les utilisateurs, y compris l'association bidirectionnelle? Voici ma tentative

Factory.define :company do |f|
  f.users{ |users| [users.association :company]}
end

Factory.define :user do |f|
  f.companies{ |companies| [companies.association :user]}
end

maintenant j'essaye

Factory :user

Sans surprise, cela se traduit peut-être par une boucle infinie, car les usines s'utilisent réciproquement pour se définir.

Plus surprenant, je n'ai trouvé aucune mention de la façon de faire cela nulle part, y a-t-il un modèle pour définir les usines nécessaires ou je fais quelque chose de fondamentalement mal?

Voici la solution qui fonctionne pour moi.

FactoryGirl.define do

  factory :company do
    #company attributes
  end

  factory :user do
   companies {[FactoryGirl.create(:company)]}
   #user attributes
  end

end

si vous avez besoin d'une entreprise spécifique, vous pouvez utiliser l'usine de cette façon

company = FactoryGirl.create(:company, #{company attributes})
user = FactoryGirl.create(:user, :companies => [company])

J'espère que cela sera utile pour quelqu'un.

Factorygirl a depuis été mis à jour et inclut désormais des rappels pour résoudre ce problème. Jetez un œil à http://robots.thoughtbot.com/post/254496652/aint-no-calla-back-girl pour plus d'informations.

À mon avis, il suffit de créer deux usines différentes comme:

 Factory.define: utilisateur,: class => Utilisateur do | u |
  # Initialisation des attributs normaux
 fin

 Factory.define: société,: class => Société do | u |
  # Initialisation des attributs normaux
 fin

Lorsque vous écrivez les cas de test pour l'utilisateur, écrivez simplement comme ceci

 Usine (: utilisateur,: entreprises => [Usine (: entreprise)])

J'espère que cela fonctionnera.

Je n'ai pas pu trouver d'exemple pour le cas mentionné ci-dessus sur le site Web fourni. (Seulement 1: N et associations polymorphes, mais pas d'habtm). J'ai eu un cas similaire et mon code ressemble à ceci:

Factory.define :user do |user|
 user.name "Foo Bar"
 user.after_create { |u| Factory(:company, :users => [u]) }
end

Factory.define :company do |c|
 c.name "Acme"
end

Ce qui a fonctionné pour moi, c'est la création de l'association lors de l'utilisation de l'usine. En utilisant votre exemple:

user = Factory(:user)
company = Factory(:company)

company.users << user 
company.save! 

Trouvé de cette façon agréable et verbeux:

FactoryGirl.define do
  factory :foo do
    name "Foo" 
  end

  factory :bar do
    name "Bar"
    foos { |a| [a.association(:foo)] }
  end
end

  factory :company_with_users, parent: :company do

    ignore do
      users_count 20
    end

    after_create do |company, evaluator|
      FactoryGirl.create_list(:user, evaluator.users_count, users: [user])
    end

  end

Avertissement: Remplacez les utilisateurs: [utilisateur] par: utilisateurs => [utilisateur] pour ruby ​​1.8.x

Tout d'abord, je vous encourage fortement à utiliser has_many: through au lieu de habtm (plus à ce sujet ici ), vous vous retrouverez donc avec quelque chose comme:

Employment belongs_to :users
Employment belongs_to :companies

User has_many :employments
User has_many :companies, :through => :employments 

Company has_many :employments
Company has_many :users, :through => :employments

Après cela, vous aurez une association has_many des deux côtés et pourrez leur attribuer dans factory_girl comme vous l'avez fait.

Mise à jour pour Rails 5:

Au lieu d'utiliser l' has_and_belongs_to_manyassociation, vous devriez considérer: has_many :throughassociation.

La fabrique d'utilisateurs pour cette association ressemble à ceci:

FactoryBot.define do
  factory :user do
    # user attributes

    factory :user_with_companies do
      transient do
        companies_count 10 # default number
      end

      after(:create) do |user, evaluator|
         create_list(:companies, evaluator.companies_count, user: user)
      end
    end
  end
end

Vous pouvez créer l'usine d'entreprise de la même manière.

Une fois les deux usines définies, vous pouvez créer une user_with_companiesusine avec companies_count option. Ici, vous pouvez spécifier le nombre d'entreprises auxquelles appartient l'utilisateur:create(:user_with_companies, companies_count: 15)

Vous pouvez trouver des explications détaillées sur les associations de filles d'usine ici .

Pour HABTM, j'ai utilisé des traits et des rappels .

Supposons que vous ayez les modèles suivants:

class Catalog < ApplicationRecord
  has_and_belongs_to_many :courses
  …
end
class Course < ApplicationRecord
  …
end

Vous pouvez définir l'usine ci - dessus :

FactoryBot.define do
  factory :catalog do
    description "Catalog description"
    …

    trait :with_courses do
      after :create do |catalog|
        courses = FactoryBot.create_list :course, 2

        catalog.courses << courses
        catalog.save
      end
    end
  end
end

Vous pouvez définir une nouvelle fabrique et utiliser après le rappel (: create) pour créer une liste d'associations. Voyons comment le faire dans cet exemple:

FactoryBot.define do

  # user factory without associated companies
  factory :user do
    # user attributes

    factory :user_with_companies do
      transient do
        companies_count 10
      end

      after(:create) do |user, evaluator|
        create_list(:companies, evaluator.companies_count, user: user)
      end
    end
  end
end

L'attribut companies_count est un transitoire et disponible dans les attributs de la fabrique et dans le callback via l'évaluateur. Désormais, vous pouvez créer un utilisateur avec des entreprises avec la possibilité de spécifier le nombre d'entreprises que vous souhaitez:

create(:user_with_companies).companies.length # 10
create(:user_with_companies, companies_count: 15).companies.length # 15