mack-data_factory

Mack-data_factory

== Summary Utility to create faux data.

== Installation sudo gem install mack-data_factory

== Using The Gem

** Constructing Factory For each model that you want to produce, you will need to define a factory class.
Let's say that I have 2 models: Item and User, and Item belongs to user. So the factories will look like the following:

class ItemFactory
    include Mack::Data::Factory
    
    field :title, :default => "MyItem"
    association :owner_id, {:user => 'id'}
end

class UserFactory
    include Mack::Data::Factory
    
    field :username, :default => "planters", :length => 25, :content => :alpha
    field :password, :default => "roastedPeanuts", :immutable => true
end

So, the 2 classes above defined the factory for item and user. As you can see, each factory will need to explicitly list all the fields that it will populate, and for each field, you can define rules on how the content is generated.

Important: For each field defined in the factory, you will need to make sure that there's a corresponding setter method in the model class (e.g. Item class is required to have title= and owner_id=).

For numeric content, you can specify the start number and end number, and the content generator will generate a random number between that range.

For all fields, you can specify :immutable to true, which means for all instances created, the default value for that field will not change.

To define a default value for a field, you use the :default options (e.g. field :username, :default => 'planters')

Supported content types:

Strings and Numbers

• :alpha --> alphabets. rules: [:length, :min_length, :max_length]
• :alphanumeric --> alphabets and number. rules: same as :alpha
• :numeric --> numbers [optional, because if the field's default value is number, its content type will automatically set to numeric)

Time and Money

• :time --> generate random time object. rules: [:start_time, :end_time]. It will generate random time between the given start and end time if available, otherwise it'll generate random time between 'now' and 1 day from 'now'
• :money --> generate random amount of money. rules: [:min, :max]. It will generate random money amount (of BigDecimal type) between the given min and max amount.

Internet related content

• :email --> generate random email address
• :username --> generate random username
• :domain --> generate random domain name

Name related info

• :firstname --> generate first name
• :lastname --> generate last name
• :name --> generate full name

Address related info

• :city --> generate city name
• :streetname --> generate street name
• :state --> generate state. rules: [:country --> :us or :uk, :abbr --> true if you want a abbreviated state name (us only)]
• :zipcode --> generate zipcode. rules: [:country --> :us or :uk]
• :phone --> generate phone number

Company info

• :company --> generate company name. rules: [:include_bs --> include sales tag line] example: field, "", :content => :company, :include_bs => true could generate something like: Fadel-Larkin monetize cross-media experiences

** Association class ItemFactory include Mack::Data::Factory

field :title, :default => "MyItem"
association :owner_id, {:user => 'id'}, :first

end

class UserFactory include Mack::Data::Factory

field :username, :default => "planters", :length => 25, :content => :alpha
field :password, :default => "roastedPeanuts", :immutable => true

end

In the above example, the ItemFactory define the owner_id field as an association to {:user => 'id'}. When the factory is run, it will generate value for owner_id as 'the id of the user #x'. You can also pass in rules to define which instance of user that the id will be retrieved from. The rules are: :first, :last, :random, and :spread. The default is :spread. Definition of the association rules: :first --> always associate with the first object that this object belongs to. If there are 10 users [id = 0 - 10], then the item will always get associated with user #0 (i.e. item's owner_id always == 0) :last --> always associate with the last object that this object belongs to. If there are 10 users [id = 0 - 10], then the item will always get associated with user #10 (i.e. item's owner_id always == 9) :random --> always associate with the Nth object that this object belongs to (and N is random). If there are 10 users [id = 0 - 10], then the item will get associated with user #n (i.e. item's owner_id == rand(10)) :spread --> spread the association. If there are 3 users [id = 0 - 2], then the items' association will be spread out (i.e. 6 items will have id--sequentially--[0, 1, 2, 0, 1, 2])

** Pumping Data

To create objects from the factory is very easy, just call create method on that factory and tell it how many items you want to create.

Note that if your factory has dependencies to other model (like the ItemFactory in the example), then make sure you have created the model that it's depending on first.

The create method will return constructed objects. If there's only 1 instance constructed, then it will return that object; if more than one then it will return an array of objects.

** Creating Factories Execution Chain In some instances, you may want to create an execution chain of a bunch of factories. In the above example: the UserFactory has to be run before the ItemFactory.
If that's the case, you can create factory chain that you can execute later.

factories(:my_cool_factory) do
    UserFactory.create(1)
    ItemFactory.create(1000)
end

Once you have defined a named factory chain, you can execute that any time, by calling:

run_factories(:my_cool_factory)

** Scoping In other instances, you may want different settings in the factory for different test scope. You can achieve this by doing the following:

class UserFactory
    include Mack::Data::Factory

    field :username, :default => "planters", :length => 25, :content => :alpha
    field :password, :default => "roastedPeanuts", :immutable => true
    
    scope_for(:long_username) do
        field :username, :default => "planters", :length => 128, :content => :alpha
    end
end

The above example defined a scoping for "long_username", which you can use by calling: UserFactory.create(100, :long_username)

When a scope is defined and called, the field defined in the block will overwrite the default field listing in that class. Scopes in the factory is independent to each other, and one scope cannot affect the others.

** Custom content generator In some cases, the default content generators that are provided by this framework don't fit your needs. To accommodate this situation, you can provide a custom content generator for each field you defined by passing in a proc.

Example: I'm creating a users, but I don't want the username be totally random, instead I want it to use the default name I provide, and append 0-n at the end of the string to represent the Nth user in the list. Here's how to accomplish that: class UserFactory include Mack::Data::Factory

    field :username, :default => "planters" do |def_value, rules, index| 
        "#{def_value}#{index}"
    end
    field :password, :default => "roastedPeanuts", :immutable => true
    
end

== Contact Please mail bugs, suggestions, and patches to [e-mail]

== Copyright Notices Copyright (c) 2008 Darsono Sutedja

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.