remarkable_activerecord 3.1.9 → 3.1.10

data/spec/association_matcher_spec.rb

@@ -1,671 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'association_matcher' do
-  include ModelBuilder
-
-  describe 'belong_to' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :projects_count => :integer }
-      define_model :company, columns
-      define_model :super_company, columns
-
-      columns = options.delete(:model_columns) || { :company_id => :integer, :company_type => :string }
-      @model = define_model :project, columns do
-        belongs_to :company, options
-        belongs_to :unknown
-        belongs_to :accountable, :polymorphic => true
-      end
-
-      belong_to :company
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'belong to company'
-
-        matcher.class_name('Company')
-        matcher.description.should == 'belong to company with class name "Company"'
-
-        matcher.foreign_key('company_id')
-        matcher.description.should == 'belong to company with class name "Company" and with foreign key "company_id"'
-
-        matcher = belong_to(:company).dependent(:destroy)
-        matcher.description.should == 'belong to company with dependent :destroy'
-
-        matcher.readonly
-        matcher.description.should == 'belong to company with dependent :destroy and with readonly records'
-
-        matcher.as(:interface)
-        matcher.description.should == 'belong to company with dependent :destroy, through the polymorphic interface :interface, and with readonly records'
-
-        matcher.counter_cache('projects_count')
-        matcher.description.should == 'belong to company with dependent :destroy, through the polymorphic interface :interface, ' <<
-                                      'with readonly records, and with counter cache "projects_count"'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = belong_to('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to whatever, but the association does not exist'
-      end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = have_one('company')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one company, got Project records belong to company'
-      end
-
-      it 'should set klass_exists? message' do
-        define_and_validate
-        matcher = belong_to('unknown')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to unknown, but the association class does not exist'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:model_columns => {})
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "company_id" to exist on "projects", but does not'
-      end
-
-      it 'should set polymorphic_exists? message' do
-        matcher = define_and_validate(:model_columns => { :company_id => :integer }, :polymorphic => true)
-        matcher.polymorphic.matches?(@model)
-        matcher.failure_message.should == 'Expected "projects" to have "company_type" as column, but does not'
-      end
-
-      it 'should set counter_cache_exists? message' do
-        matcher = define_and_validate(:association_columns => {}, :counter_cache => true)
-        matcher.counter_cache.matches?(@model)
-        matcher.failure_message.should == 'Expected "companies" to have "projects_count" as column, but does not'
-      end
-
-      it 'should set options_matches? message when polymorphic is given' do
-        matcher = define_and_validate(:polymorphic => false)
-        matcher.polymorphic.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to company with options {:polymorphic=>"true"}, got {:polymorphic=>"false"}'
-      end
-
-      it 'should set options_matches? message when counter_cache is given' do
-        matcher = define_and_validate(:counter_cache => true)
-        matcher.counter_cache(false).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to company with options {:counter_cache=>"false"}, got {:counter_cache=>"true"}'
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
-        it { should belong_to(:company) }
-        it { should_not belong_to(:unknown) }
-        it { should_not belong_to(:project) }
-        it { should_not have_one(:company) }
-        it { should_not have_many(:company) }
-      end
-
-      describe 'with class name option' do
-        it { should define_and_validate.class_name('Company') }
-        it { should define_and_validate(:class_name => 'SuperCompany').class_name('SuperCompany') }
-
-        it { should_not define_and_validate.class_name('SuperCompany') }
-        it { should_not define_and_validate(:class_name => 'Company').class_name('SuperCompany') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:company_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :model_columns => { :association_id => :integer }).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:model_columns => { :association_id => :integer }).foreign_key(:association_id) }
-      end
-
-      describe 'with dependent option' do
-        it { should define_and_validate(:dependent => :delete).dependent(:delete) }
-        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
-
-        it { should_not define_and_validate(:dependent => :delete).dependent(:destroy) }
-        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete) }
-      end
-
-      describe 'with counter_cache option' do
-        # Checks whether fk exists or not
-        it { should define_and_validate(:counter_cache => :association_count,
-                                        :association_columns => { :association_count => :integer }).counter_cache(:association_count) }
-
-        it { should_not define_and_validate(:counter_cache => :association_count).counter_cache(:association_count) }
-        it { should_not define_and_validate(:association_columns => { :association_count => :integer }).counter_cache(:association_count) }
-      end
-
-      describe "with polymorphic option" do
-        before(:each){ define_and_validate(:model_columns => {:accountable_id => :integer, :accountable_type => :string}) }
-        it { should belong_to(:accountable).polymorphic }
-      end
-
-      create_optional_boolean_specs(:readonly, self)
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-      create_optional_boolean_specs(:polymorphic, self)
-      create_optional_boolean_specs(:counter_cache, self)
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:validate => true, :readonly => true) }
-
-      should_belong_to :company
-      should_belong_to :company, :readonly    => true
-      should_belong_to :company, :validate    => true
-      should_belong_to :company, :class_name  => "Company"
-      should_belong_to :company, :foreign_key => :company_id
-
-      should_belong_to :company do |m|
-        m.readonly
-        m.validate
-        m.class_name = "Company"
-        m.foreign_key = :company_id
-      end
-
-      should_not_belong_to :unknown
-      should_not_belong_to :project
-      should_not_have_one  :company
-      should_not_have_many :companies
-
-      should_not_belong_to :company, :readonly    => false
-      should_not_belong_to :company, :validate    => false
-      should_not_belong_to :company, :class_name  => "Anything"
-      should_not_belong_to :company, :foreign_key => :anything_id
-    end
-  end
-
-  describe 'have_and_belong_to_many' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
-      define_model :label
-      define_model :super_label
-
-      columns = options.delete(:association_columns) || [ :label_id, :project_id ]
-      create_table(options.delete(:association_table) || :labels_projects) do |table|
-        columns.each { |name| table.column(name, :integer) }
-      end
-
-      @model = define_model :project, options.delete(:model_columns) || {} do
-        has_and_belongs_to_many :labels, options
-      end
-
-      have_and_belong_to_many :labels
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'have and belong to many labels'
-
-        matcher.class_name('Label')
-        matcher.description.should == 'have and belong to many labels with class name "Label"'
-
-        matcher.foreign_key('label_id')
-        matcher.description.should == 'have and belong to many labels with class name "Label" and with foreign key "label_id"'
-
-        matcher = have_and_belong_to_many(:labels).autosave
-        matcher.description.should == 'have and belong to many labels autosaving associated records'
-
-        matcher.uniq
-        matcher.description.should == 'have and belong to many labels with unique records and autosaving associated records'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = have_and_belong_to_many('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have and belong to many whatever, but the association does not exist'
-      end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = have_many('labels')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many labels, got Project records have and belong to many labels'
-      end
-
-      it 'should set join_table_exists? message' do
-        matcher = define_and_validate(:association_table => 'another_name')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected join table "labels_projects" to exist, but does not'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:association_columns => [])
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "labels_projects", but does not'
-      end
-
-      it 'should set options_matches? message' do
-        matcher = define_and_validate(:uniq => false)
-        matcher.uniq.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have and belong to many labels with options {:uniq=>"true"}, got {:uniq=>"false"}'
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
-        it { should have_and_belong_to_many(:labels) }
-        it { should_not belong_to(:label) }
-        it { should_not have_one(:label) }
-        it { should_not have_many(:labels) }
-        it { should_not have_and_belong_to_many(:companies) }
-      end
-
-      describe 'with class name option' do
-        it { should define_and_validate.class_name('Label') }
-
-        it { should define_and_validate(:class_name => 'SuperLabel',
-                                        :association_table => 'projects_super_labels').class_name('SuperLabel') }
-
-        it { should_not define_and_validate.class_name('SuperLabel') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:project_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :association_columns => [ :association_id ]).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:association_columns => [ :association_id ]).foreign_key(:association_id) }
-      end
-
-      describe 'with join table option' do
-        it { should define_and_validate.join_table('labels_projects') }
-        it { should define_and_validate(:join_table => 'my_table',
-                                        :association_table => 'my_table').join_table('my_table') }
-
-        it { should define_and_validate(:join_table => :my_table,
-                                        :association_table => :my_table).join_table(:my_table) }
-
-        it { should_not define_and_validate.join_table('projects_labels') }
-
-        it { should_not define_and_validate(:join_table => 'my_table',
-                                            :association_table => 'another_table').join_table('my_table') }
-        it { should_not define_and_validate(:join_table => 'another_table',
-                                            :association_table => 'my_table').join_table('my_table') }
-        it { should_not define_and_validate(:join_table => 'my_table',
-                                            :association_table => 'my_table').join_table('another_table') }
-      end
-
-      create_optional_boolean_specs(:uniq, self)
-      create_optional_boolean_specs(:readonly, self)
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:validate => true, :readonly => true) }
-
-      should_have_and_belong_to_many :labels
-      should_have_and_belong_to_many :labels, :readonly    => true
-      should_have_and_belong_to_many :labels, :validate    => true
-      should_have_and_belong_to_many :labels, :class_name  => "Label"
-      should_have_and_belong_to_many :labels, :foreign_key => :project_id
-
-      should_have_and_belong_to_many :labels do |m|
-        m.readonly
-        m.validate
-        m.class_name "Label"
-        m.foreign_key :project_id
-      end
-
-      should_not_have_and_belong_to_many :companies
-      should_not_have_one  :label
-      should_not_have_many :labels
-
-      should_not_have_and_belong_to_many :labels, :readonly    => false
-      should_not_have_and_belong_to_many :labels, :validate    => false
-      should_not_have_and_belong_to_many :labels, :class_name  => "Anything"
-      should_not_have_and_belong_to_many :labels, :foreign_key => :anything_id
-    end
-  end
-
-  describe 'have_many' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :task_id => :integer, :project_id => :integer, :todo_id => :integer }
-      define_model :task, columns
-      define_model :todo, columns
-
-      define_model :project_task, columns do
-        belongs_to :task
-        belongs_to :project
-        belongs_to :todo
-      end unless options.delete(:skip_source)
-
-      @model = define_model :project, options.delete(:model_columns) || {} do
-        has_many :project_tasks unless options.delete(:skip_through)
-        has_many :tasks, options
-      end
-
-      have_many :tasks
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'have many tasks'
-
-        matcher.class_name('Task')
-        matcher.description.should == 'have many tasks with class name "Task"'
-
-        matcher.foreign_key('task_id')
-        matcher.description.should == 'have many tasks with class name "Task" and with foreign key "task_id"'
-
-        matcher = have_many(:tasks).autosave
-        matcher.description.should == 'have many tasks autosaving associated records'
-
-        matcher.uniq
-        matcher.description.should == 'have many tasks with unique records and autosaving associated records'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = have_many('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many whatever, but the association does not exist'
-      end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = have_and_belong_to_many('tasks')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have and belong to many tasks, got Project records have many tasks'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:association_columns => {})
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "tasks", but does not'
-      end
-
-      it 'should set through_exists? message' do
-        matcher = define_and_validate(:through => :project_tasks, :skip_through => true)
-        matcher.through(:project_tasks).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, through association does not exist'
-      end
-
-      it 'should set source_exists? message' do
-        matcher = define_and_validate(:through => :project_tasks, :skip_source => true)
-        matcher.through(:project_tasks).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, source association does not exist'
-      end
-
-      it 'should set options_matches? message when dependent is given' do
-        matcher = define_and_validate(:dependent => :destroy)
-        matcher.dependent(:nullify).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many tasks with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
-      end
-
-      it 'should set options_matches? message when source is given' do
-        matcher = define_and_validate(:through => :project_tasks, :source => :todo)
-        matcher.through(:project_tasks).source(:task).matches?(@model)
-        matcher.failure_message.should match(/:source=>"task"/)
-        matcher.failure_message.should match(/:source=>"todo"/)
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
-        it { should have_many(:tasks) }
-        it { should_not belong_to(:task) }
-        it { should_not have_one(:task) }
-        it { should_not have_and_belong_to_many(:tasks) }
-      end
-
-      describe 'with class name option' do
-        before(:each){ define_model :super_task, :project_id => :integer }
-
-        it { should define_and_validate.class_name('Task') }
-        it { should define_and_validate(:class_name => 'SuperTask').class_name('SuperTask') }
-
-        it { should_not define_and_validate.class_name('SuperTask') }
-        it { should_not define_and_validate(:class_name => 'SuperTask').class_name('Task') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:project_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-      end
-
-      describe 'with dependent option' do
-        it { should define_and_validate(:dependent => :delete_all).dependent(:delete_all) }
-        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
-
-        it { should_not define_and_validate(:dependent => :delete_all).dependent(:destroy) }
-        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete_all) }
-      end
-
-      describe 'with through option' do
-        it { should define_and_validate(:through => :project_tasks) }
-        it { should define_and_validate(:through => :project_tasks).through(:project_tasks) }
-
-        it { should_not define_and_validate(:through => :project_tasks).through(:something) }
-        it { should_not define_and_validate(:through => :project_tasks, :skip_through => true).through(:project_tasks) }
-      end
-
-      describe 'with source option' do
-        it { should define_and_validate(:through => :project_tasks, :source => :todo).source(:todo) }
-        it { should_not define_and_validate(:through => :project_tasks, :source => :todo).source(:task) }
-      end
-
-      create_optional_boolean_specs(:uniq, self)
-      create_optional_boolean_specs(:readonly, self)
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:through => :project_tasks, :readonly => true, :validate => true) } 
-
-      should_have_many :tasks
-      should_have_many :tasks, :readonly => true
-      should_have_many :tasks, :validate => true
-      should_have_many :tasks, :through => :project_tasks
-
-      should_have_many :tasks do |m|
-        m.readonly
-        m.validate
-        m.through = :project_tasks
-      end
-
-      should_not_have_many :tasks, :readonly => false
-      should_not_have_many :tasks, :validate => false
-      should_not_have_many :tasks, :through => :another_thing
-    end
-  end
-
-  describe 'have_one' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :manager_id => :integer, :project_id => :integer, :boss_id => :integer }
-      define_model :manager, columns
-      define_model :boss,    columns
-
-      define_model :project_manager, columns do
-        belongs_to :manager
-        belongs_to :project
-        belongs_to :boss
-      end unless options.delete(:skip_source)
-
-      @model = define_model :project, options.delete(:model_columns) || {} do
-        has_many :project_managers unless options.delete(:skip_through)
-        has_one  :manager, options
-        has_one  :unknown
-      end
-
-      have_one :manager
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'have one manager'
-
-        matcher.class_name('Manager')
-        matcher.description.should == 'have one manager with class name "Manager"'
-
-        matcher.foreign_key('manager_id')
-        matcher.description.should == 'have one manager with class name "Manager" and with foreign key "manager_id"'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = have_one('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one whatever, but the association does not exist'
-      end
-
-      it 'should set klass_exists? message' do
-        define_and_validate
-        matcher = have_one('unknown')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one unknown, but the association class does not exist'
-      end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = belong_to('manager')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to manager, got Project records have one manager'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:association_columns => {})
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "managers", but does not'
-      end
-
-      it 'should set through_exists? message' do
-        matcher = define_and_validate(:through => :project_managers, :skip_through => true)
-        matcher.through(:project_managers).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, through association does not exist'
-      end
-
-      it 'should set source_exists? message' do
-        matcher = define_and_validate(:through => :project_managers, :skip_source => true)
-        matcher.through(:project_managers).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, source association does not exist'
-      end
-
-      it 'should set options_matches? message when dependent is given' do
-        matcher = define_and_validate(:dependent => :destroy)
-        matcher.dependent(:nullify).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one manager with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
-      end
-
-      it 'should set options_matches? message when source is given' do
-        matcher = define_and_validate(:through => :project_managers, :source => :boss)
-        matcher.through(:project_managers).source(:manager).matches?(@model)
-        matcher.failure_message.should match(/:source=>"manager"/)
-        matcher.failure_message.should match(/:source=>"boss"/)
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
-        it { should have_one(:manager) }
-        it { should_not have_one(:unknown) }
-        it { should_not belong_to(:manager) }
-        it { should_not have_many(:managers) }
-        it { should_not have_and_belong_to_many(:managers) }
-      end
-
-      describe 'with class name option' do
-        before(:each){ define_model :super_manager, :project_id => :integer }
-
-        it { should define_and_validate.class_name('Manager') }
-        it { should define_and_validate(:class_name => 'SuperManager').class_name('SuperManager') }
-
-        it { should_not define_and_validate.class_name('SuperManager') }
-        it { should_not define_and_validate(:class_name => 'SuperManager').class_name('Manager') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:project_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-      end
-
-      describe 'with dependent option' do
-        it { should define_and_validate(:dependent => :delete).dependent(:delete) }
-        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
-
-        it { should_not define_and_validate(:dependent => :delete).dependent(:destroy) }
-        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete) }
-      end
-
-      describe 'with through option' do
-        it { should define_and_validate(:through => :project_managers) }
-        it { should define_and_validate(:through => :project_managers).through(:project_managers) }
-
-        it { should_not define_and_validate(:through => :project_managers).through(:something) }
-        it { should_not define_and_validate(:through => :project_managers, :skip_through => true).through(:project_managers) }
-      end
-
-      describe 'with source option' do
-        it { should define_and_validate(:through => :project_managers, :source => :boss).source(:boss) }
-        it { should_not define_and_validate(:through => :project_managers, :source => :boss).source(:manager) }
-      end
-
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:through => :project_managers, :validate => true) } 
-
-      should_have_one :manager
-      should_have_one :manager, :validate => true
-      should_have_one :manager, :through => :project_managers
-
-      should_have_one :manager do |m|
-        m.validate
-        m.through = :project_managers
-      end
-
-      should_not_have_one :unknown
-      should_not_have_one :manager, :validate => false
-      should_not_have_one :manager, :through => :another_thing
-    end
-  end
-
-end