Getting Started

Aktualisieren Sie Ihr Gemfile

Wenn Sie Rails verwenden, müssen Sie die erforderliche Version von factory_girl_rails:

gem "factory_girl_rails", "~> 4.0"

Wenn Sie Rails nicht verwenden, müssen Sie nur die erforderliche Version von factory_girl:

gem "factory_girl", "~> 4.0"

export JRUBY_OPTS=--1.9

Wenn Ihr Gemfile aktualisiert ist, müssen Sie Ihr Bundle aktualisieren.

Konfigurieren Sie Ihre Testsuite

Erinnern Sie sich daran, die obige Datei in Ihrem rails_helper zu benötigen, da der Support-Ordner nicht eifrig geladen wird

require 'support/factory_girl'

Test::Unit

class Test::Unit::TestCase include FactoryGirl::Syntax::Methodsend

Cucumber

# env.rb (Rails example location - RAILS_ROOT/features/support/env.rb)World(FactoryGirl::Syntax::Methods)

Spinach

class Spinach::FeatureSteps include FactoryGirl::Syntax::Methodsend

Minitest

class Minitest::Unit::TestCase include FactoryGirl::Syntax::Methodsend

Minitest::Spec

class Minitest::Spec include FactoryGirl::Syntax::Methodsend

Minitest-rails

class ActiveSupport::TestCase include FactoryGirl::Syntax::Methodsend

Wenn Sie FactoryGirl::Syntax::Methods nicht in Ihre Testsuite aufnehmen, muss allen factory_girl-Methoden ein FactoryGirl vorangestellt werden.

Definieren von Fabriken

Jede Fabrik hat einen Namen und einen Satz von Attributen. Der Name wird standardmäßig verwendet, um die Klasse des Objekts zu erraten, aber es ist möglich, ihn explizit anzugeben:

Es wird dringend empfohlen, dass Sie eine Fabrik für jede Klasse haben, die den einfachsten Satz von Attributen bereitstellt, die notwendig sind, um eine Instanz dieser Klasse zu erstellen. Wenn Sie ActiveRecord-Objekte erstellen, bedeutet dies, dass Sie nur Attribute bereitstellen sollten, die durch Validierungen erforderlich sind und keine Standardwerte haben. Andere Factories können durch Vererbung erstellt werden, um gemeinsame Szenarien für jede Klasse abzudecken.

Der Versuch, mehrere Factories mit demselben Namen zu definieren, führt zu einem Fehler.

Fabriken können an beliebiger Stelle definiert werden, werden aber automatisch nach dem Aufruf von FactoryGirl.find_definitions geladen, wenn sie in Dateien an den folgenden Stellen definiert sind:

test/factories.rbspec/factories.rbtest/factories/*.rbspec/factories/*.rb

Verwendung von Fabriken

factory_girl unterstützt mehrere verschiedene Erstellungsstrategien: build, create, attributes_for und build_stubbed:

Unabhängig von der verwendeten Strategie ist es möglich, die definierten Attribute zu überschreiben, indem ein Hash übergeben wird:

# Build a User instance and override the first_name propertyuser = build(:user, first_name: "Joe")user.first_name# => "Joe"

Dynamische Attribute

Die meisten Fabrikattribute können mit statischen Werten hinzugefügt werden, die ausgewertet werden, wenn die Fabrik definiert wird, aber einige Attribute (wie Assoziationen und andere Attribute, die dynamisch generiert werden müssen) benötigen Werte, die jedes Mal zugewiesen werden, wenn eine Instanz erzeugt wird. Diese „dynamischen“ Attribute können durch die Übergabe eines Blocks anstelle eines Parameters hinzugefügt werden:

factory :user do # ... activation_code { User.generate_activation_code } date_of_birth { 21.years.ago }end

Aufgrund der Blocksyntax in Ruby erfordert die Definition von Attributen als Hashes (z.B. für serialisierte/JSON-Spalten) zwei Sätze geschweifter Klammern:

factory :program do configuration { { auto_resolve: false, auto_define: true } }end

Aliases

factory_girl ermöglicht die Definition von Aliasen für bestehende Fabriken, um deren Wiederverwendung zu erleichtern. Das ist zum Beispiel nützlich, wenn Ihr Post-Objekt ein Author-Attribut hat, das sich auf eine Instanz der Klasse User bezieht. Während factory_girl normalerweise den Fabriknamen aus dem Assoziationsnamen ableiten kann, wird es in diesem Fall vergeblich nach einer Author-Factory suchen. Also, geben Sie Ihrer User-Factory einen Alias, damit sie unter Alias-Namen verwendet werden kann.

Abhängige Attribute

Attribute können auf den Werten anderer Attribute basieren, indem Sie den Evaluator verwenden, der dynamischen Attributblöcken zur Verfügung gestellt wird:

Transiente Attribute

Es kann Zeiten geben, in denen Ihr Code durch die Übergabe von transienten Attributen an Fabriken trockener gemacht werden kann.

Statische und dynamische Attribute können als transiente Attribute erstellt werden. Transiente Attribute werden innerhalb von attributes_for ignoriert und werden nicht auf dem Modell gesetzt, selbst wenn das Attribut existiert oder Sie versuchen, es zu überschreiben.

In den dynamischen Attributen von factory_girl können Sie auf transiente Attribute zugreifen, wie Sie es erwarten würden. Wenn Sie in einem factory_girl-Callback auf den Evaluator zugreifen müssen, müssen Sie ein zweites Blockargument (für den Evaluator) deklarieren und von dort aus auf transiente Attribute zugreifen.

Methodennamen/Reservierte Wortattribute

Wenn Ihre Attribute mit bestehenden Methoden oder reservierten Wörtern in Konflikt stehen, können Sie sie mit add_attribute definieren.

factory :dna do add_attribute(:sequence) { 'GATTACA' }endfactory :payment do add_attribute(:method) { 'paypal' }end

Vererbung

Sie können leicht mehrere Fabriken für dieselbe Klasse erstellen, ohne gemeinsame Attribute zu wiederholen, indem Sie Fabriken verschachteln:

Sie können auch das Elternteil explizit zuweisen:

factory :post do title "A title"endfactory :approved_post, parent: :post do approved trueend

Wie oben erwähnt, ist es eine gute Praxis, eine Basisfabrik für jede Klasse zu definieren, die nur die für die Erstellung erforderlichen Attribute enthält. Erstellen Sie dann spezifischere Fabriken, die von dieser Basis-Elternklasse erben. Fabrikdefinitionen sind immer noch Code, also halten Sie sie DRY.

Assoziationen

Es ist möglich, Assoziationen innerhalb von Fabriken einzurichten. Wenn der Fabrikname derselbe ist wie der Name der Assoziation, kann der Fabrikname weggelassen werden.

factory :post do # ... authorend

Sie können auch eine andere Fabrik oder Überschreibungsattribute angeben:

factory :post do # ... association :author, factory: :user, last_name: "Writely"end

Das Verhalten der Assoziationsmethode variiert je nach der für das übergeordnete Objekt verwendeten Build-Strategie.

Um das assoziierte Objekt nicht zu speichern, geben Sie in der Fabrik die Strategie: :build an:

Bitte beachten Sie, dass die Option strategy: :build an einen expliziten Aufruf von association übergeben werden muss und nicht mit impliziten Assoziationen verwendet werden kann:

factory :post do # ... author strategy: :build # <<< this does *not* work; causes author_id to be nil

Das Erzeugen von Daten für eine has_many-Beziehung ist etwas komplizierter, abhängig von der gewünschten Flexibilität, aber hier ist ein todsicheres Beispiel für das Erzeugen assoziierter Daten.

FactoryGirl.define do # post factory with a `belongs_to` association for the user factory :post do title "Through the Looking Glass" user end # user factory without associated posts factory :user do name "John Doe" # user_with_posts will create post data after the user has been created factory :user_with_posts do # posts_count is declared as a transient attribute and available in # attributes on the factory, as well as the callback via the evaluator transient do posts_count 5 end # the after(:create) yields two values; the user instance itself and the # evaluator, which stores all values from the factory, including transient # attributes; `create_list`'s second argument is the number of records # to create and we make sure the user is associated properly to the post after(:create) do |user, evaluator| create_list(:post, evaluator.posts_count, user: user) end end endend

Damit können wir Folgendes tun:

create(:user).posts.length # 0create(:user_with_posts).posts.length # 5create(:user_with_posts, posts_count: 15).posts.length # 15

Das Erzeugen von Daten für eine has_and_belongs_to_many-Beziehung ist der obigen has_many-Beziehung sehr ähnlich, mit einer kleinen Änderung: Sie müssen ein Array von Objekten an den pluralisierten Attributnamen des Modells übergeben, anstatt ein einzelnes Objekt an die Singularversion des Attributnamens.

Hier ist ein Beispiel mit zwei Modellen, die überhas_and_belongs_to_many in Beziehung stehen:

FactoryGirl.define do # language factory with a `belongs_to` association for the profile factory :language do title "Through the Looking Glass" profile end # profile factory without associated languages factory :profile do name "John Doe" # profile_with_languages will create language data after the profile has # been created factory :profile_with_languages do # languages_count is declared as an ignored attribute and available in # attributes on the factory, as well as the callback via the evaluator transient do languages_count 5 end # the after(:create) yields two values; the profile instance itself and # the evaluator, which stores all values from the factory, including # ignored attributes; `create_list`'s second argument is the number of # records to create and we make sure the profile is associated properly # to the language after(:create) do |profile, evaluator| create_list(:language, evaluator.languages_count, profiles: ) end end endend

Dies ermöglicht uns:

Sequenzen

Einzigartige Werte in einem bestimmten Format (zum Beispiel E-Mail-Adressen) können mit Hilfe von Sequenzen erzeugt werden. Sequenzen werden durch den Aufruf von sequence in einem Definitionsblock definiert, und Werte in einer Sequenz werden durch den Aufruf vongenerate erzeugt:

Sequenzen können in dynamischen Attributen verwendet werden:

factory :invite do invitee { generate(:email) }end

Oder als implizite Attribute:

factory :user do email # Same as `email { generate(:email) }`end

Und es ist auch möglich, eine Inline-Sequenz zu definieren, die nur in einer bestimmten Fabrik verwendet wird:

factory :user do sequence(:email) { |n| "person#{n}@example.com" }end

Sie können auch den Anfangswert überschreiben:

factory :user do sequence(:email, 1000) { |n| "person#{n}@example.com" }end

Ohne einen Block erhöht sich der Wert selbst, beginnend bei seinem Anfangswert:

factory :post do sequence(:position)end

Sequenzen können auch Aliase haben. Die Sequenz-Aliase teilen sich denselben Zähler:

Aliase definieren und Standardwert (1) für den Zähler verwenden

factory :user do sequence(:email, aliases: ) { |n| "person#{n}@example.com" }end

Wert setzen:

factory :user do sequence(:email, 'a', aliases: ) { |n| "person#{n}@example.com" }end

Der Wert muss nur die Methode #next unterstützen. Hier wird der nächste Wert ‚a‘ sein, dann ‚b‘, usw.

Traits

Traits erlauben es, Attribute zu gruppieren und sie dann auf eine beliebige Fabrik anzuwenden.

Traits können als Attribute verwendet werden:

Traits, die die gleichen Attribute definieren, lösen keine AttributeDefinitionErrors aus; das Trait, das das Attribut zuletzt definiert, hat Vorrang.

Sie können auch einzelne Attribute überschreiben, die von einem Trait in Unterklassen gewährt werden.

Traits können auch als eine Liste von Symbolen übergeben werden, wenn Sie eine Instanz von factory_girl konstruieren.

Diese Fähigkeit funktioniert mit build, build_stubbed, attributes_for und create.

create_list und build_listMethoden werden ebenfalls unterstützt. Denken Sie einfach daran, die Anzahl der zu erstellenden Instanzen als zweiten Parameter zu übergeben, wie im Abschnitt „Erstellen oder Erstellen mehrerer Datensätze“ dieser Datei dokumentiert.

Traits können auch einfach mit Assoziationen verwendet werden:

Wenn Sie Assoziationsnamen verwenden, die sich von der Fabrik unterscheiden:

Traits können innerhalb anderer Traits verwendet werden, um deren Attribute einzubinden.

factory :order do trait :completed do completed_at { 3.days.ago } end trait :refunded do completed refunded_at { 1.day.ago } endend

Schließlich können Traits transiente Attribute akzeptieren.

Callbacks

factory_girl stellt vier Callbacks zur Verfügung, um Code zu injizieren:

Beispiele:

Beachten Sie, dass Sie eine Instanz des Benutzers im Block haben werden. Das kann nützlich sein.

Sie können auch mehrere Arten von Rückrufen für dieselbe Fabrik definieren:

factory :user do after(:build) { |user| do_something_to(user) } after(:create) { |user| do_something_else_to(user) }end

Fabriken können auch eine beliebige Anzahl der gleichen Art von Rückrufen definieren. Diese Rückrufe werden in der Reihenfolge ausgeführt, in der sie angegeben sind:

factory :user do after(:create) { this_runs_first } after(:create) { then_this }end

Der Aufruf von create ruft sowohl after_build als auch after_create Rückrufe auf.

Wie bei Standardattributen erben auch untergeordnete Fabriken Rückrufe von ihrer übergeordneten Fabrik (und können diese auch definieren).

Mehrere Rückrufe können zugewiesen werden, um einen Block auszuführen; dies ist nützlich, wenn verschiedene Strategien gebaut werden, die den gleichen Code ausführen (da es keine Rückrufe gibt, die von allen Strategien gemeinsam genutzt werden).

Um Callbacks für alle Fabriken zu überschreiben, definieren Sie sie innerhalb desFactoryGirl.define Blocks:

Sie können auch Callbacks verwenden, die auf Symbol#to_proc beruhen:

Fabriken modifizieren

Wenn Sie einen Satz von Fabriken erhalten (z.B. von einem Edelsteinentwickler), diese aber ändern möchten, damit sie besser in Ihre Anwendung passen, können Sie diese Fabrik modifizieren, anstatt eine untergeordnete Fabrik zu erstellen und dort Attribute hinzuzufügen.

Wenn ein Edelstein Ihnen eine Benutzerfabrik gibt:

FactoryGirl.define do factory :user do full_name "John Doe" sequence(:username) { |n| "user#{n}" } password "password" endend

Anstatt eine untergeordnete Fabrik zu erstellen, die zusätzliche Attribute hinzufügt:

Sie können diese Fabrik stattdessen modifizieren.

FactoryGirl.modify do factory :user do full_name "Jane Doe" date_of_birth { 21.years.ago } gender "Female" health 90 endend

Wenn Sie eine Fabrik modifizieren, können Sie alle gewünschten Attribute ändern (abgesehen von Callbacks).

FactoryGirl.modify muss außerhalb eines FactoryGirl.defineBlocks aufgerufen werden, da er anders mit Fabriken umgeht.

Eine Einschränkung: Sie können nur Fabriken ändern (nicht Sequenzen oder Eigenschaften) und Rückrufe werden weiterhin wie gewohnt zusammengesetzt. Wenn also die Fabrik, die du modifizierst, einen after(:create) Callback definiert, wirst du, wenn du einen after(:create) Callback definierst, diesen nicht außer Kraft setzen, er wird einfach nach dem ersten Callback ausgeführt.

Erstellen oder Erzeugen mehrerer Datensätze

Gelegentlich wirst du mehrere Instanzen einer Fabrik auf einmal erstellen oder erzeugen wollen.

built_users = build_list(:user, 25)created_users = create_list(:user, 25)

Diese Methoden bauen oder erstellen eine bestimmte Anzahl von Fabriken und geben sie als Array zurück.um die Attribute für jede der Fabriken zu setzen, können Sie einen Hash übergeben, wie Sie es normalerweise tun würden.

twenty_year_olds = build_list(:user, 25, date_of_birth: 20.years.ago)

build_stubbed_list gibt Ihnen vollständig ausgefüllte Instanzen:

stubbed_users = build_stubbed_list(:user, 25) # array of stubbed users

Es gibt auch eine Reihe von *_pair Methoden, um zwei Datensätze auf einmal zu erstellen:

built_users = build_pair(:user) # array of two built userscreated_users = create_pair(:user) # array of two created users

Wenn Sie mehrere Attribut-Hashes benötigen, erzeugt attributes_for_list diese:

users_attrs = attributes_for_list(:user, 25) # array of attribute hashes

Linting Factories

factory_girl ermöglicht das Linting bekannter Fabriken:

FactoryGirl.lint

FactoryGirl.lint erstellt jede Fabrik und fängt alle Ausnahmen ab, die während des Erstellungsprozesses auftreten. FactoryGirl::InvalidFactoryError wird mit einer Liste von Fabriken (und entsprechenden Ausnahmen) für Fabriken ausgelöst, die nicht erstellt werden konnten.

Empfohlen wird, FactoryGirl.lintin einem Task auszuführen, bevor die Testsuite ausgeführt wird.Die Ausführung in einer before(:suite), wird die Leistung Ihrer Tests negativ beeinflussen, wenn einzelne Tests ausgeführt werden.

Beispiel Rake task:

Nach dem Aufruf von FactoryGirl.lint, werden Sie wahrscheinlich die Datenbank leeren wollen, da höchstwahrscheinlich Datensätze erstellt werden. Das obige Beispiel verwendet das Gem database_cleaner, um die Datenbank zu leeren; stellen Sie sicher, dass Sie das Gem zu Ihrer Gemfile unter den entsprechenden Gruppen hinzufügen.

Sie können Fabriken selektiv lintieren, indem Sie nur die Fabriken übergeben, die Sie lintieren wollen:

factories_to_lint = FactoryGirl.factories.reject do |factory| factory.name =~ /^old_/endFactoryGirl.lint factories_to_lint

Dies würde alle Fabriken lintieren, die nicht mit old_ vorangestellt sind.

Eigenschaften können ebenfalls gelint werden. Diese Option prüft, ob jede Eigenschaft einer Fabrik für sich ein gültiges Objekt erzeugt.Dies wird durch die Übergabe von traits: true an die lint-Methode aktiviert:

FactoryGirl.lint traits: true

Dies kann auch mit anderen Argumenten kombiniert werden:

FactoryGirl.lint factories_to_lint, traits: true

Sie können auch die für das Linting verwendete Strategie angeben:

FactoryGirl.lint strategy: :build

Benutzerdefinierte Konstruktion

Wenn Sie factory_girl verwenden möchten, um ein Objekt zu konstruieren, bei dem einige Attribute an initialize übergeben werden, oder wenn Sie etwas anderes als den einfachen Aufruf von new in Ihrer Build-Klasse tun möchten, können Sie das Standardverhalten außer Kraft setzen, indem Sie initialize_with in Ihrer Factory definieren. Beispiel:

Obwohl factory_girl von Haus aus für ActiveRecord geschrieben wurde, kann es auch mit jeder Ruby-Klasse funktionieren. Um maximale Kompatibilität mit ActiveRecord zu gewährleisten, erstellt der Standardinitialisierer alle Instanzen durch den Aufruf von new in Ihrer Build-Klasse ohne Argumente. Er ruft dann Attribut-Writer-Methoden auf, um alle Attributwerte zuzuweisen. Während das für ActiveRecord gut funktioniert, funktioniert es für fast alle anderen Ruby-Klassen nicht.

Sie können den Initialisierer überschreiben, um:

• Nicht-ActiveRecord-Objekte zu erstellen, die Argumente für initialize
• eine andere Methode als new zu verwenden, um die Instanz zu instanziieren
• Verrückte Dinge zu tun, wie die Instanz zu dekorieren, nachdem sie erstellt wurde

Wenn du initialize_with verwendest, musst du die Klasse selbst nicht deklarieren, wenn du new aufrufst; aber alle anderen Klassenmethoden, die Sie aufrufen wollen, müssen explizit in der Klasse aufgerufen werden.

Zum Beispiel:

factory :user do name "John Doe" initialize_with { User.build_with_name(name) }end

Sie können auch auf alle öffentlichen Attribute innerhalb des initialize_with-Blocks zugreifen, indem Sie attributes aufrufen:

factory :user do transient do 5 end name "John Doe" initialize_with { new(attributes) }end

Dies erstellt einen Hash aller Attribute, die an new übergeben werden. Transiente Attribute werden nicht berücksichtigt, aber alles andere, was in der Fabrik definiert ist, wird übergeben (Assoziationen, ausgewertete Sequenzen, etc.)

Sie können initialize_with für alle Fabriken definieren, indem Sie es in denFactoryGirl.defineBlock einfügen:

FactoryGirl.define do initialize_with { new("Awesome first argument") }end

Wenn Sie initialize_with verwenden, werden Attribute, auf die innerhalb des initialize_withBlocks zugegriffen wird, nur im Konstruktor zugewiesen; dies entspricht in etwa folgendem Code:

FactoryGirl.define do factory :user do initialize_with { new(name) } name { 'value' } endendbuild(:user)# runsUser.new('value')

Dies verhindert doppelte Zuweisungen; in Versionen von factory_girl vor 4.0 würde es so ablaufen:

Benutzerdefinierte Strategien

Es gibt Fälle, in denen man das Verhalten von factory_girl durch Hinzufügen einer benutzerdefinierten Build-Strategie erweitern möchte.

Strategien definieren zwei Methoden: association und result. associationerhält eine FactoryGirl::FactoryRunnerInstanz, auf die Sie runaufrufen können, wobei Sie die Strategie überschreiben können, wenn Sie wollen. Die zweite Methode, result, empfängt eine FactoryGirl::Evaluation-Instanz. Sie bietet eine Möglichkeit, Rückrufe auszulösen (mit notify), object oder hash (um die Ergebnisinstanz oder einen Hash auf der Grundlage der in der Fabrik definierten Attribute zu erhalten), und create, die den in der Fabrik definierten to_create Rückruf ausführt.

Um zu verstehen, wie factory_girl intern Strategien verwendet, ist es wahrscheinlich am einfachsten, den Quelltext für jede der vier Standardstrategien anzusehen.

Hier ist ein Beispiel für das Zusammenstellen einer Strategie mitFactoryGirl::Strategy::Create, um eine JSON-Darstellung des Modells zu erstellen.

Damit factory_girl die neue Strategie erkennt, können Sie sie registrieren:

FactoryGirl.register_strategy(:json, JsonStrategy)

Damit können Sie

FactoryGirl.json(:user)

Schließlich können Sie die eigenen Strategien von factory_girl überschreiben, wenn Sie das möchten, indem Sie ein neues Objekt anstelle der Strategien registrieren.

Benutzerdefinierte Callbacks

Benutzerdefinierte Callbacks können definiert werden, wenn Sie benutzerdefinierte Strategien verwenden:

Benutzerdefinierte Methoden zum Persistieren von Objekten

Standardmäßig wird beim Erstellen eines Datensatzes save! für die Instanz aufgerufen; da dies nicht immer ideal ist, können Sie dieses Verhalten außer Kraft setzen, indem Sie to_create für die Fabrik definieren:

factory :different_orm_model do to_create { |instance| instance.persist! }end

Um die Persistenzmethode beim Erstellen ganz zu deaktivieren, können Sie skip_createfür diese Fabrik:

factory :user_without_database do skip_createend

Um to_create für alle Fabriken zu überschreiben, definieren Sie es innerhalb desFactoryGirl.define Blocks:

FactoryGirl.define do to_create { |instance| instance.persist! } factory :user do name "John Doe" endend

ActiveSupport Instrumentation

Um zu verfolgen, welche Fabriken erstellt werden (und mit welcher Build-Strategie),ActiveSupport::Notifications sind enthalten, um eine Möglichkeit zu bieten, Fabriken zu abonnieren, die ausgeführt werden. Ein Beispiel wäre die Verfolgung von Fabriken auf der Grundlage eines Schwellenwerts für die Ausführungszeit.

Ein anderes Beispiel wäre die Verfolgung aller Fabriken und ihrer Verwendung in der gesamten Testsuite. Wenn Sie RSpec verwenden, ist es so einfach wie das Hinzufügen von before(:suite) und after(:suite):

Rails-Preloader und RSpec

Wenn RSpec mit einem Rails-Preloader wie spring oder zeus ausgeführt wird, ist es möglich, dass ein ActiveRecord::AssociationTypeMismatch-Fehler auftritt, wenn eine Fabrik mit Assoziationen erstellt wird, wie unten dargestellt:

Der Fehler tritt während der Ausführung der Testsuite auf:

Die beiden möglichen Lösungen sind entweder die Suite ohne den Preloader auszuführen, oder FactoryGirl.reload zur RSpec-Konfiguration hinzuzufügen, etwa so:

RSpec.configure do |config| config.before(:suite) { FactoryGirl.reload }end

Ohne Bundler verwenden

Wenn Sie Bundler nicht verwenden, stellen Sie sicher, dass das Gem installiert ist und rufen Sie auf:

require 'factory_girl'

Wenn Sie eine Verzeichnisstruktur von spec/factories odertest/factories haben, müssen Sie nur noch

FactoryGirl.find_definitions

Wenn Sie eine separate Verzeichnisstruktur für Ihre Factories verwenden, können Sie die Pfade der Definitionsdateien ändern, bevor Sie versuchen, Definitionen zu finden:

FactoryGirl.definition_file_paths = %w(custom_factories_directory)FactoryGirl.find_definitions

Wenn Sie kein separates Verzeichnis für Fabriken haben und diese inline definieren möchten, ist das ebenfalls möglich:

require 'factory_girl'FactoryGirl.define do factory :user do name 'John Doe' date_of_birth { 21.years.ago } endend