fixture_replacement 3.0.1

data/MIT_LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008-2009 Scott Taylor (smtlaissezfaire) <scott@railsnewbie.com>
+
+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 OR COPYRIGHT
+HOLDERS 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.

data/README.rdoc

@@ -0,0 +1,154 @@
+= FixtureReplacement (version 3.0.1)
+
+== What is FixtureReplacement
+
+FixtureReplacement is a Rails[http://rubyonrails.org/] plugin that provides a simple way to
+quickly populate your test database with model objects without having to manage multiple,
+brittle fixture files. You can easily set up complex object graphs (with models which
+reference other models) and add new objects on the fly.
+
+Not only can FixtureReplacement make your test data easier to maintain, it can also help
+to make your tests and specs much more readable and intention-revealing by allowing you
+to omit extraneous details and focus only on the attributes that are important for a
+particular behaviour. It works well with both RSpec[http://rspec.rubyforge.org/] and
+Test::Unit[http://www.ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit.html].
+
+== What's new since 2.0:
+
+* default_* is gone in favor of new_*.
+* Cyclic dependencies are no longer an issue.  The "overrides hash" (the hash passed to new_* or create_*) can now be processed.
+
+See CHANGELOG.rdoc + test suite for further changes.
+
+== Installation
+
+Install the plugin:
+
+  git://github.com/smtlaissezfaire/fixturereplacement.git
+
+=== Using it with RSpec
+
+Add the following to your <tt>spec/spec_helper.rb</tt> file, in the configuration section:
+
+  Spec::Runner.configure do |config|
+    config.include FixtureReplacement
+  end
+
+=== Using it with Test::Unit
+
+Add the following to your <tt>test/test_helper.rb</tt> file:
+
+  class Test::Unit::TestCase
+    include FixtureReplacement
+  end
+
+== How to use FixtureReplacement
+
+=== Defining default attributes
+
+At the heart of FixtureReplacement is the <tt>db/example_data.rb</tt> file where you
+define the default attributes for each of your test models. This example shows the default
+attributes for a user:
+
+  module FixtureReplacement
+
+    attributes_for :user do |u|
+      password = random_string
+
+      u.value                  = "a value",
+      u.other                  = "other value",
+      u.another                = random_string,     # random string 10 characters long
+      u.one_more               = random_string(15), # 15 characters long
+      u.password               = password,
+      u.password_confirmation  = password,
+      u.associated_object      = new_bar            # expects attributes_for :bar to be setup
+    end
+
+  end
+
+Note that:
+
+- A 'random_string' method is provided for attributes whose exact value isn't important; this means you can
+  create multiple, unique model instances
+- you can perform arbitrary set-up and execute any Ruby code prior to returning the hash
+  (as shown here where a <tt>password</tt> is generated and then used for both the <tt>:password</tt> and
+  <tt>:password_confirmation</tt> attributes)
+- a <tt>new_modelname</tt> method is automatically provided that allows you to set up dependent
+  model objects (in this case an instance of the <tt>Bar</tt> model)
+
+=== Available methods
+
+Based on the above definition FixtureReplacement makes the following methods available:
+
+- <tt>random_string</tt>: generates a random string as shown above
+- <tt>new_user</tt>: equivalent to <tt>User.new</tt> with the attributes for the user.
+- <tt>create_user</tt>: equivalent to <tt>User.create!</tt> with the user's attributes.
+- <tt>valid_user_attributes</tt>: returns a hash of the user's attributes including associations, specified in db/example_data.rb.
+
+=== Overriding attributes
+
+Overrides of specific attributes can be performed as follows:
+
+  new_user(:thing => "overridden")
+  create_user(:thing => "overridden")
+
+Overrides can also be used with associations:
+
+  scott = create_user(:username => "scott")
+  post = create_post(:user => scott)
+
+
+=== attr_protected / attr_accessible
+
+In the case that the model has an attr_protected field, FixtureReplacement
+will assign the field as if it wasn't protected, which is convenient for testing:
+
+  class User < ActiveRecord::Base
+    attr_protected :admin_status
+  end
+
+  user = create_user(:username => "scott", :admin_status => true)
+  user.admin_status # => true
+
+=== Validate your fixtures (thanks Fixjour)
+
+Validate your fixture definitions after including it in the spec helper or test helper:
+
+==== spec_helper.rb:
+
+  Spec::Runner.configuration do |config|
+    config.include FixtureReplacement
+  end
+
+  FixtureReplacement.validate!
+
+==== test_helper.rb
+
+  class Test::Unit::TestCase
+    include FixtureReplacement
+  end
+
+  FixtureReplacement.validate!
+
+=== Using FixtureReplacement within <tt>script/console</tt>
+
+  $ ./script/console
+  Loading development environment
+  >> include FR
+  => Object
+  >> create_user
+  => #<User id: 1, crypted_password: "521faec1c095..." ...>
+
+= Philosophy & Disadvantages
+
+See philosophy_and_bugs.rdoc
+
+= Contributors, Contributions, & BUGS
+
+See contributions.rdoc
+
+== License
+
+This software is dual licensed under the MIT and the GPLv3 Licenses (it's your pick).
+
+Copyright 2007-2009 Scott Taylor / smtlaissezfaire[http://github.com/smtlaissezfaire] (scott@railsnewbie.com)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+
+Dir.glob("rake_tasks/**/*.rb").each do |file|
+  require file
+end
+
+desc 'Default: run unit tests (specs + tests).'
+task :default => [:spec, :test]

data/TODO.rdoc

@@ -0,0 +1,22 @@
+
+== Bugs
+
+- Allow 'extend FixtureReplacement' as well as 'include FixtureReplacement'
+- Two levels down of inherited fixture bug
+
+== Features
+
+- Validate fixtures.  Steal any other good ideas from FactoryGirl, Fixjour, Machinist, etc.
+- Support SEQUEL & Datamapper.  Make it ORM independent
+
+== Code Cleanup
+
+- Remove ugly method_added hack
+
+== ETC
+
+- Store old version 2 README
+- Update website info
+- Update with github info
+- Register Lighthouse project
+- Remove TODOs from Rubyforge tracker (http://rubyforge.org/tracker/?group_id=4556)

data/VERSION

@@ -0,0 +1 @@
+3.0.1

data/contributions.rdoc

@@ -0,0 +1,48 @@
+= Bugs & Contributing Code
+
+If you would like to change how this software works, report a bug, or request a feature, use
+the github issue tracker[http://github.com/smtlaissezfaire/fixturereplacement/issues].
+
+== Running the Specs/Tests for FixtureReplacement
+
+You will need rspec (version 1.0.8 or later) to run the specs, as well as the sqlite3-ruby gem
+(and sqlite3 installed):
+
+  % gem install rspec sqlite3-ruby
+
+cd into the fixture_replacement plugin directory:
+
+  % cd vendor/plugins/fixture_replacement
+
+Then run with <tt>rake</tt>
+
+  % rake
+
+There are also some tests for test/unit.  These mainly serve as regressions, but you are free
+to run them as well.
+
+== Test Coverage
+
+specdocs[http://replacefixtures.rubyforge.org/specdoc.html], rcov[http://replacefixtures.rubyforge.org/rcov/index.html], flog[http://replacefixtures.rubyforge.org/flog.txt]
+
+= Patches, Contributions:
+
+Thanks to the following for making this software better:
+
+- Greg Bluvshteyn (http://www.m001.net), for bugging me about the naming, and making the wonderful suggestion to use the plugin in the console.
+- Simon Peter Nicholls
+  - default_* methods can take a hash (applied in rev. 11)
+- Wincent Colaiuta (http://wincent.com/) - Huge Thanks
+  - patch for spelling error in comments (applied in revision 31)
+  - patch for specs with sqlite3 (applied in revision 35)
+  - patch to ignore attr_protected in mass assignment (applied in revision 57)
+  - Most of this README Documentation (applied in revision 62)
+  - patch: silencing sqlite3 in memory creation of table output (applied in revision 72)
+  - doc patch: typo fix in readme
+- Carl Porth
+  - patch: classify should be camelize (applied in revision 74)
+- LinoJ, JW, Matthew Bass, Andy Watts, Dave Spurr
+  - bug reports
+- Bryan Helmkamp: Feedback on back associating models.
+- Pat Nakajima: Wonderful ideas from Fixjour.  Elimination of default_* methods in favor
+  of new_* methods.  validation of new instances.

data/etc/bug_reports/2007_09_28_linoj.txt

@@ -0,0 +1,51 @@
+Hi Scott,
+
+I'm wondering if you have insight into this or if I should go ask somewhere else.
+
+I installed 2 plug-in today,
+first fixture_replacement plugin
+and been using it successfully
+
+Then I installed validates_email_format_of plugin
+http://code.dunae.ca/validates_email_format_of
+
+and added this to my User model
+  validates_email_format_of :email
+
+then script/server wont start
+When I comment out this line, it's fine
+
+Here's the error:
+
+$ script/server
+=> Booting Mongrel (use 'script/server webrick' to force WEBrick)
+=> Rails application starting on http://0.0.0.0:3000
+=> Call with -d to detach
+=> Ctrl-C to shutdown server
+** Starting Mongrel listening at 0.0.0.0:3000
+** Starting Rails with development environment...
+Exiting
+/Users/jonathan/rails/reviewramp/vendor/plugins/fixture_replacement/init.rb:9:in `evaluate': Error in FixtureReplacement Plugin: undefined method `validates_email_format_of' for #<Class:0x241cc68> (RuntimeError)
+        from ./script/../config/../vendor/rails/railties/lib/rails/plugin/loader.rb:107:in `evaluate'
+        from /Users/jonathan/rails/reviewramp/vendor/rails/activesupport/lib/active_support/core_ext/kernel/reporting.rb:11:in `silence_warnings'
+        from ./script/../config/../vendor/rails/railties/lib/rails/plugin/loader.rb:107:in `evaluate'
+        from ./script/../config/../vendor/rails/railties/lib/rails/plugin/loader.rb:24:in `load'
+        from /Users/jonathan/rails/reviewramp/vendor/rails/railties/lib/initializer.rb:183:in `load_plugins'
+        from ./script/../config/../vendor/rails/railties/lib/rails/plugin/locator.rb:16:in `each'
+        from ./script/../config/../vendor/rails/railties/lib/rails/plugin/locator.rb:16:in `each'
+        from /Users/jonathan/rails/reviewramp/vendor/rails/railties/lib/initializer.rb:182:in `load_plugins'
+         ... 31 levels...
+        from /Users/jonathan/rails/reviewramp/vendor/rails/activesupport/lib/active_support/dependencies.rb:495:in `require'
+        from /Users/jonathan/rails/reviewramp/vendor/rails/railties/lib/commands/server.rb:39
+        from script/server:3:in `require'
+        from script/server:3
+
+
+I havent tried it in a different project (without fixture_replacement) but looks like yours is getting the blame... :)
+
+(I'm on Rails Edge)
+
+-- linoj
+
+
+

data/etc/google_analytics

@@ -0,0 +1,6 @@
+<script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
+</script>
+<script type="text/javascript">
+_uacct = "UA-3080808-2";
+urchinTracker();
+</script>

data/etc/patches/2007_09_14_default_model_name_with_arguments.diff

@@ -0,0 +1,26 @@
+Index: lib/fixture_replacement/fixture_replacement.rb
+===================================================================
+--- lib/fixture_replacement/fixture_replacement.rb  (revision 1151)
++++ lib/fixture_replacement/fixture_replacement.rb  (working copy)
+@@ -40,7 +40,8 @@
+       def merge_unevaluated_method(obj, method_for_instantiation, hash={})
+         hash.each do |key, value|
+           if value.kind_of?(::FixtureReplacement::DelayedEvaluationProc)
+-            hash[key] = obj.send("#{method_for_instantiation}_#{value.call}")
++            model_name, args = value.call
++            hash[key] = obj.send("#{method_for_instantiation}_#{model_name}", args)
+           end
+         end
+       end
+@@ -63,9 +64,9 @@
+       default_method = "default_#{model_name}".to_sym
+
+       fixture_module.module_eval do
+-        define_method(default_method) do
++        define_method(default_method) do |*args|
+           ::FixtureReplacement::DelayedEvaluationProc.new do
+-            model_as_string
++            [model_as_string, args[0]]
+           end
+         end
+       end

data/etc/patches/2007_10_14_active_record_specs.diff

@@ -0,0 +1,396 @@
+Index: spec/fixture_replacement/fixture_replacement_spec.rb
+===================================================================
+--- spec/fixture_replacement/fixture_replacement_spec.rb  (revision 31)
++++ spec/fixture_replacement/fixture_replacement_spec.rb  (working copy)
+@@ -1,53 +1,52 @@
+-
+ require File.dirname(__FILE__) + "/../spec_helper"
++require 'activesupport'
++require 'activerecord'
+
+-# It would be better if these things were actual mocks/stubs
+-# of ActiveRecord Classes.
+-class ARBase
+-  class << self
+-    def create!(h={})
+-      obj = new(h)
+-      obj.save!
+-      obj
+-    end
++ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database  => ':memory:'
++class User < ActiveRecord::Base
++  belongs_to :gender
++  attr_accessor :saved
++  def save!
++    @saved = true
+   end
++end
++class Gender < ActiveRecord::Base
++  attr_accessor :saved
++  def save!
++    @saved = true
++  end
++end
++class Alien < ActiveRecord::Base
++  belongs_to :gender
++end
+
+-  def initialize(hash={})
+-    @hash = hash
++ActiveRecord::Schema.define do
++  create_table :users do |t|
++    t.string  :key
++    t.string  :other_key
++    t.integer :gender_id
+   end
+-
+-  attr_reader :hash
+-
+-  def gender # this would be a has_many call in rails
+-    17
++  create_table :genders do |t|
++    t.string  :sex
+   end
+-
+-  def save!
+-    @saved = true
++  create_table :aliens do |t|
++    t.integer :gender_id
+   end
+-
+-  def saved?
+-    @saved || false
+-  end
+-
+ end
+
+-class User < ARBase; end
+-class Gender < ARBase; end
+-class Alien < ARBase; end
++include FixtureReplacement
+
+-
+ module FixtureReplacement
+   describe Generator, "creation" do
+     before :each do
+       @generator = Generator.new("user")
+     end
+
+-    it "should take a lowecase-model name as it's paramaters" do
++    it "should take a lowercase-model name as its paramaters" do
+       @generator.model_name.should == "user"
+     end
+
+-    it "should be able to take tell the name of model in  string" do
++    it "should be able to take tell the name of model in string" do
+       @generator.model_name.to_s.should == "user"
+     end
+
+@@ -84,16 +83,11 @@
+       FixtureReplacement.module_eval do
+         def user_attributes
+           {
+-            :key => :val
++            :key => "val"
+           }
+         end
+       end
+       @generator = Generator.new("user")
+-
+-      @class = Class.new do
+-        include FixtureReplacement
+-      end
+-      @instance = @class.new
+     end
+
+     it "should generate the method default_user in the module" do
+@@ -103,45 +97,34 @@
+
+     it "should return a ::FixtureReplacement::DelayedEvaluationProc" do
+       @generator.generate_default_method
+-      @instance.default_user.class.should == ::FixtureReplacement::DelayedEvaluationProc
++      default_user.class.should == ::FixtureReplacement::DelayedEvaluationProc
+     end
+
+     it %(should return the special proc, which in turn should return an array
+         of the name of the model ('user') if no params were given) do
+       @generator.generate_default_method
+-      @instance.default_user.call.should == ["user"]
++      default_user.call.should == ["user"]
+     end
+
+     it %(should return the special proc, which in turn should return an array
+         of the name of the model ('user') and the params given) do
+       @generator.generate_default_method
+-      @instance.default_user({:some => :hash}).call.should == ["user", {:some => :hash}]
++      default_user({:key => "hash"}).call.should == ["user", {:key => "hash"}]
+     end
+   end
+
+   describe Generator, "generate_create_method for User when user_attributes is defined (and valid)" do
+-    before :each do
+-      User.class_eval do
+-        def save!
+-          @saved = true
+-        end
+-      end
+-
++    before :each do
+       FixtureReplacement.module_eval do
+         def user_attributes
+           {
+-            :key => :val
++            :key => "val"
+           }
+         end
+       end
+       @generator = Generator.new("user")
+       @generator.generate_new_method
+       @generator.generate_create_method
+-
+-      @class = Class.new do
+-        include FixtureReplacement
+-      end
+-      @instance = @class.new
+     end
+
+     it "should generate the method create_user in the module" do
+@@ -150,38 +133,32 @@
+
+     it "should generate the method create_user which takes one parameter - a hash" do
+       @generator.generate_create_method
+-      @instance.create_user({:key => :value})
++      create_user({:key => "value"})
+     end
+
+     it "should return a user" do
+       @generator.generate_create_method
+-      @instance.create_user.should be_a_kind_of(User)
++      create_user.should be_a_kind_of(User)
+     end
+
+-    it "should return a user which has been saved (with create!)" do
++    it "should return a user which has been saved (with save!)" do
+       @generator.generate_create_method
+-      @instance.create_user.should be_saved
++      create_user.saved.should == true
+     end
+
+     it "should overwrite the hash parameters given" do
+       @generator.generate_create_method
+-      @instance.create_user(:key => :value).hash.should == {:key => :value}
++      create_user(:key => "value").key.should == "value"
+     end
+
+     it "should not overwrite the default hash parameters, if none are given" do
+       @generator.generate_create_method
+-      @instance.create_user.hash.should == {:key => :val}
++      create_user.key.should == "val"
+     end
+   end
+
+   describe Generator, "generate_create_method for User when user_attributes is defined (and valid)" do
+     before :each do
+-      User.class_eval do
+-        def save!
+-          @saved = true
+-        end
+-      end
+-
+       FixtureReplacement.module_eval do
+         def user_attributes
+           {
+@@ -203,60 +180,40 @@
+       @generator = Generator.new("user")
+       @generator.generate_new_method
+       @generator.generate_create_method
+-
+-      @class = Class.new do
+-        include FixtureReplacement
+-      end
+-      @instance = @class.new
+     end
+
+     it "should save the associated join models which have a default_* method (if it is not overwritten)" do
+-      created_user = @instance.create_user
+-      created_gender = created_user.hash[:gender]
+-      created_gender.hash.should == {:sex => "Male"}
++      created_gender = create_user.gender
++      created_gender.sex.should == "Male"
+     end
+
+     it "should not save the associated join model, but not as the default_* method (in the case that it is overwritten)" do
+-      created_user = @instance.create_user(:gender => Gender.create!(:sex => "Female"))
+-      created_gender = created_user.hash[:gender]
+-      created_gender.hash.should == {:sex => "Female"}
++      created_user = create_user(:gender => Gender.create!(:sex => "Female"))
++      created_gender = created_user.gender
++      created_gender.sex.should == "Female"
+     end
+
+-    it "should call Gender.create! when the default_gender method is evaluated by default_gender" do
+-      gender = Gender.new
+-      Gender.should_receive(:create!).and_return gender
+-      @instance.create_user
++    it "should call Gender.save! when the default_gender method is evaluated by default_gender" do
++      create_user.gender.saved.should == true
+     end
+
+-    it "should not call Gender.create! if the default_gender is overwritten by another value (say, a string)" do
+-      Gender.should_not_receive(:create!)
+-      @instance.create_user(:gender => "a string")
++    it "should not call Gender.save! if the default_gender is overwritten by another value" do
++      create_user(:gender => Gender.new).gender.saved.should_not == true
+     end
+   end
+
+   describe Generator, "generate_create_method for User when user_attributes is defined, but not valid" do
+-    before :each do
+-      User.class_eval do
+-        def save!
+-          @saved = true
+-        end
+-      end
+-
++    before :each do
+       FixtureReplacement.module_eval do
+         def user_attributes
+           {
+-            :key => :val
++            :key => "val"
+           }
+         end
+       end
+       @generator = Generator.new("user")
+       @generator.generate_new_method
+       @generator.generate_create_method
+-
+-      @class = Class.new do
+-        include FixtureReplacement
+-      end
+-      @instance = @class.new
+     end
+
+     it "should generate the method create_user in the module" do
+@@ -265,22 +222,9 @@
+
+     it "should generate the method create_user which takes one parameter - a hash" do
+       @generator.generate_create_method
+-      @instance.create_user({:key => :value})
++      create_user({:key => "value"})
+     end
+
+-    it "should raise an error with a user which has been saved (with create!)" do
+-      User.class_eval do
+-        def save!
+-          raise
+-        end
+-      end
+-
+-      @generator.generate_create_method
+-      lambda {
+-        @instance.create_user
+-      }.should raise_error
+-    end
+-
+   end
+
+   describe Generator, "generate_new_method for User when user_attributes is defined" do
+@@ -290,7 +234,7 @@
+       FixtureReplacement.module_eval do
+         def user_attributes
+           {
+-            :key => :val
++            :key => "val"
+           }
+         end
+
+@@ -302,12 +246,6 @@
+       end
+       @generator = Generator.new("user")
+       @generator.generate_new_method
+-
+-      @class = Class.new do
+-        include FixtureReplacement
+-      end
+-      @instance = @class.new
+-
+     end
+
+     it "should respond to new_user in the module" do
+@@ -316,19 +254,21 @@
+
+     it "should return a new User object" do
+       User.stub!(:new).and_return @user
+-      @instance.new_user.should == @user
++      new_user.should == @user
+     end
+
+     it "should return a new User object with the keys given in user_attributes" do
+-      @instance.new_user.hash.should == {:key => :val}
++      new_user.key.should == "val"
+     end
+
+     it "should over-write the User's hash with any hash given to new_user" do
+-      @instance.new_user(:key => :other_value).hash.should == {:key => :other_value}
++      new_user(:key => "other_value").key.should == "other_value"
+     end
+
+     it "should add any hash key-value pairs which weren't previously given in user_attributes" do
+-      @instance.new_user(:other_key => :other_value).hash.should == {:key => :val, :other_key => :other_value}
++      u = new_user(:other_key => "other_value")
++      u.key.should == "val"
++      u.other_key.should == "other_value"
+     end
+   end
+
+@@ -365,39 +305,30 @@
+
+       @generator = Generator.new("alien")
+       @generator.generate_new_method
+-
+-      @class = Class.new do
+-        include FixtureReplacement
+-      end
+-      @instance = @class.new
+     end
+
+     it "should evaluate any of the default_* methods before returning (if no over-writing key is given)" do
+-      new_user = @instance.new_user
+-      new_gender = new_user.hash[:gender]
+-      new_gender.hash.should == {:sex => "Male"}
++      new_gender = new_user.gender
++      new_gender.sex.should == "Male"
+     end
+
+     it %(should evaluate any of the default_* methods before returning, with the hash params given to default_* method) do
+-      new_alien = @instance.new_alien
+-      new_gender = new_alien.hash[:gender]
+-      new_gender.hash.should == {:sex => "unknown"}
++      new_gender = new_alien.gender
++      new_gender.sex.should == "unknown"
+     end
+
+     it "should call Gender.save! when the default_gender method is evaluated by default_gender" do
+-      Gender.should_receive(:create!)
+-      @instance.new_user
++      new_user.gender.saved.should == true
+     end
+
+-    it "should not call Gender.new if the default_gender is overwritten by another value (say, a string)" do
+-      Gender.should_not_receive(:create!)
+-      @instance.new_user(:gender => "a string")
++    it "should not call Gender.new if the default_gender is overwritten by another value" do
++      new_user(:gender => Gender.new).gender.saved.should_not == true
+     end
+
+     it "should be able to overwrite a default_* method" do
+-      new_user = @instance.new_user(:gender => Gender.create!(:sex => "Female"))
+-      created_gender = new_user.hash[:gender]
+-      created_gender.hash.should == {:sex => "Female"}
++      new_user = new_user(:gender => Gender.create!(:sex => "Female"))
++      created_gender = new_user.gender
++      created_gender.sex.should == "Female"
+     end
+   end
+