remarkable_activerecord 3.0.0

data/spec/have_index_matcher_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'have_index_matcher' do
+  include ModelBuilder
+
+  before(:each) do
+    @model = define_model :users, :table => lambda {|table|
+      table.string  :name,  :null => true
+      table.string  :email, :limit => '255', :default => 'jose.valim@gmail.com'
+    }
+
+    ActiveRecord::Base.connection.add_index :users, :name
+    ActiveRecord::Base.connection.add_index :users, :email, :unique => true
+    ActiveRecord::Base.connection.add_index :users, [:email, :name], :unique => true
+  end
+
+  describe 'messages' do
+
+    it 'should contain a description' do
+      @matcher = have_index(:name)
+      @matcher.description.should == 'have index for column(s) name'
+
+      @matcher.unique
+      @matcher.description.should == 'have index for column(s) name with unique values'
+    end
+
+    it 'should set index_exists? message' do
+      @matcher = have_index(:password)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected index password to exist on table users'
+    end
+
+    it 'should set is_unique? message' do
+      @matcher = have_index(:email, :unique => false)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected index on email with unique equals to false, got true'
+    end
+  end
+
+  describe 'matchers' do
+    it { should have_index(:name) }
+    it { should have_index(:email) }
+    it { should have_index([:email, :name]) }
+    it { should have_indices(:name, :email) }
+
+    it { should have_index(:name).unique(false) }
+    it { should have_index(:email).unique }
+
+    it { should_not have_index(:password) }
+    it { should_not have_index(:name).unique(true) }
+    it { should_not have_index(:email).unique(false) }
+  end
+
+  describe 'macros' do
+    should_have_index :name
+    should_have_index :email
+    should_have_index [:email, :name]
+    should_have_indices :name, :email
+
+    should_have_index :name, :unique => false
+    should_have_index :email, :unique => true
+
+    should_not_have_index :password
+    should_not_have_index :name, :unique => true
+    should_not_have_index :email, :unique => false
+  end
+end
+

data/spec/have_readonly_attributes_matcher_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'have_readonly_attributes' do
+  include ModelBuilder
+
+  def define_and_validate(options={})
+    @model = define_model :product, :title => :string, :category => :string do
+      attr_readonly :title, :category   if options[:readonly] == true
+      attr_readonly *options[:readonly] if options[:readonly].is_a?(Array)
+    end
+
+    have_readonly_attributes(:title, :category)
+  end
+
+  describe 'messages' do
+
+    it 'should contain a description' do
+      @matcher = have_readonly_attributes(:title, :category)
+      @matcher.description.should == 'make title and category read-only'
+    end
+
+    it 'should set is_readonly? message' do
+      @matcher = define_and_validate(:readonly => [:another])
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to make title read-only, got ["another"]'
+    end
+
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:readonly => true) }
+    it { should_not define_and_validate(:readonly => false) }
+    it { should_not define_and_validate(:accessible => [:another]) }
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate(:readonly => true) }
+
+    should_have_readonly_attributes :title
+    should_have_readonly_attributes :category
+    should_have_readonly_attributes :title, :category
+
+    should_not_have_readonly_attributes :another
+    should_not_have_readonly_attributes :title, :another
+  end
+end
+

data/spec/have_scope_matcher_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'have_scope' do
+  include ModelBuilder
+
+  before(:each) do
+    @model = define_model :product, :title => :string, :category => :string do
+      named_scope :recent, :order => 'created_at DESC'
+      named_scope :latest, lambda {|c| {:limit => c}}
+
+      def self.beginning(c)
+        scoped(:offset => c)
+      end
+
+      def self.null
+        nil
+      end
+    end
+  end
+
+  describe 'messages' do
+
+    it 'should contain a description' do
+      @matcher = have_scope(:title)
+      @matcher.description.should == 'have to scope itself to {} when :title is called'
+
+      @matcher.with(1)
+      @matcher.description.should == 'have to scope itself to {} when :title is called with 1 as argument'
+    end
+
+    it 'should set is_scope? message' do
+      @matcher = have_scope(:null)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected :null when called on Product return a ActiveRecord::NamedScope::Scope object'
+    end
+
+    it 'should set options_match? message' do
+      @matcher = have_scope(:recent, :conditions => {:special => true})
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected :recent when called on Product scope to {:conditions=>{:special=>true}}, got {:order=>"created_at DESC"}'
+    end
+
+  end
+
+  describe 'matchers' do
+    it { should have_scope(:recent) }
+    it { should have_scope(:recent, :order => 'created_at DESC') }
+
+    it { should have_scope(:latest,    :with => 10, :limit => 10) }
+    it { should have_scope(:beginning, :with => 10, :offset => 10) }
+
+    it { should_not have_scope(:null) }
+    it { should_not have_scope(:latest,    :with => 5, :limit => 10) }
+    it { should_not have_scope(:beginning, :with => 5, :offset => 10) }
+  end
+
+  describe 'macros' do
+    should_have_scope :recent
+    should_have_scope :recent, :order => 'created_at DESC'
+
+    should_have_scope :latest,    :with => 10, :limit => 10
+    should_have_scope :beginning, :with => 10, :offset => 10
+
+    should_not_have_scope :null
+    should_not_have_scope :latest,    :with => 5, :limit => 10
+    should_not_have_scope :beginning, :with => 5, :offset => 10
+  end
+end
+

data/spec/model_builder.rb

@@ -0,0 +1,101 @@
+# This is based on Shoulda model builder for Test::Unit.
+#
+module ModelBuilder
+  def self.included(base)
+    return unless base.name =~ /^Spec/
+
+    base.class_eval do
+      after(:each) do
+        if @defined_constants
+          @defined_constants.each do |class_name| 
+            Object.send(:remove_const, class_name)
+          end
+        end
+
+        if @created_tables
+          @created_tables.each do |table_name|
+            ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{table_name}")
+          end
+        end
+      end
+    end
+
+    base.extend ClassMethods
+  end
+
+  def create_table(table_name, &block)
+    connection = ActiveRecord::Base.connection
+
+    begin
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      connection.create_table(table_name, &block)
+      @created_tables ||= []
+      @created_tables << table_name
+      connection
+    rescue Exception => e
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      raise e
+    end
+  end
+
+  def define_constant(class_name, base, &block)
+    class_name = class_name.to_s.camelize
+
+    klass = Class.new(base)
+    Object.const_set(class_name, klass)
+
+    klass.class_eval(&block) if block_given?
+
+    @defined_constants ||= []
+    @defined_constants << class_name
+
+    klass
+  end
+
+  def define_model_class(class_name, &block)
+    define_constant(class_name, ActiveRecord::Base, &block)
+  end
+
+  def define_model(name, columns = {}, &block)
+    class_name = name.to_s.pluralize.classify
+    table_name = class_name.tableize
+
+    table = columns.delete(:table) || lambda {|table|
+      columns.each do |name, type|
+        table.column name, type
+      end
+    }
+
+    create_table(table_name, &table)
+
+    klass    = define_model_class(class_name, &block)
+    instance = klass.new
+
+    self.class.subject { instance } if self.class.respond_to?(:subject)
+    instance
+  end
+
+  module ClassMethods
+    # This is a macro to run validations of boolean optionals such as :allow_nil
+    # and :allow_blank. This macro tests all scenarios. The specs must have a
+    # define_and_validate method defined.
+    #
+    def create_optional_boolean_specs(optional, base, options={})
+      base.describe "with #{optional} option" do
+        it { should define_and_validate(options.merge(optional => true)).send(optional)            }
+        it { should define_and_validate(options.merge(optional => false)).send(optional, false)    }
+        it { should_not define_and_validate(options.merge(optional => true)).send(optional, false) }
+        it { should_not define_and_validate(options.merge(optional => false)).send(optional)       }
+      end
+    end
+
+    def create_message_specs(base)
+      base.describe "with message option" do
+        it { should define_and_validate(:message => 'valid_message').message('valid_message') }
+        it { should_not define_and_validate(:message => 'not_valid').message('valid_message') }
+      end
+    end
+  end
+
+end
+

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude "spec/*,gems/*" 
+--rails

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'ruby-debug'
+
+RAILS_VERSION = ENV['RAILS_VERSION'] || '=2.2.2'
+
+gem 'activesupport', RAILS_VERSION
+require 'active_support'
+
+gem 'activerecord', RAILS_VERSION
+require 'active_record'
+
+# Configure ActiveRecord connection
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :dbfile  => 'memory'
+)
+
+# Load Remarkable core on place to avoid gem to be loaded
+dir = File.dirname(__FILE__)
+require File.join(dir, '..', '..', 'remarkable', 'lib', 'remarkable')
+
+# Load Remarkable ActiveRecord
+require File.join(dir, 'model_builder')
+require File.join(dir, '..', 'lib', 'remarkable_activerecord')
+
+# Include matchers
+Remarkable.include_matchers!(Remarkable::ActiveRecord, Spec::Example::ExampleGroup)

data/spec/validate_acceptance_of_matcher_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_acceptance_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :user, :eula => :string, :terms => :string, :name => :string do
+      validates_acceptance_of :eula, :terms, options
+    end
+
+    validate_acceptance_of(:eula, :terms)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+
+    it 'should contain a description' do
+      @matcher.description.should == 'require eula and terms to be accepted'
+
+      @matcher.accept('true')
+      @matcher.description.should == 'require eula and terms to be accepted with value "true"'
+
+      @matcher.allow_nil
+      @matcher.description.should == 'require eula and terms to be accepted with value "true" and allowing nil values'
+    end
+
+    it 'should set requires_acceptance? message' do
+      @matcher = validate_acceptance_of(:name)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected User to be invalid if name is not accepted'
+    end
+
+    it 'should set accept_is_valid? message' do
+      @matcher.accept('accept_value').matches?(@model)
+      @matcher.failure_message.should == 'Expected User to be valid when eula is accepted with value "accept_value"'
+    end
+
+  end
+
+  describe 'matchers' do
+
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_acceptance_of(:eula) }
+      it { should validate_acceptance_of(:eula, :terms) }
+      it { should_not validate_acceptance_of(:eula, :name) }
+    end
+
+    describe 'with accept as option' do
+      it { should define_and_validate(:accept => 'accept_value').accept('accept_value') }
+      it { should_not define_and_validate(:accept => 'another_value').accept('a_value') }
+    end
+
+    create_message_specs(self)
+    create_optional_boolean_specs(:allow_nil, self)
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate }
+
+    should_validate_acceptance_of :eula
+    should_validate_acceptance_of :eula, :terms
+    should_not_validate_acceptance_of :eula, :name
+  end
+
+end

data/spec/validate_associated_matcher_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_associated' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(macro, association, options={})
+    define_model association, :name => :string do
+      if options[:with_builder]
+        validates_acceptance_of :name
+      else
+        validates_presence_of :name
+      end
+    end
+
+    options[:message] ||= :invalid
+
+    @model = define_model :project do
+      send(macro, association, :validate => false)              unless options[:skip_association]
+      validates_associated association, options.slice(:message) unless options[:skip_validation]
+    end
+
+    validate_associated association
+  end
+
+  describe 'messages' do
+    it 'should contain a description' do
+      define_and_validate(:belongs_to, :company).description.should == 'require associated company to be valid'
+    end
+
+    it 'should set is_valid? message' do
+      matcher = define_and_validate(:belongs_to, :company, :skip_validation => true)
+      matcher.matches?(@model)
+      matcher.failure_message.should == 'Expected Project to be invalid when company is invalid'
+    end
+  end
+
+  describe 'error' do
+    it 'should raise an error if the association does not exist' do
+      lambda {
+        should define_and_validate(:belongs_to, :company, :skip_association => true)
+      }.should raise_error(ScriptError, 'Could not find association company on Project.')
+    end
+
+    it 'should raise an error if a singular association cannot be built' do
+      lambda {
+        matcher = define_and_validate(:belongs_to, :company)
+        @model.should_receive(:build_company).and_raise(NoMethodError)
+        should matcher
+      }.should raise_error(ScriptError, 'The association object company could not be built. ' << 
+                                        'You can give me :builder as option or a block which ' <<
+                                        'returns an association.')
+    end
+
+    it 'should raise an error if a plural association cannot be built' do
+      lambda {
+        matcher = define_and_validate(:has_many, :tasks)
+        @model.should_receive(:tasks).and_return(mock=mock('proxy'))
+        mock.should_receive(:build).and_raise(NoMethodError)
+        should matcher
+      }.should raise_error(ScriptError, 'The association object tasks could not be built. ' << 
+                                        'You can give me :builder as option or a block which ' <<
+                                        'returns an association.')
+    end
+
+    it 'should raise an error if the associated object cannot be saved as invalid' do
+      lambda {
+        should define_and_validate(:belongs_to, :company, :with_builder => true)
+      }.should raise_error(ScriptError, 'The associated object company is not invalid. ' << 
+                                        'You can give me :builder as option or a block which ' << 
+                                        'returns an invalid association.')
+    end
+
+    it 'should raise an error if the associated object cannot be saved even when a build is supplied' do
+      lambda {
+        should define_and_validate(:belongs_to, :company, :with_builder => true).builder(proc{ |p| p.build_company })
+      }.should raise_error(ScriptError, 'The associated object company is not invalid. ' << 
+                                        'You can give me :builder as option or a block which ' << 
+                                        'returns an invalid association.')
+    end
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:belongs_to, :company) }
+    it { should define_and_validate(:has_one, :manager) }
+    it { should define_and_validate(:has_many, :tasks) }
+    it { should define_and_validate(:has_and_belongs_to_many, :tags) }
+
+    it { should define_and_validate(:belongs_to, :company, :with_builder => true).builder(proc{|p| p.build_company(:name => true)}) }
+    it { should define_and_validate(:has_one, :manager, :with_builder => true).builder(proc{|p| p.build_manager(:name => true)}) }
+    it { should define_and_validate(:has_many, :tasks, :with_builder => true).builder(proc{|p| p.tasks.build(:name => true)}) }
+    it { should define_and_validate(:has_and_belongs_to_many, :tags, :with_builder => true).builder(proc{|p| p.tags.build(:name => true)}) }
+
+    it { should_not define_and_validate(:belongs_to, :company, :skip_validation => true) }
+    it { should_not define_and_validate(:has_one, :manager, :skip_validation => true) }
+    it { should_not define_and_validate(:has_many, :tasks, :skip_validation => true) }
+    it { should_not define_and_validate(:has_and_belongs_to_many, :tags, :skip_validation => true) }
+
+    describe "with message option" do
+      it { should define_and_validate(:belongs_to, :company, :message => 'valid_message').message('valid_message') }
+      it { should_not define_and_validate(:belongs_to, :company, :message => 'not_valid').message('valid_message') }
+    end
+  end
+
+  describe 'macros' do
+    describe 'belongs to' do
+      before(:each){ define_and_validate(:belongs_to, :company) }
+      should_validate_associated(:company)
+    end
+
+    describe 'has_many with builder' do
+      before(:each){ define_and_validate(:has_many, :tasks, :with_builder => true) }
+      should_validate_associated(:tasks){ |p| p.tasks.build(:name => true) }
+    end
+
+    describe 'has_and_belongs_to_many with skip validation' do
+      before(:each){ define_and_validate(:has_and_belongs_to_many, :tags, :skip_validation => true) }
+      should_not_validate_associated(:tags)
+    end
+  end
+
+end

data/spec/validate_confirmation_of_matcher_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_confirmation_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :user, :name => :string, :email => :string, :age => :string do
+      validates_confirmation_of :name, :email, options
+    end
+
+    validate_confirmation_of(:name, :email)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+
+    it 'should contain a description' do
+      @matcher.description.should == 'require name and email to be confirmed'
+    end
+
+    it 'should set responds_to_confirmation? message' do
+      @matcher = validate_confirmation_of(:age)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected User instance responds to age_confirmation'
+    end
+
+    it 'should set confirms? message' do
+      @model.instance_eval{ def age_confirmation=(*args); end }
+      @matcher = validate_confirmation_of(:age)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected User to be valid only when age is confirmed'
+    end
+
+  end
+
+  describe 'matchers' do
+
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_confirmation_of(:name) }
+      it { should validate_confirmation_of(:name, :email) }
+      it { should_not validate_confirmation_of(:name, :age) }
+    end
+
+    create_message_specs(self)
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate }
+
+    should_validate_confirmation_of :name
+    should_validate_confirmation_of :name, :email
+    should_not_validate_confirmation_of :name, :age
+  end
+
+end

data/spec/validate_exclusion_of_matcher_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_exclusion_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :product, :title => :string, :size => :string do
+      validates_exclusion_of :title, :size, options
+    end
+
+    validate_exclusion_of(:title, :size)
+  end
+
+  describe 'messages' do
+
+    it 'should contain a description' do
+      @matcher = define_and_validate(:in => 2..10)
+      @matcher.in(2..10)
+      @matcher.description.should == 'ensure exclusion of title and size in 2..10'
+
+      @matcher = validate_exclusion_of(:title, :size).in('X', 'Y', 'Z')
+      @matcher.description.should == 'ensure exclusion of title and size in "X", "Y", and "Z"'
+    end
+
+    it 'should set is_invalid? message' do
+      @matcher = define_and_validate(:in => 2..10)
+      @matcher.in(1..10).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when title is set to 1'
+    end
+
+    it 'should set is_valid? message' do
+      @matcher = define_and_validate(:in => 2..10)
+      @matcher.in(3..10).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when title is set to 2'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher = define_and_validate(:in => [nil])
+      @matcher.allow_nil.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for title'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher = define_and_validate(:in => [''])
+      @matcher.allow_blank.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for title'
+    end
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:in => ['X', 'Y', 'Z']).in('X', 'Y', 'Z') }
+    it { should_not define_and_validate(:in => ['X', 'Y', 'Z']).in('A') }
+
+    it { should define_and_validate(:in => 2..3).in(2..3) }
+    it { should define_and_validate(:in => 2..20).in(2..20) }
+    it { should_not define_and_validate(:in => 2..20).in(1..20) }
+    it { should_not define_and_validate(:in => 2..20).in(3..20) }
+    it { should_not define_and_validate(:in => 2..20).in(2..19) }
+    it { should_not define_and_validate(:in => 2..20).in(2..21) }
+
+    it { should define_and_validate(:in => ['X', 'Y', 'Z'], :message => 'valid').in('X', 'Y', 'Z').message('valid') }
+
+    create_optional_boolean_specs(:allow_nil, self, :in => [nil])
+    create_optional_boolean_specs(:allow_blank, self, :in => [''])
+  end
+
+  describe 'macros' do
+    describe 'with array' do
+      before(:each){ define_and_validate(:in => ['X', 'Y', 'Z']) }
+
+      should_validate_exclusion_of :title, :in => ['X']
+      should_validate_exclusion_of :title, :size, :in => ['X']
+      should_not_validate_exclusion_of :title, :size, :in => ['A']
+    end
+
+    describe 'with range' do
+      before(:each){ define_and_validate(:in => 2..20) }
+
+      should_validate_exclusion_of :title, :in => 2..20
+      should_not_validate_exclusion_of :title, :in => 1..20
+      should_not_validate_exclusion_of :title, :in => 3..20
+      should_not_validate_exclusion_of :title, :in => 2..19
+      should_not_validate_exclusion_of :title, :in => 2..21
+    end
+  end
+end
+