Share
Deze tweedelige miniserie is geschreven voor mensen die willen werken met Factory Girl en zich willen inspannen zonder de documentatie te veel door te nemen. Voor mensen die onlangs met tests begonnen te spelen, heb ik mijn best gedaan om het vriendelijk voor beginners te houden.
Het is duidelijk dat ik op een gegeven moment in dezelfde schoenen heb gezeten dat ik geloof dat het niet veel vergen om nieuwe mensen zich comfortabeler te laten voelen bij het testen. Het nemen van een beetje meer tijd om de context uit te leggen en het jargon te ontraadselen gaat een lange weg in het verminderen van frustratie voor beginners.
Laten we beginnen met een beetje geschiedenis en praten over de fijne mensen bij thoughtbot die verantwoordelijk zijn voor deze populaire Ruby-edelsteen. In 2007/2008 had Joe Ferris, CTO van thoughtbot, het al met armaturen gehad en begon hij zijn eigen oplossing te koken. Het doorlopen van verschillende bestanden om een enkele methode te testen was een veel voorkomend pijnpunt bij het omgaan met fixtures. Anders gezegd en alle soorten inflexibiliteit negerend, leidt die praktijk ook tot het schrijven van tests die je niet veel vertellen over hun context die meteen wordt getest.
Niet verkocht op die huidige praktijk deed hem verschillende oplossingen voor fabrieken bekijken, maar geen van hen ondersteunde alles wat hij wilde. Dus bedacht hij Factory Girl, waardoor testen met testgegevens leesbaarder, DROOG en ook explicieter werd door u de context voor elke test te geven. Een paar jaar later nam Josh Clayton, Development Director bij thoughtbot in Boston, de taak op zich om het project voort te zetten. In de loop van de tijd is dit juweeltje gestaag gegroeid en wordt het een "vaste waarde" in de Ruby-gemeenschap.
Laten we het hebben over de belangrijkste pijnpunten die Factory Girl oplost. Wanneer u uw testsuite samenstelt, hebt u te maken met veel bijbehorende records en met informatie die vaak verandert. U wilt datasets kunnen bouwen voor uw integratietests die niet broos, eenvoudig te beheren en expliciet zijn. Uw datafabrieken moeten dynamisch zijn en in staat zijn om naar andere fabrieken te verwijzen - iets dat gedeeltelijk buiten YAML-armaturen van vroeger valt.
Een ander gemak dat u wilt hebben, is de mogelijkheid attributen voor objecten on the fly te overschrijven. Met Factory Girl kun je dat allemaal moeiteloos doen, gezien het feit dat het in Ruby is geschreven en veel metaprogrammering plaatsvindt achter de schermen, en je bent voorzien van een geweldige domeinspecifieke taal die gemakkelijk in de ogen staat te.
Het opbouwen van je armatuurgegevens met dit juweel kan worden omschreven als gemakkelijk, effectief en over het algemeen handiger dan gehannes met armaturen. Op die manier kunt u meer met concepten omgaan dan met de eigenlijke kolommen in de database. Maar genoeg om te praten, laten we onze handen een beetje vies maken.
Mensen die ervaring hebben met het testen van applicaties en die niet over het concept van armaturen hoeven te leren, aarzel dan niet om direct naar de volgende sectie te gaan. Deze is voor nieuwkomers die alleen een update over het testen van gegevens nodig hebben.
Armaturen zijn voorbeeldgegevens - dat is het echt! Voor een flink deel van uw testsuite wilt u uw testdatabase kunnen vullen met gegevens die zijn afgestemd op uw specifieke testcases. Voor een tijdje gebruikten veel ontwikkelaars YAML voor deze gegevens, waardoor deze database onafhankelijk werd. Achteraf gezien was onafhankelijk zijn misschien wel het beste ding ervan. Het was min of meer één bestand per model. Dat alleen al zou je een idee kunnen geven van allerlei soorten hoofdpijn waar mensen over klagen. Complexiteit is een snelgroeiende vijand die YAML nauwelijks in staat is om effectief op te nemen. Hieronder zie je wat zo'n .YML bestand met testgegevens eruitziet.
YAML-bestand: secret_service.yml
"plain Quartermaster: naam: Q favorite_gadget: Broom radiovaardigheden: uitvindingen en hacking uitvinden
00 Agent: naam: James Bond favorite_gadget: onderzeeër Lotus Esprit-vaardigheden: Bond-meisjes vermoorden en verkapte infiltratie "
Het ziet eruit als een hash, nietwaar? Het is een door dubbele punten gescheiden lijst van sleutel- / waardeparen die van elkaar zijn gescheiden door een lege ruimte. U kunt naar andere knooppunten in elkaar verwijzen als u associaties van uw modellen wilt simuleren. Maar ik denk dat het eerlijk is om te zeggen dat daar de muziek stopt en velen zeggen dat hun pijn begint. Voor datasets die een beetje meer betrokken zijn, zijn YAML-fixtures moeilijk te onderhouden en moeilijk te veranderen zonder andere tests te beïnvloeden. Je kunt ze laten werken, natuurlijk - ontwikkelaars hebben er in het verleden veel gebruik van gemaakt - maar veel mensen waren het erover eens dat de prijs voor het beheren van armaturen net iets te hoog was.
Om te voorkomen dat uw testgegevens worden doorbroken wanneer de onvermijdelijke wijzigingen zich voordoen, namen ontwikkelaars graag nieuwe strategieën toe die meer flexibiliteit en dynamisch gedrag boden. Dat is waar Factory Girl binnenkwam en de YAML-dagen achterliet. Een ander probleem is de grote afhankelijkheid tussen de test en de .YML armatuur bestand. Geheimzinnigheid gasten zijn ook een grote pijn met dit soort armaturen. Met Factory Girl kunt u dat voorkomen door objecten die relevant zijn voor de tests inline te maken.
Natuurlijk zijn YAML-fixtures snel en ik heb gehoord dat mensen beweren dat een langzame testsuite met Factory Girl-gegevens ervoor zorgde dat ze teruggingen naar YAML-land. Als u Factory Girl zozeer gebruikt dat het uw tests aanzienlijk vertraagt, denkt u misschien onnodig veel aan fabrieken en negeert u strategieën die de database niet raken. U zult zien wat ik bedoel als we bij de relevante sectie (s) komen. Gebruik natuurlijk alles wat je nodig hebt, maar beschouw jezelf als gewaarschuwd als je wordt verbrand door YAML.
Ik denk dat het eerlijk is om eraan toe te voegen dat YAML-armaturen in de beginperiode van Rails en Ruby TDD de de facto standaard waren voor het instellen van testgegevens in uw toepassing. Ze speelden een belangrijke rol en hielpen de sector vooruit. Tegenwoordig hebben ze echter een redelijk slechte rep. Tijden veranderen, dus laten we overgaan tot fabrieken, die bedoeld zijn om armaturen te vervangen.
Ik neem aan dat je al Ruby en RSpec hebt om te testen op je systeem. Zo niet, kom dan terug nadat u Google hebt geraadpleegd en u moet goed zijn om te gaan. Het is vrij eenvoudig, zou ik zeggen. U kunt de edelsteen handmatig in uw terminal installeren Shell:
bash gem install factory_girl
of voeg het toe aan jouw Gemfile:
robijn edelsteen "factory_girl", "~> 4.0" en loop bundel installeren.
Nu hoeft u alleen maar vereisen Factory Girl om je setup te voltooien. Hier gebruik ik RSpec, dus voeg het volgende bovenaan toe /spec/spec_helper.rb:
robijn vereist 'factory_girl'
Je bent natuurlijk gedekt als je Factory Girl with Rails wilt gebruiken. De factory_girl_rails gem biedt een handige Rails-integratie voor factory_girl.
Shell:
bash gem install factory_girl_rails
Gemfile:
ruby gem "factory_girl_rails", "~> 4.0"
en vereisen het is natuurlijk in spec / spec_helper.rb:
robijn vereist 'factory_girl_rails'
Als u liever zoiets invoert als (natuurlijk doet u dat)
Robijn:
ruby create (: gebruiker)
in plaats van
ruby FactoryGirl.create (: gebruiker)
elke keer dat u een van uw fabrieken gebruikt, hoeft u alleen de FactoryGirl :: Syntax :: Methods module in uw testconfiguratiebestand. Als je die stap bent vergeten, moet je alle Factory Girl-methoden invoeren met hetzelfde uitgebreide voorwoord. Dit werkt met elke Ruby-app, niet alleen met Rails-enen.
Voor RSpec vind je de spec / spec_helper.rb bestand en voeg toe:
"ruby require 'factory_girl_rails'
RSpec.configuratie do | config | config.include FactoryGirl :: Syntax :: Methods end "
Voor de nieuwelingen onder u, pas op dat de RSpec.configure blok zal er al zijn - begraven onder een aantal opmerkingen. Je kunt dezelfde instellingen ook in een apart bestand van je eigen soort doen spec / support / factory_girl.rb. In dat geval moet je natuurlijk het hele configuratieblok zelf toevoegen.
Dezelfde configuratie werkt als u andere bibliotheken gebruikt om te testen:
Je kunt meer fantaseren met je configuratie door erin te gooien DatabaseCleaner, bijvoorbeeld, maar de documentatie impliceert dat deze opstelling voldoende is om van start te gaan, dus ik ga van hier verder.
U kunt uw fabrieken overal definiëren, maar ze worden automatisch geladen als ze op de volgende locaties worden geplaatst:
RSpec:
bash spec / fabrieken.rb spec / fabrieken / *. rb
Test :: Eenheid:
bash test / fabrieken.rb test / fabrieken / *. rb
Zoals je kunt zien, heb je de optie om ze op te splitsen in afzonderlijke bestanden die aansluiten bij welke logica dan ook, of om je fabrieken samen te bundelen tot één grote factories.rb het dossier. De complexiteit van uw project is de beste richtlijn voor het logisch scheiden van fabrieken in hun eigen afzonderlijke bestanden.
Factory Girl biedt een goed ontwikkelde robijnrode DSL-syntaxis voor het definiëren van fabrieken zoals gebruiker, post of een ander object - niet alleen Actieve record voorwerpen. "Gewone" Ruby-klassen zijn prima. U begint met het instellen van een definitieblok in uw factories.rb het dossier.
Robijn:
"ruby FactoryGirl.define doen
einde"
Alle fabrieken worden binnen dit blok gedefinieerd. Fabrieken hebben alleen een a nodig :symbool naam en een reeks attributen om te beginnen. Deze naam moet de zijn snake_cased versie van het Model dat u wilt emuleren, zoals SecretServiceAgent in het volgende voorbeeld. De fabriek hieronder is genoemd secret_service_agent en heeft attributen genoemd naam, favorite_gadget en vaardigheden.
Robijn:
"ruby FactoryGirl.define doen
fabriek: secret_service_agent do name "Q" favorite_gadget "Submarine Lotus Esprit" skills "Inventing gizmos and hacking" einde
einde"
Als u één ding wegneemt van dit artikel, zou het als volgt moeten zijn: definieer alleen de meest kale fabriek die mogelijk is om standaard geldig te zijn in de zin van Active Record-validaties, bijvoorbeeld.
Wanneer Factory Girl belt opslaan! in sommige gevallen worden uw validaties uitgevoerd. Als een van hen faalt, ActiveRecord :: RecordInvalid wordt opgevoed. Het definiëren van alleen het absolute minimum geeft u meer flexibiliteit als uw gegevens veranderen en vermindert de kans op het verbreken van tests en duplicatie, omdat koppeling tot de kern wordt herleid. Wees niet lui wanneer je je fabrieken samenstelt - het zal veel geld opleveren!
Als u denkt dat dit moeilijk te beheren klinkt, zult u hoogstwaarschijnlijk blij zijn te horen dat er handige oplossingen zijn om voorwerpen en hun attributen van elkaar te scheiden.. Erfenis en Eigenschappen zullen geweldige bondgenoten worden, omdat het handige strategieën zijn om je kale fabrieken aan te vullen en tegelijkertijd DROOG te houden. Meer informatie over overerving hieronder, en mijn tweede artikel zal zich nogal focussen op eigenschappen.
Als u de FactoryGirl :: Syntax :: Methods in de configuratiestap kunt u de steno-syntaxis gebruiken om fabrieken in uw tests te maken. Je hebt vier opties, die mensen noemen bouw strategieën:
ruby create (: some_object) # FactoryGirl.create (: some_object)
Deze retourneert een exemplaar van de klasse die de fabriek emuleert. Het wordt aanbevolen om te gebruiken creëren alleen als je echt de database moet raken. Deze strategie vertraagt uw testsuite als deze onnodig wordt gebruikt. Gebruik het als u uw validaties wilt uitvoeren, omdat het zal worden uitgevoerd opslaan! op de achtergrond. Ik denk dat deze optie vooral geschikt is als u integratietests uitvoert waarbij u een database wilt gebruiken voor uw testscenario's.
ruby build (: some_object) # FactoryGirl.build (: some_object)
Het concretiseert en wijst kenmerken toe, maar u krijgt een exemplaar teruggestuurd dat niet in de database is opgeslagen-bouwen houdt het object alleen in het geheugen. Als u wilt controleren of een object bepaalde kenmerken heeft, zal dit het werk doen, aangezien u voor dat soort zaken geen databasetoegang nodig heeft. Achter de schermen wordt het niet gebruikt opslaan!, wat betekent dat uw validaties niet worden uitgevoerd.
Wanneer u associaties ermee gebruikt, kunt u een kleine gotcha tegenkomen. Er is een kleine uitzondering met betrekking tot het niet opslaan van het object via bouwen-het bouwt het object maar het creëert de verenigingen - die ik in het gedeelte over Factory Girl-associaties zal bespreken. Daar is een oplossing voor, voor het geval dat niet is waar je naar op zoek was.
ruby build_stubbed (: some_object) # FactoryGirl.build_stubbed (: some_object)
Deze optie is gemaakt om uw tests te versnellen en voor testgevallen waarbij geen van de code de database hoeft te raken. Het definieert ook en wijst attributen toe als bouwen doet, maar het zorgt er alleen maar voor dat objecten eruitzien alsof ze zijn volgehouden. Het geretourneerde object heeft alle gedefinieerde attributen uit je fabriek uitgeboet - plus een nep ID kaart en nul timestamps. Hun associaties zijn net zo goed uitgewerkt als anders bouwen associaties die gebruiken creëren op bijbehorende objecten. Aangezien deze strategie te maken heeft met stubs en geen afhankelijkheid van de database heeft, zullen deze tests zo snel zijn als ze worden.
Deze methode retourneert een hash van alleen de kenmerken die zijn gedefinieerd in de relevante fabriek, zonder associaties, tijdstempels en id-code. Het is handig als u een instantie van een object wilt bouwen zonder dat u met hashes handmatig hoeft te hacken. Ik heb het vooral in vergelijkbare Controller-specificaties gezien:
Robijn:
"ruby it" verwijst naar een locatie door 'do post: create, spy: attributes_for (: spy)
verwachten (reactie) .toire_naar (some_location) end "
Om deze sectie te sluiten, wil ik u een eenvoudig voorbeeld geven om de verschillende objecten terug te zien komen van deze vier bouwstrategieën. Hieronder kun je de vier verschillende objecten vergelijken waarvan je zult profiteren attributes_for, creëren, bouwen en build_stubbed:
"ruby FactoryGirl.define doen
fabriek: spion do naam "Marty McSpy" favorite_gadget "Hoverboard" vaardigheden "Infiltratie en spionage" einde
einde"
"ruby attributes_for (: spy)
"
"ruby create (: spy)
"ruby build (: spion)
"ruby build_stubbed (: spion)
Ik hoop dat dit nuttig was als je nog steeds enige verwarring over had over hoe ze werken en wanneer je welke optie moet gebruiken.
Je gaat van deze houden! Met overerving kunt u fabrieken alleen definiëren met de benodigde kenmerken die elke klasse nodig heeft voor het maken. Deze ouderfabriek kan zoveel "kinderfabrieken" spawnen als u nodig acht om alle soorten testscenario's met verschillende gegevenssets te dekken. Het bijhouden van uw testgegevens DRY is erg belangrijk en overerving maakt dit een stuk eenvoudiger voor u.
Stel dat u een aantal kernattributen in een fabriek wilt definiëren en binnen dezelfde fabriek verschillende fabrieken voor hetzelfde bedrijf hebt Klasse met verschillende attributen. In het onderstaande voorbeeld kunt u zien hoe u herhalingen kunt voorkomen door alleen uw fabrieken te nesten. Laten we emuleren Spion klasse die zich aan drie verschillende testscenario's moet aanpassen.
factories.rb
"ruby FactoryGirl.define doen
fabriek: spion do naam 'Marty McSpy' licentie_naar_kill valse vaardigheden 'Spionage en intelligentie'
fabriek: kwartiermaker do naam 'Q' vaardigheden 'Uitvinden van gadgets en hacking' end factory: bond do name 'James Bond' licence_to_kill true end end
einde"
some_spec.rb
"ruby bond = create (: bond) kwartiermaker = create (: kwartiermaker)
quartermaster.name # => 'Q' quartermaster.skills # => 'Gizmos en hacking uitvinden' quartermaster.licence_to_kill # => false
bond.name # => 'James Bond' bond.skills # => 'Spionage en intelligentie' bond.licence_to_kill # => true "
Zoals je kunt zien, is de :binding en :kwartiermeester fabrieken erven attributen van hun ouder :spion. Tegelijkertijd kunt u eenvoudig attributen overschrijven als dat nodig is en er heel expressief over zijn via hun fabrieksnamen. Stel je alle regels code voor die zijn opgeslagen, omdat je niet dezelfde basisinstellingen hoeft te herhalen als je verschillende toestanden of gerelateerde objecten wilt testen. Die eigenschap alleen al is het waard om Factory Girl te gebruiken en het maakt het moeilijk om terug te gaan naar YAML-armaturen.
Als u wilt voorkomen dat de fabrieksdefinities worden genest, kunt u fabrieken ook expliciet aan hun ouder koppelen door een ouder hash:
factories.rb
"robijnfabriek: spion do naam 'Marty McSpy' licentie_naar_kill valse vaardigheden 'spionage en intelligentie' einde
factory: bond, parent:: spy do name 'James Bond' licence_to_kill true end "
Het is dezelfde functionaliteit en bijna net zo droog.
Hier is een kleine, maar niettemin verwelkomende toevoeging aan Factory Girl die het omgaan met lijsten eenvoudig maakt als taart:
Af en toe, in situaties waar je meerdere exemplaren van een fabriek wilt hebben zonder veel fuzz, zullen deze van pas komen. Beide methoden retourneren een array met het opgegeven aantal fabrieksitems. Behoorlijk goed?
Robijn:
"ruby spy_clones = create_list (: spion, 3)
fake_spies = build_list (: spion, 3)
spy_clones # => [#
fake_spies # => [#
Er zijn subtiele verschillen tussen de twee opties, maar ik weet zeker dat je ze nu begrijpt. Ik moet ook vermelden dat je beide methoden kunt voorzien van een hash van kenmerken als je de fabrieksattributen om de een of andere reden on-the-fly wilt overschrijven. De overschrijvingen zullen een beetje van uw testsnelheid opeten als u veel testgegevens maakt met overschrijvingen. Waarschijnlijk zal het hebben van een aparte fabriek met deze kenmerken veranderd een betere optie zijn om lijsten te maken.
"ruby smug_spies = create_list (: spion, 3, vaardigheden: 'Smug grappen')
double_agents = build_list (: spion, 3, naam: 'Vesper Lynd', vaardigheden: 'Verleiding en boekhouden')
smug_spies # => [#
double_agents # => [#
Je hebt vaak een paar objecten nodig, dus Factory Girl biedt je nog twee opties:
Het is hetzelfde idee als hierboven, maar de geretourneerde array bevat slechts twee records tegelijk.
"ruby create_pair (: spy) # => [#
build_pair (: spy) # => [#
Als je zou denken dat het benoemen van spionnen minder statisch zou kunnen zijn, heb je absoluut gelijk. In deze laatste sectie bekijken we sequentiële unieke waarden als testgegevens voor uw fabrieksattributen.
Wanneer kan dit nuttig zijn? Hoe zit het met unieke e-mailadressen voor het testen van authenticatie of unieke gebruikersnamen bijvoorbeeld? Dat is waar sequenties schijnen. Laten we eens kijken naar een aantal verschillende manieren waarop u gebruik kunt maken volgorde:
"ruby FactoryGirl.define doen
volgorde: spy_email do | n | "00#[email protected]" einde
fabriek: spion do naam 'Marty McSpy' email '[email protected]' vaardigheden 'Spionage en infiltratie' license_to_kill false
fabriek: elite_spy do naam 'Edward Donne' license_to_kill true end end
einde
top_spy = create (: elite_spy) top_spy.email = generate (: spy_email)
top_spy.email # => "[email protected]" "
Omdat deze reeks 'globaal' is gedefinieerd voor al uw fabrieken - het hoort niet bij een specifieke fabriek - kunt u deze sequentiegenerator voor al uw fabrieken gebruiken waar u maar wilt. : spy_email. Alles wat je nodig hebt is voortbrengen en de naam van uw reeks.
Als een kleine variatie die superhandig is, laat ik je zien hoe je reeksen direct toewijst als attributen aan je fabrieken. Gebruik dezelfde voorwaarde als hierboven, waarbij uw reeks "globaal" is gedefinieerd. In het geval van een fabrieksdefinitie kunt u de instelling verlaten voortbrengen method call en Factory Girl zullen de geretourneerde waarde uit de reeks direct toewijzen aan het attribuut met dezelfde naam. Netjes!
"ruby FactoryGirl.define doen
volgorde: email do | n | "00#[email protected]" einde
fabriek: secret_service_agent do name 'Edwad Donne' e-mailvaardigheden 'Spionage en infiltratie' license_to_kill true end
einde"
U kunt ook een volgorde op luie attributen. Ik zal dit onderwerp in mijn tweede artikel behandelen, maar omwille van de volledigheid wilde ik het hier ook vermelden. Als u een unieke waarde nodig hebt die is toegewezen op het moment dat de instantie wordt gemaakt, wordt deze genoemd lui omdat dit attribuut wacht met waarde-toewijzing totdat object-instantiatie-sequenties slechts een blok nodig hebben om ook te werken.
"robijn
FactoryGirl.define doen
volgorde: mission_deployment do | number | "Mission # number op # DateTime.now.to_formatted_s (: short)" end
fabriek: spion noem 'Marty McSpy' deployment generate (: mission_deployment) end
einde
some_spy = create (: spy) some_spy.deployment # => "Mission # 1 at 19 Oct 21:13" "
Het blok voor het attribuut factory wordt geëvalueerd wanneer het object wordt geïnstantieerd. In ons geval krijg je een string die bestaat uit een uniek missienummer en een nieuw nummer Datum Tijd object als waarden voor elke :spion dat wordt ingezet.
Deze optie is het beste wanneer een reeks unieke waarden alleen nodig is voor een kenmerk voor een enkele fabriek. Het zou geen zin hebben om het buiten die fabriek te definiëren en mogelijk ergens anders naar te zoeken als u het moet aanpassen. In het onderstaande voorbeeld willen we unieke id's genereren voor elke spionwagen.
"ruby FactoryGirl.define doen
fabriek: aston_martin do sequence (: vehicle_id_number) | n | "A_M _ # n" einde
einde
spycar_01 = create (: aston_martin) spycar_01.sehicle_id_number # => "A_M_1"
spycar_02 = create (: aston_martin) spycar_02.sehicle_id_number # => "A_M_2" "
Nou ja, misschien moeten we de vehicle_id_number een andere startwaarde dan toevoegen 1? Laten we zeggen dat we rekening willen houden met een aantal prototypen voordat de auto klaar was voor productie. U kunt een tweede argument als startwaarde voor uw reeks opgeven. Laten we gaan 9 deze keer.
"ruby FactoryGirl.define doen
fabriek: aston_martin do sequence (: vehicle_id_number, 9) | n | "A_M _ # n" einde
einde
spycar_01 = create (: aston_martin) spycar_01.sehicle_id_number # => "A_M_9"
spycar_02 = create (: aston_martin) spycar_02.sehicle_id_number # => "A_M_10"
"
Zoals je inmiddels hebt gezien, biedt Factory Girl een goed gebalanceerde Ruby DSL die objecten bouwt in plaats van Database Records voor je testgegevens. Het helpt om uw tests geconcentreerd, DROOG en leesbaar te houden wanneer u met dummy-gegevens omgaat. Dat is een behoorlijk solide prestatie in mijn boek.
Bedenk dat de definitie van 'bare-bones' in de fabriek bepalend is voor uw geestelijke gezondheid. Hoe meer fabrieksgegevens u in uw globale testruimte plaatst, hoe groter de kans dat u een vorm van onderhoudspijn ondervindt.
Voor uw unittests is Factory Girl niet nodig en wordt uw testsuite alleen maar vertraagd. Josh Clayton zou de eerste zijn die dit zou bevestigen en zou het de beste werkwijze aanbevelen om Factory Girl selectief en zo min mogelijk te gebruiken.
Accentsconagua