remarkable_activerecord 3.1.9 → 3.1.10

data/spec/model_builder.rb

@@ -1,101 +0,0 @@
-# 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

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

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-require 'rubygems'
-
-RAILS_VERSION = ENV['RAILS_VERSION'] || '2.3.3'
-
-gem 'activesupport', RAILS_VERSION
-require 'active_support'
-
-gem 'activerecord', RAILS_VERSION
-require 'active_record'
-
-# Configure ActiveRecord connection
-ActiveRecord::Base.establish_connection(
-  :adapter  => 'sqlite3',
-  :database => ':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

@@ -1,68 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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, :builder => proc{ |p| p.tasks.build(:name => true) }
-
-      should_validate_associated :tasks do |m|
-        m.builder { |p| p.tasks.build(:name => true) }
-      end
-    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

@@ -1,58 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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('X', 'Y') }
-    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 => 'not valid').in('X', 'Y', 'Z').message('not valid') }
-    it { should_not define_and_validate(:in => ['X', 'Y', 'Z'], :message => 'not valid').in('X', 'Y', 'Z').message('valid') }
-  end
-
-  describe 'macros' do
-    describe 'with array' do
-      before(:each){ define_and_validate(:in => ['X', 'Y', 'Z']) }
-
-      should_validate_exclusion_of :title, :in => ['X', 'Y', 'Z']
-      should_validate_exclusion_of :title, :size, :in => ['X', 'Y', 'Z']
-      should_not_validate_exclusion_of :title, :in => ['X', 'Y']
-      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
-