cranky 0.0.3 → 0.0.4

data/README.rdoc

@@ -27,13 +27,50 @@ Then in your spec_helper.rb ...
 The above assumes that you have created your factory methods in a file called my_factories.rb in the spec/factories directory.
 You can create as many different factory files as you want, just require them in the same way.
 
-== Usage Syntax
+== In a Nutshell
 
 Cranky steals its core syntax from Factory Girl...
 
   Factory.build(:user)                  # Build a user instance without saving
   Factory.create(:user)                 # Build and save a user instance
   Factory.build(:user, :name => "Ian")  # Override a default attribute value
+  Factory.attributes_for(:user)         # Return a set of valid attributes rather than the object
+
+Cranky allows you to build factories via std Ruby methods, like this...
+
+  # factories/my_factories.rb
+  class Cranky          # Your factory must use the Cranky class
+
+    # Simple factory method to create a user instance, you would call this via Factory.build(:user)
+    def user
+      # Define attributes via a hash, generate the values any way you want
+      define :name    => "Jimmy",               
+             :email   => "jimmy#{n}@home.com",   # An 'n' counter method is available to help make things unique
+             :role    => :user,
+             :address => default_address         # Call your own helper methods to wire up your associations
+    end
+
+    # Easily create variations via the inherit helper, callable via Factory.build(:admin)
+    def admin
+      inherit(:user, :role => :admin)
+    end
+
+    # Return a default address if it already exists, or call the address factory to make one
+    def default_address
+      @default_address ||= create(:address) 
+    end
+
+    # Alternatively loose the DSL altogether and define the factory yourself, still callable via Factory.build(:address)
+    def address
+      a = Address.new
+      a.street = "192 Broadway"
+      a.city = options[:city] || "New York"   # You can get any caller overrides via the options hash
+      a                                       # Only rule is the method must return the generated object 
+    end
+
+  end
+
+= Details
 
 == Define Your Factories
 
@@ -52,8 +89,10 @@ So for example to create a simple user factory...
 
     # Simple factory method to create a user instance, you would call this via Factory.build(:user)
     def user
-      u = User.new
-      u.name = options[:name] || "Jimmy"  # Use the passed in name if present, or the default
+      u       = User.new
+      u.name  = options[:name] || "Jimmy"                 # Use the passed in name if present, or the default
+      u.email = options[:email] || "jimmy#{n}@home.com"   # Give each user a unique email address
+      u.role  = options[:role] || :user
       u
     end
 
@@ -61,37 +100,50 @@ So for example to create a simple user factory...
 
 Now of course you are working in straight Ruby here, so you can extend this any way you want as long as you follow the above rules. 
 
-For example here it is with the capability to automatically create a default account association...
+For example here it is with the capability to automatically create a default address association...
 
   # factories/my_factories.rb
   class Cranky
 
-    # Return the default account if it already exists, or call the account factory to make one
-    def default_account
-      @default_account ||= create(:account) 
+    # Return the default address if it already exists, or call the address factory to make one
+    def default_address
+      @default_address ||= create(:address) 
     end
 
     def user
-      u = User.new
-      u.name = options[:name] || "Jimmy"
-      u.account = default_account
+      u         = User.new
+      u.name    = options[:name] || "Jimmy"
+      u.email   = options[:email] || "jimmy#{n}@home.com"
+      u.role    = options[:role] || :user
+      u.address = default_address
       u
     end
 
-    ... # Create the account factory in the same way
+    ... # Create the address factory in the same way
 
   end
 
-Quite often the database will be cleared between tests however the instance variable in the factory will not necessarily be reset which could lead to problems if the tests check for the associated record in the database.
+Quite often the database will be cleared between tests but the instance variable in the factory will not necessarily be reset which could lead to problems if the tests check for the associated record in the database.
 So a nice tip is to implement default associations like this (assuming you're using Rails)...
 
-  # Return the default account if it already exists, or call the account factory to make one
-  def default_account
-    # If the default account exists, but has been cleared from the database...
-    if @default_account && !Account.exists?(@default_account.id)
-      @default_account = nil
-    end
-    @default_account ||= create(:account) 
+  # Return the default address if it already exists, or call the address factory to make one
+  def default_address
+    # If the default address exists, but has been cleared from the database...
+    @default_address = nil if @default_address && !Account.exists?(@default_address.id)
+    @default_address ||= create(:address) 
+  end
+
+You can pass additional arguments to your factories via the overrides hash...
+
+  Factory.build(:user, :new_address => true)
+
+  def user
+    u         = User.new
+    u.name    = options[:name] || "Jimmy"
+    u.email   = options[:email] || "jimmy#{n}@home.com"
+    u.role    = options[:role] || :user
+    u.address = options[:new_address] ? create(:address) : default_address
+    u
   end
 
 == Helpers
@@ -104,19 +156,23 @@ Most of your factories are likely to simply define a list of mimimum attribute v
 
   # The user factory re-written using the define helper
   def user
-    define :name => "Jimmy",
-           :account => default_account
+    define :name    => "Jimmy",
+           :email   => "jimmy#{n}@home.com",
+           :role    => :user,
+           :address => default_address
   end
 
 Note that you don't have to worry about handling the overrides here, they will be applied automatically if present, just define the defaults.
 
-The best thing about this is that there are no pesky blocks to worry about. The define argument is just a regular hash, you have complete freedom to choose how you generate the values to be passed into it.
+The best thing about this is that there are no pesky blocks to worry about. The define argument is just a regular hash, you have complete freedom to choose how to generate the values to be passed into it.
 
 The define method will return the object, you can grab this for additional manipulation as you would expect...
 
   def user
-    u = define :name => "Jimmy",
-               :account => default_account
+    u = define :name    => "Jimmy",
+               :email   => "jimmy#{n}@home.com",
+               :role    => :user,
+               :address => default_address
     u.do_something
     u               # Remember to return it at the end
   end
@@ -125,9 +181,11 @@ If for any reason you want to have your factory method named differently from th
 
   # Called via Factory.create(:jimmy)
   def jimmy
-    define :class => :user,
-           :name => "Jimmy",
-           :account => default_account
+    u = define :class   => :user, 
+               :name    => "Jimmy",
+               :email   => "jimmy#{n}@home.com",
+               :role    => :user,
+               :address => default_address
   end
 
 === Inherit
@@ -136,24 +194,18 @@ You can inherit from other factories via the inherit method. So for example to c
 
   # Called via Factory.create(:admin)
   def admin
-    inherit(:user, :account => admin_account)  # Pass in any attribute overrides you want
+    inherit(:user, :role => :admin)  # Pass in any attribute overrides you want
   end
 
 === Unique Attributes (n)
 
 If you want to generate unique attributes you can call the n method which will automatically increment the next time it is called.
-For example to give each user a unique name...
-
-  def user
-    define :name => "Jimmy#{n}",
-           :account => default_account
-  end
 
 Note that every time n is called it will increment, it does not implement a unique counter per attribute.
 
 === Reset
 
-Reset all instance variables in the factory. This may be useful to run between tests depending on your factory logic...
+Clear all instance variables in the factory. This may be useful to run between tests depending on your factory logic...
 
   before(:each) do
     Factory.reset
@@ -169,7 +221,7 @@ Note that this relies on the instance having a valid? method, so in practice thi
 
 === Attributes For
 
-Returns the attributes that would be applied for a given factory...
+Returns the attributes that would be applied by a given factory method...
 
   valid_attributes = Factory.attributes_for(:user)
 
@@ -182,4 +234,6 @@ Want any? Feel free to let me know.
 == Thanks
 
 Cranky was inspired by factory_girl[http://github.com/thoughtbot/factory_girl] and miniskirt[http://gist.github.com/273579].
+
 Thanks to both.
+

data/lib/cranky.rb

@@ -1,6 +1,6 @@
 class Cranky
 
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 
 #  Dir.glob("#{File.expand_path(File.dirname(__FILE__))}/*.rb").each do |file|
 #    require file
@@ -66,7 +66,7 @@ class Cranky
       item = get_constant(attrs[:class] ? attrs[:class] : @what.last).new
       final_attrs.delete(:class)
       final_attrs.each do |attr, value|
-        item.send("#{attr}=", value)
+        item.send("#{attr}=", value) if item.respond_to?("#{attr}=")
       end
       item
     end

data/spec/cranky_spec.rb

@@ -72,6 +72,12 @@ describe Cranky do
       error = true 
     end
     error.should == true
+    Factory.debug = false
+  end
+
+  it "should allow arguments to be passed in the overrides hash" do
+    Factory.build(:user).argument_received.should == nil
+    Factory.build(:user, :argument_supplied => true).argument_received.should == true
   end
   
 end

data/spec/spec_helper.rb

@@ -8,6 +8,7 @@ class User
   attr_accessor :role
   attr_accessor :email
   attr_accessor :unique
+  attr_accessor :argument_received
 
   def save
     @saved = true
@@ -46,11 +47,13 @@ class Cranky
   end
 
   def user_by_define
-    define :class => :user, 
-           :name => "Fred",
-           :role => :user,
-           :unique => "value#{n}",
-           :email => "fred@home.com"
+    u = define :class => :user, 
+               :name => "Fred",
+               :role => :user,
+               :unique => "value#{n}",
+               :email => "fred@home.com"
+    u.argument_received = true if options[:argument_supplied]
+    u
   end
   alias :user :user_by_define
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Stephen McGinty