fixjour 0.5.1 → 0.5.2

data/README.textile

@@ -0,0 +1,236 @@
+h1. fixjour
+
+Another fixture replacement. Gets you some methods (@new_*@, @create_*@ and
+@valid_*_attributes@) methods and some confidence.
+
+"View the RDoc":http://gitrdoc.com/nakajima/fixjour/tree/master (still underway, but has a bit of helpful stuff)
+
+"Recommend Me on the Working with Rails":http://www.workingwithrails.com/person/7973-pat-nakajima
+
+h2. Contribute
+
+Fixjour has some developer dependencies. Install them as shown below,
+and run rake to make sure the tests pass. Then dive in!
+
+<pre>
+fixjour:$ gem build fixjour.gemspec
+fixjour:$ sudo gem install --development fixjour
+fixjour:$ rake
+Do the tests pass?
+</pre>
+h2. The focus of this project is liberation through constraints.
+
+It uses the bits of object mother systems that worked well for
+me in the past, and actively discourages the bits that have caused
+me pain.
+
+The constraints:
+
+h4. One builder per model
+
+If you try to define a builder more than once per model, you'll
+run into a @Fixjour::RedundantBuilder@ error. One builder per
+model decreases confusion.
+
+h4. No redundant object creation methods
+
+If you try to define a method that's already been defined by
+a Fixjour builder, you'll run into a @Fixjour::RedundantBuilder@
+error. If you find the need to alter the behavior of a builder
+for a particular set of tests, you should just wrap the creation
+methods defined by Fixjour, preferably with a name that describes
+how the new method is different from the Fixjour method.
+
+h4. Processing the overrides hash is bad
+
+If you want to mess with the overrides hash that can be passed
+into any of the creation methods, you must use the @process@
+method (see below). To enforce this, the @delete@ method is actually
+private for the overrides hash.
+
+h2. What it gets you:
+
+With this setup:
+
+<pre>
+Fixjour do
+  define_builder(Person) do |klass, overrides|
+    klass.new(:name => 'Pat', :age => 22)
+  end
+end
+
+include Fixjour
+</pre>
+
+You get:
+
+h3. @new_person(overrides={})@
+
+The @new_person@ method basically just returns the result
+of your builder block, which should *always return an unsaved
+instance of the model class*. You can pass it overrides in a
+hash like so: @new_person(:name => nil)@.
+
+h3. @create_person(overrides={})@
+
+The @create_person@ method calls @new_person@, passing in any
+overrides you pass it, calls @save!@ on the result, and returns
+the saved object.
+
+h3. @valid_person_attributes(overrides={})@
+
+The @valid_person_attributes@ returns a hash of valid person
+attributes that are derived from the @new_person@ method, and
+ideal for things like testing controllers. It can also take
+attribute override options like so: @valid_person_attributes(:name => nil)@.
+
+h2. Usage:
+
+You specify builder sets for your ActiveRecord models in a
+@Fixjour@ block using the @define_builder@ helper, which can
+be used in one of two ways:
+
+h3. Using a builder block
+
+Pass @define_builder@ a model class for which you want a new set
+of creation methods, and a block which returns a new valid
+model object. The block will be passed two arguments: a proxy
+object for your class, and an overrides hash. If you call @new@
+on the class proxy, it will return a new instance of the class,
+with whatever attributes you specify as defaults. It will also
+automatically merge any override options in all of the methods
+generated by Fixjour.
+
+Example:
+
+<pre>
+define_builder(Person) do |klass, overrides|
+  klass.new(:name => "Pat", :age => 22)
+end
+</pre>
+
+If you want to process an option in the overrides hash, you can use
+the @process@ method:
+
+<pre>
+define_builder(Person) do |klass, overrides|
+  overrides.process(:child) do |is_child|
+    overrides[:age] = 14 if is_child
+  end
+  
+  klass.new(:name => "Pat", :age => 22)
+end
+
+# the default
+person = new_person
+person.age # => 22
+
+# using the override
+person = new_person(:child => true)
+person.age  # => 14
+</pre>
+
+In the above example, the @:child@ key will be deleted from the @overrides@
+hash and made available as the @is_child@ block argument where you can handle
+things accordingly.
+
+*Note:* The @delete@ method is private on the overrides hash passed into the
+builder block. This is meant to encourage you to only use the @process@ method
+instead. Why? First, because processing the overrides hash is a smell. Deal
+with it. Second, using the @process@ method provides some indication to readers
+that you're screwing with the overrides hash, and that's a good thing.
+
+h4. @attr_protected@ fields
+
+If you have fields that cannot be mass-assigned, use the @protected@ helper:
+
+  define_builder(Article) do |klass, overrides|
+    klass.protected :author
+    klass.new :title => "The title", :body => "good", :author => new_user
+  end
+
+If you use the @protected@ helper to declare @attr_protected@ fields, you can
+then treat them the same as any other field in your test methods.
+
+h4. With Associations
+
+To specify an associated object, you can call that object's @new_*@ method:
+
+<pre>
+Fixjour do
+  define_builder(Post) do |klass, overrides|
+    klass.new(:name => 'a post', :body => 'texted')
+  end
+  
+  define_builder(Comment) do |klass, overrides|
+    klass.new(:body => 'Oh ok!', :post => new_post)
+  end
+end
+
+include Fixjour
+
+new_comment.post.name # => 'a post'
+</pre>
+
+Note that it's never a good idea to use a @create_*@ method in a
+build block.
+
+h3. Verifying your setups
+
+Fixjour requires more work on your part, so it also includes a way
+to verify that your creation methods are behaving the way they should.
+Call @Fixjour.verify!@ to ensure the following things:
+
+# Creation methods are returning valid objects by default.
+# @new_*@ methods are returning new records.
+# @new_*@ and @create_*@ methods return instances of the correct class.
+
+h3. Recommended usage with RSpec and Cucumber
+
+If you want to use Fixjour with RSpec and Cucumber you probably want to avoid adding the builder methods onto Object directly. To do this you should first create a file where your Fixjour builder definitions can live. Say for example you put it at spec/fixjour_builders.rb. To take advantage of these builders from RSpec use the following code in your spec_helper.rb:
+
+<pre>
+require File.expand_path(File.dirname(__FILE__) + "/fixjour_builders.rb")
+
+Spec::Runner.configure do |config|
+  config.include(Fixjour) # This will add the builder methods to your ExampleGroups and not pollute Object
+  ...
+end
+</pre>
+
+To use the same builders in Cucumber you simply need to include Fixjour into your World object from features/support/env.rb:
+
+<pre>
+require File.expand_path(File.dirname(__FILE__) +'/../../spec/fixjour_builders.rb')
+World { |world| world.extend(Fixjour) }
+</pre>
+
+Be sure to do this after you define your World object. So, if you are using Rails you should include Fixjour after you require 'cucumber/rails/world'.
+
+In *Cucumber version 0.2.3.2 and later* you need to pass in a module to the World method to extend it:
+
+<pre>
+require File.expand_path(File.dirname(__FILE__) +'/../../spec/fixjour_builders.rb')
+World(Fixjour)
+</pre>
+
+(See the Cucumber::StepMother#World RDoc or "http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world":http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.)
+
+h4. Contributors
+
+* "Pat Maddox":http://github.com/pat-maddox - Sparked the original idea and fixed my bugs
+* "Ben Mabey":http://github.com/bmabey - Added docs and fixed my bugs
+* "Aaron Quint":http://github.com/quirkey - Pointed out valid attrs problem and fixed my bugs
+
+h4. TODO
+
+* There should be a @Builder@ class.
+
+h4. "Join the mailing list.":http://groups.google.com/group/fixjour
+
+I've talked to smart people who like these instead:
+
+* "fixturereplacement":http://github.com/smtlaissezfaire/fixturereplacement/tree/master
+* "factory girl":http://github.com/thoughtbot/factory_girl/tree
+
+(c) Copyright 2008 Pat Nakajima, released under MIT License.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new("spec:rcov") do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec

data/fixjour.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fixjour}
+  s.version = "0.5.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pat Nakajima"]
+  s.date = %q{2008-12-29}
+  s.email = %q{patnakajima@gmail.com}
+  s.files = ["README.textile", "Rakefile", "fixjour.gemspec", "lib/core_ext/hash.rb", "lib/core_ext/object.rb", "lib/fixjour.rb", "lib/fixjour/builder.rb", "lib/fixjour/builders.rb", "lib/fixjour/counter.rb", "lib/fixjour/define.rb", "lib/fixjour/definitions.rb", "lib/fixjour/deprecation.rb", "lib/fixjour/errors.rb", "lib/fixjour/generator.rb", "lib/fixjour/merging_proxy.rb", "lib/fixjour/overrides_hash.rb", "lib/fixjour/redundant_check.rb", "lib/fixjour/verify.rb", "spec/builder_spec.rb", "spec/define_spec.rb", "spec/dev.rip", "spec/edge_cases_spec.rb", "spec/fixjour_spec.rb", "spec/merging_proxy_spec.rb", "spec/overrides_hash_spec.rb", "spec/spec_helper.rb", "spec/verify_spec.rb"]
+  s.homepage = %q{http://github.com/nakajima/fixjour}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Object creation methods everyone already has}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_development_dependency(%q<faker>, [">= 0"])
+      s.add_development_dependency(%q<acts_as_fu>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<faker>, [">= 0"])
+      s.add_dependency(%q<acts_as_fu>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<faker>, [">= 0"])
+    s.add_dependency(%q<acts_as_fu>, [">= 0"])
+  end
+end

data/lib/fixjour.rb

@@ -1,6 +1,6 @@
 $LOAD_PATH << File.dirname(__FILE__)
 
-require 'active_record'
+require 'activerecord'
 require 'core_ext/hash'
 require 'core_ext/object'
 require 'fixjour/merging_proxy'

data/lib/fixjour/merging_proxy.rb

@@ -21,7 +21,7 @@ module Fixjour
       attrs = defaults.merge(@overrides)
       accessible, inaccessible = partition(attrs)
 
-      returning @klass.new(accessible) do |instance|
+      @klass.new(accessible).tap do |instance|
         inaccessible.each do |key,val|
           instance.send("#{key}=", val)
         end

data/spec/builder_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Fixjour::Builder do
+  def new_builder(*args)
+    Fixjour::Builder.new(*args)
+  end
+
+  it "takes a class" do
+    new_builder(Foo).klass.should == Foo
+  end
+
+  it "can have a name specified" do
+    new_builder(Foo, :as => :fooz).name.should == 'fooz'
+  end
+
+  it "can infer name" do
+    new_builder(Foo).name.should == 'foo'
+  end
+
+  it "can infer nested name" do
+    class Foo; class Bar; end end
+    new_builder(Foo::Bar).name.should == 'foo_bar'
+  end
+end

data/spec/define_spec.rb

@@ -0,0 +1,55 @@
+require 'spec/spec_helper'
+
+describe Fixjour, '.define' do
+  include Fixjour
+
+  before(:each) do
+    Fixjour.builders.clear
+  end
+
+  it "defines a valid builder" do
+    Fixjour.define(Person) do |person|
+      person.first_name = 'Pat'
+    end
+
+    person = new_person
+    person.first_name.should == 'Pat'
+
+    new_person(:first_name => 'Larry').first_name.should == 'Larry'
+
+    created_person = create_person
+    created_person.should_not be_new_record
+    created_person.first_name.should == 'Pat'
+  end
+
+  it "allows 'scenario' builders from class name" do
+    Fixjour.define(Person) do |person|
+      person.first_name = 'Pat'
+    end
+
+    Fixjour.define(:person_with_last_name, :from => Person) do |person|
+      person.last_name = 'Nakajima'
+    end
+
+    new_person_with_last_name.first_name.should == 'Pat'
+    new_person_with_last_name.last_name.should == 'Nakajima'
+  end
+
+  it "allows 'scenario' builders from other scenario" do
+    Fixjour.define(Person) do |person|
+      person.first_name = 'Pat'
+    end
+
+    Fixjour.define(:person_with_last_name, :from => Person) do |person|
+      person.last_name = 'Nakajima'
+    end
+
+    Fixjour.define(:person_with_bar_id, :from => :person_with_last_name) do |person|
+      person.bar_id = 123
+    end
+
+    new_person_with_bar_id.first_name.should == 'Pat'
+    new_person_with_bar_id.last_name.should == 'Nakajima'
+    new_person_with_bar_id.bar_id.should == 123
+  end
+end

data/spec/dev.rip

@@ -0,0 +1,4 @@
+git://github.com/rspec/rspec.git
+git://github.com/btakita/rr.git
+git://github.com/nakajima/acts_as_fu.git
+faker

data/spec/edge_cases_spec.rb

@@ -0,0 +1,33 @@
+require 'spec/spec_helper'
+
+module Mister
+  class Manager
+    def initialize(attrs)
+      @attributes = attrs
+    end
+
+    def valid?
+      true
+    end
+  end
+end
+
+describe Fixjour, 'edge cases' do
+  include Fixjour
+
+  describe "namespaced models" do
+    before(:each) do
+      Fixjour.builders.clear
+    end
+
+    it "allows name to be specified" do
+      Fixjour do
+        define_builder(Mister::Manager, :as => :manager) do |klass|
+          klass.new
+        end
+      end
+
+      new_manager.should be_kind_of(Mister::Manager)
+    end
+  end
+end

data/spec/fixjour_spec.rb

@@ -0,0 +1,555 @@
+require 'spec/spec_helper'
+
+describe Fixjour do
+  before(:each) do
+    define_all_builders
+  end
+
+  describe "when Fixjour is not included" do
+    it "does not have access to creation methods" do
+      self.should_not respond_to(:new_foo)
+    end
+  end
+
+  describe "counter" do
+    include Fixjour
+
+    before(:each) do
+      Fixjour::Counter.reset
+    end
+
+    it "provides default counter" do
+      counter.should == 1
+      counter.should == 2
+      counter.should == 3
+    end
+
+    it "should increase" do
+      counter(:foo).should == 1
+      counter(:foo).should == 2
+      counter(:foo).should == 3
+    end
+
+    it "should allow multiple counters" do
+      counter(:foo).should == 1
+      counter(:foo).should == 2
+      counter(:bar).should == 1
+      counter(:foo).should == 3
+      counter(:bar).should == 2
+    end
+
+    it "should allow resetting a single counter" do
+      counter(:foo).should == 1
+      counter(:bar).should == 1
+      Fixjour::Counter.reset :foo
+      counter(:foo).should == 1
+      counter(:bar).should == 2
+    end
+  end
+
+  describe "when Fixjour is included" do
+    include Fixjour
+
+    describe "new_* methods" do
+      it "generates new_[model] method" do
+        proc {
+          new_foo
+        }.should_not raise_error
+      end
+
+      it "should raise a helpful error when the class can't be found" do
+        lambda {
+          Fixjour { define_builder(WhereOWhereAmI) }
+        }.should raise_error(NameError)
+      end
+
+      context "passing a builder block with one arg" do
+        context "when it returns a model object" do
+          before(:each) do
+            Fixjour.remove(Foo)
+            Fixjour do
+              define_builder(Foo) do |klass|
+                klass.new(:name => 'Foo Namery', :bar => new_bar)
+              end
+            end
+          end
+
+          it "returns a new model object" do
+            new_foo.should be_kind_of(Foo)
+          end
+
+          it "is a new record" do
+            new_foo.should be_new_record
+          end
+
+          it "returns defaults specified in block" do
+            new_foo.name.should == 'Foo Namery'
+          end
+
+          it "merges overrides" do
+            new_foo(:name => nil).name.should be_nil
+          end
+
+          it "is indifferent" do
+            new_foo('name' => nil).name.should be_nil
+          end
+
+          it "can be made invalid associated objects" do
+            new_foo(:bar => nil).should_not be_valid
+          end
+
+          it "allows access to other builders" do
+            bar = new_bar
+            mock(self).new_bar { bar }
+            new_foo.bar.should == bar
+          end
+        end
+
+        context "when passed a hash" do
+          before(:each) do
+            Fixjour.remove(Foo)
+            Fixjour do
+              define_builder(Foo, :name => 'Foo Namery')
+            end
+          end
+
+          it "returns a new model object" do
+            new_foo.should be_kind_of(Foo)
+          end
+
+          it "is a new record" do
+            new_foo.should be_new_record
+          end
+
+          it "returns defaults specified in block" do
+            new_foo.name.should == 'Foo Namery'
+          end
+
+          it "merges overrides" do
+            new_foo(:name => nil).name.should be_nil
+          end
+        end
+
+        context "when it returns a hash" do
+          before(:each) do
+            Fixjour.remove(Foo)
+            Fixjour do
+              define_builder(Foo) do |overrides|
+                { :name => 'Foo Namery', :bar => new_bar }
+              end
+            end
+          end
+
+          it "returns a new model object" do
+            new_foo.should be_kind_of(Foo)
+          end
+
+          it "is a new record" do
+            new_foo.should be_new_record
+          end
+
+          it "returns defaults specified in block" do
+            new_foo.name.should == 'Foo Namery'
+          end
+
+          it "merges overrides" do
+            new_foo(:name => nil).name.should be_nil
+          end
+
+          it "can be made invalid associated objects" do
+            new_foo(:bar => nil).should_not be_valid
+          end
+
+          it "allows access to other builders" do
+            bar = new_bar
+            mock(self).new_bar { bar }
+            new_foo.bar.should == bar
+          end
+        end
+      end
+
+      context "passing a builder block with two args" do
+        before(:each) do
+          Fixjour.remove(Foo)
+          Fixjour do
+            define_builder(Foo) do |klass, overrides|
+              klass.new({ :name => 'Foo Namery', :bar => new_bar })
+            end
+          end
+        end
+
+        it "returns a new model object" do
+          new_foo.should be_kind_of(Foo)
+        end
+
+        it "is a new record" do
+          new_foo.should be_new_record
+        end
+
+        it "returns defaults specified in block" do
+          new_foo.name.should == 'Foo Namery'
+        end
+
+        it "merges overrides" do
+          new_foo(:name => nil).name.should be_nil
+        end
+
+        it "is indifferent" do
+          new_foo('name' => nil).name.should be_nil
+        end
+
+        it "can be made invalid associated objects" do
+          new_foo(:bar => nil).should_not be_valid
+        end
+
+        it "allows access to other builders" do
+          bar = new_bar
+          mock(self).new_bar { bar }
+          new_foo.bar.should == bar
+        end
+      end
+    end
+
+    describe "create_* methods" do
+      it "calls new_* method then saves the result" do
+        # mocking here to make sure it's still using the new_person helper
+        # as opposed to calling Foo.new again. We don't want to duplicate
+        # that sort of behavior
+        mock(foo = Object.new).save!
+        mock(self).new_foo { foo }
+
+        create_foo
+      end
+
+      context "declared with a block" do
+        it "saves the record" do
+          foo = create_foo
+          foo.should_not be_new_record
+        end
+
+        it "retains defaults" do
+          create_foo.name.should == 'Foo Namery'
+        end
+
+        it "still allows options override" do
+          create_foo(:name => "created").name.should == "created"
+        end
+      end
+
+      context "declared with a hash" do
+        it "saves the record" do
+          bazz = create_bazz
+          bazz.should_not be_new_record
+        end
+
+        it "retains defaults" do
+          create_bazz.name.should == 'Bazz Namery'
+        end
+
+        it "still allows options override" do
+          create_bazz(:name => "created").name.should == "created"
+        end
+      end
+    end
+
+    describe "valid_*_attributes" do
+      it "returns a hash containing the valid attributes specified in the builder" do
+        valid_foo_attributes[:name].should == new_foo.name
+      end
+
+      it "does not include attributes that aren't defined in the builder block" do
+        valid_foo_attributes.should_not have_key(:age)
+      end
+
+      it "allows overrides" do
+        valid_foo_attributes(:name => "as attr")[:name].should == "as attr"
+      end
+
+      it "is indifferent" do
+        valid_foo_attributes[:name].should == valid_foo_attributes['name']
+      end
+
+      it "overrides indifferently" do
+        valid_foo_attributes("name" => "as attr")[:name].should == "as attr"
+        valid_foo_attributes(:name => "as attr")["name"].should == "as attr"
+      end
+
+      describe "singular association ids" do
+        it "sets appropriate foreign keys" do
+          valid_foo_attributes[:bar].should be_nil
+          valid_foo_attributes[:bar_id].should_not be_nil
+        end
+
+        it "respects custom foreign keys" do
+          valid_foo_attributes[:owner].should be_nil
+          valid_foo_attributes[:person_id].should_not be_nil
+        end
+      end
+
+      describe "plural association ids" do
+        it "sets appropriate foreign keys" do
+          valid_bar_attributes[:people].should be_nil
+          valid_bar_attributes[:person_ids].should_not be_empty
+        end
+
+        it "leaves out blank keys" do
+          valid_bar_attributes.should_not have_key('foo_ids')
+        end
+      end
+
+      describe "returning new values every time" do
+        before(:each) do
+          FooBar.validates_uniqueness_of :name
+          create_foo_bar(valid_foo_bar_attributes)
+        end
+
+        it "returns new values every time" do
+          new_foo_bar(valid_foo_bar_attributes).should be_valid
+        end
+      end
+
+      context "declared with a hash" do
+        it "works the same way as builder block style" do
+          valid_bazz_attributes[:name].should == new_bazz.name
+        end
+      end
+    end
+
+    describe "Fixjour.builders" do
+      it "contains the classes for which there are builders" do
+        Fixjour.should have(5).builders
+        Fixjour.builders.values.map(&:klass).should include(Foo, Bar, Bazz)
+      end
+
+      context "when defining multiple builders for same class" do
+        it "raises RedundantBuilder error" do
+          proc {
+            Fixjour do
+              define_builder(Foo) { |overrides| Foo.new(:name => 'bad!') }
+            end
+          }.should raise_error(Fixjour::RedundantBuilder)
+        end
+      end
+
+      describe "redundancy checker" do
+        context "when :allow_redundancy is true" do
+          before(:each) do
+            Fixjour.builders.clear
+          end
+
+          it "doesn't blow up" do
+            proc {
+              Fixjour :allow_redundancy => true do
+                define_builder(Bar) { Bar.new }
+                define_builder(Bar) { Bar.new }
+              end
+            }.should_not raise_error
+          end
+
+          it "resets the settings when done" do
+            Fixjour :allow_redundancy => true do
+              define_builder(Bar) { Bar.new }
+              define_builder(Bar) { Bar.new }
+            end
+
+            proc {
+              Fixjour do
+                define_builder(Bar) { Bar.new }
+              end
+            }.should raise_error(Fixjour::RedundantBuilder)
+          end
+
+          it "can always allow redundancy" do
+            Fixjour do
+              allow_redundancy!
+              define_builder(Bar) { Bar.new }
+            end
+            proc {
+              Class.new {
+                include Fixjour
+                def new_bar(*args) end
+              }
+            }.should_not raise_error
+          end
+
+          it "can prohibit redundancy" do
+            Fixjour do
+              allow_redundancy!
+              prohibit_redundancy!
+              define_builder(Bar) { Bar.new }
+            end
+            proc {
+              Class.new {
+                include Fixjour
+                def new_bar(*args) end
+              }
+            }.should raise_error(Fixjour::RedundantBuilder)
+          end
+        end
+
+        describe "method_added hook" do
+          context "when it's already defined for the class" do
+            before(:each) do
+              @klass = Class.new do
+                def self.added_methods
+                  @added_methods ||= []
+                end
+
+                def self.method_added(name)
+                  added_methods << name
+                end
+
+                include Fixjour
+              end
+            end
+
+            it "does not lose old behavior" do
+              @klass.class_eval { def foo; :foo end }
+              @klass.added_methods.should include(:foo)
+            end
+
+            it "gets Fixjour behavior" do
+              foo = @klass.new.new_foo
+              foo.should be_kind_of(Foo)
+            end
+          end
+        end
+
+        context "when the method is redundant" do
+          it "raises RedundantBuilder for new_*" do
+            proc {
+              self.class.class_eval do
+                def new_foo(overrides={}); Foo.new end
+              end
+            }.should raise_error(Fixjour::RedundantBuilder)
+          end
+
+          it "raises RedundantBuilder for new_ when there's an underscore" do
+            proc {
+              self.class.class_eval do
+                def new_foo_bar(overrides={}); end
+              end
+            }.should raise_error(Fixjour::RedundantBuilder)
+          end
+
+          it "raises RedundantBuilder for create_*" do
+            proc {
+              self.class.class_eval do
+                def create_foo(overrides={}); Foo.new end
+              end
+            }.should raise_error(Fixjour::RedundantBuilder)
+          end
+
+          it "raises RedundantBuilder for valid_*_attributes" do
+            proc {
+              self.class.class_eval do
+                def valid_foo_attributes(overrides={}); end
+              end
+            }.should raise_error(Fixjour::RedundantBuilder)
+          end
+        end
+
+        context "when the method is not redundant" do
+          it "handles *similar* names" do
+            proc {
+              self.class.class_eval do
+                def new_foo_source(overrides={}); end
+                def choice_new_foo(overrides={}); end
+              end
+            }.should_not raise_error(Fixjour::RedundantBuilder)
+          end
+
+          it "does not raise error" do
+            proc {
+              self.class.class_eval do
+                def valid_nothing_attributes(overrides={}); Foo.new end
+              end
+            }.should_not raise_error
+          end
+        end
+      end
+    end
+
+    describe "a virtual attribute" do
+      before(:each) do
+        Fixjour.remove(Foo)
+        Foo.class_eval { attr_accessor :bizzle }
+        Fixjour do
+          define_builder(Foo) do |klass, overrides|
+            klass.new(:bizzle => 'fizzle')
+          end
+        end
+      end
+
+      it "gets preserved" do
+        new_foo.bizzle.should == 'fizzle'
+      end
+
+      it "is overrideable" do
+        new_foo(:bizzle => 'bliggety').bizzle.should == 'bliggety'
+      end
+    end
+
+    describe "protected attributes" do
+      before(:each) do
+        Fixjour.remove(Bar)
+        Bar.attr_protected :name
+        Fixjour do
+          define_builder(Bar) do |klass, overrides|
+            klass.protected :name
+            klass.new :name => "Protect me!"
+          end
+        end
+      end
+
+      it "returns default value" do
+        new_bar.name.should == "Protect me!"
+      end
+
+      it "can be overridden" do
+        new_bar(:name => 'pwnd').name.should == 'pwnd'
+      end
+    end
+
+    describe "processing overrides" do
+      before(:each) do
+        Fixjour.remove(Foo)
+      end
+
+      context "when the builder block has one arg" do
+        it "is raises DeprecatedMergeAttempt when #process is called" do
+          proc {
+            Fixjour.define_builder(Foo) do |overrides|
+              overrides.process(:alias) { |v| overrides[:name] = v }
+            end
+
+            new_foo
+          }.should raise_error(Fixjour::DeprecatedMergeAttempt)
+        end
+      end
+
+      context "when the builder block has two args" do
+        before(:each) do
+          Fixjour do
+            define_builder(Foo) do |klass, overrides|
+              overrides.process(:alias) do |value|
+                overrides[:name] = value
+              end
+
+              klass.new(:name => "El Nameo!")
+            end
+          end
+        end
+
+        it "returns a new Fixjour::OverridesHash" do
+          mock.proxy(Fixjour::OverridesHash).new(:alias => "Bart Simpson")
+          new_foo(:alias => "Bart Simpson")
+        end
+
+        it "merges overrides" do
+          new_foo(:alias => "Bart Simpson").name.should == "Bart Simpson"
+        end
+      end
+    end
+  end
+end