À l'aide de factory_girl dans les Rails avec des associations qui ont des contraintes. Prise en double erreurs

J'ai rencontré le même problème et a ajouté une lambda au dessus de mes usines de fichier qui implémente le pattern singleton, qui régénère le modèle, si la db a été effacée depuis la dernière série de tests/specs:

saved_single_instances = {}
#Find or create the model instance
single_instances = lambda do |factory_key|
  begin
    saved_single_instances[factory_key].reload
  rescue NoMethodError, ActiveRecord::RecordNotFound  
    #was never created (is nil) or was cleared from db
    saved_single_instances[factory_key] = Factory.create(factory_key)  #recreate
  end

  return saved_single_instances[factory_key]
end

Puis, à l'aide de votre exemple usines, vous pouvez utiliser un factory_girl attribut lazy pour exécuter le lambda

Factory.define :product do |p|
  p.product_type  { single_instances[:add_product_type] }
  #...this block edited as per comment below
end

Voila!

La réponse est "non", Factory girl n'ont pas le moyen le plus propre de le faire. Il me semblait vérifier cela sur le Factory girl forums.

Cependant, j'ai trouvé une autre réponse pour moi. Il s'agit d'une autre sorte de solution de contournement, mais rend tout beaucoup plus propre.

L'idée est de changer les modèles qui représentent les tables de recherche à la création de la saisie en cas de disparition. C'est OK parce que le code s'attend à des entrées spécifiques pour exister. Voici un exemple de la modification du modèle.

class ProductType < ActiveRecord::Base
  has_many :products

  validates_presence_of :name, :code
  validates_uniqueness_of :name, :code

  # Constants defined for the class.
  CODE_FOR_SUBSCRIPTION = "sub"
  CODE_FOR_ADDITION = "add"

  # Get the ID for of the entry that represents a trial account status.
  def self.id_for_subscription
    type = ProductType.find(:first, :conditions => ["code = ?", CODE_FOR_SUBSCRIPTION])
    # if the type wasn't found, create it.
    if type.nil?
      type = ProductType.create!(:name => 'Subscription', :code => CODE_FOR_SUBSCRIPTION)
    end
    # Return the loaded or created ID
    type.id
  end

  # Get the ID for of the entry that represents a trial account status.
  def self.id_for_addition
    type = ProductType.find(:first, :conditions => ["code = ?", CODE_FOR_ADDITION])
    # if the type wasn't found, create it.
    if type.nil?
      type = ProductType.create!(:name => 'Additions', :code => CODE_FOR_ADDITION)
    end
    # Return the loaded or created ID
    type.id
  end
end

La méthode de classe statique de "id_for_addition" charge le modèle et le numéro d'identification si trouvé, si elle ne trouve pas, il va le créer.

L'inconvénient est le "id_for_addition" la méthode peut ne pas être clair quant à ce qu'il fait en son nom. Qui peut avoir besoin de changer. La seule autre code de l'impact de l'utilisation normale supplémentaire est un test pour voir si le modèle a été trouvé ou non.

Cela signifie que l'Usine de code pour créer le produit peut être changé comme ça...

Factory.define :added_users_product, :parent => :product do |p|
  #p.association :product_type, :factory => :add_product_type
  p.product_type_id { ProductType.id_for_addition }
end

Cela signifie que la modification de l'Usine de code peut ressembler à ceci...

Factory.define :cart_with_two_add_items, :parent => :cart do |o|
  o.after_build do |cart|
    cart.cart_items = [Factory(:cart_item_add_users, :cart => cart),
                       Factory(:cart_item_add_profiles, :cart => cart)]
  end
end

C'est exactement ce que je voulais. Je peux maintenant proprement exprimer mon usine et le code de test.

Un autre avantage de cette approche est la recherche des données de la table n'a pas besoin d'être semées ou peuplées dans les migrations. Il gère lui-même pour tester les bases de données ainsi que de la production.

EDIT:

Voir une meilleure solution au bas de cette réponse.

RÉPONSE ORIGINALE À CETTE QUESTION:

C'est ma solution pour la création de FactoryGirl singleton associations:

FactoryGirl.define do
  factory :platform do
    name 'Foo'
  end

  factory :platform_version do
    name 'Bar'
    platform {
      if Platform.find(:first).blank?
        FactoryGirl.create(:platform)
      else
        Platform.find(:first)
      end
    }
  end
end

Vous l'appelez comme par exemple:

And the following platform versions exists:
  | Name     |
  | Master   |
  | Slave    |
  | Replica  |

De cette façon, tous les 3 versions de plate-forme aura le même plate-forme 'Foo', c'est à dire singleton.

Si vous voulez enregistrer une base de données de requête vous pouvez faire au lieu de:

platform {
  search = Platform.find(:first)
  if search.blank?
    FactoryGirl.create(:platform)
  else
    search
  end
}

Et vous pouvez envisager de faire le singleton association d'un trait:

factory :platform_version do
  name 'Bar'
  platform

  trait :singleton do
    platform {
      search = Platform.find(:first)
      if search.blank?
        FactoryGirl.create(:platform)
      else
        search
      end
    }
  end

  factory :singleton_platform_version, :traits => [:singleton]
end

Si vous souhaitez configurer plus de 1 plate-forme, et ont différents ensembles de platform_versions, vous pouvez effectuer différents traits qui sont plus spécifiques, à savoir:

factory :platform_version do
  name 'Bar'
  platform

  trait :singleton do
    platform {
      search = Platform.find(:first)
      if search.blank?
        FactoryGirl.create(:platform)
      else
        search
      end
    }
  end

  trait :newfoo do
    platform {
      search = Platform.find_by_name('NewFoo')
      if search.blank?
        FactoryGirl.create(:platform, :name => 'NewFoo')
      else
        search
      end
    }
  end

  factory :singleton_platform_version, :traits => [:singleton]
  factory :newfoo_platform_version, :traits => [:newfoo]
end

Espère que ce sera utile à certains.

EDIT:

Après la présentation de mon solution originale au-dessus, j'ai donné le code d'un autre regard, et trouve encore le moyen le plus propre pour ce faire: Vous ne définissez pas de traits dans les usines, à la place, vous spécifiez l'association lorsque vous appelez l'étape de test.

De faire régulièrement des usines:

FactoryGirl.define do
  factory :platform do
    name 'Foo'
  end

  factory :platform_version do
    name 'Bar'
    platform
  end
end

Maintenant, vous appelez l'étape de test avec l'association spécifié:

And the following platform versions exists:
  | Name     | Platform     |
  | Master   | Name: NewFoo |
  | Slave    | Name: NewFoo |
  | Replica  | Name: NewFoo |

Lorsque vous faites comme cela, la création de la plate-forme NewFoo' utilise 'find_or_create_by' de la fonctionnalité, de sorte que le premier appel crée la plate-forme, les 2 prochains appels trouve déjà créé la plate-forme.

De cette façon, tous les 3 versions de plate-forme aura même de la plate-forme NewFoo', et vous pouvez créer autant de groupes de versions de plate-forme que vous avez besoin.

Je pense que c'est un très propre solution, puisque vous gardez l'usine propre, et vous avez même le rendre visible pour le lecteur de test suit que ces 3 versions de plate-forme ont tous la même plate-forme.

J'ai eu ce même problème, et je pense que c'est le même que celui référencé ici: http://groups.google.com/group/factory_girl/browse_frm/thread/68947290d1819952/ef22581f4cd05aa9?tvc=1&q=associations+validates_uniqueness_of#ef22581f4cd05aa9

Je pense que votre solution est peut-être la meilleure solution au problème.

Je pense que j'ai au moins trouvé une manière plus propre.

J'aime l'idée de contacter ThoughtBot sur l'obtention d'un recommandé "officiel" de la solution. Pour l'instant, cela fonctionne bien.

Je viens de combiné l'approche de le faire dans le test du code de avec de le faire dans l'usine de définition.

Factory.define :cart_with_two_add_items, :parent => :cart do |o|
  o.after_build do |cart|
    prod_type = Factory(:add_product_type) # Define locally here and reuse below

    cart.cart_items = [Factory(:cart_item,
                               :cart => cart,
                               :product => Factory(:added_users_product,
                                                   :product_type => prod_type)),
                       Factory(:cart_item,
                               :cart => cart,
                               :product => Factory(:added_profiles_product,
                                                   :product_type => prod_type))]
  end
end

def test_cart_with_same_item_types
  cart = Factory(:cart_with_two_add_items)
  # ... Do asserts
end

Je mettrai à jour si je trouve une meilleure solution.