shoulda-callback-matchers 0.1.0

data/lib/shoulda/callback/matchers/integrations/rspec.rb

@@ -0,0 +1,13 @@
+# :enddoc:
+
+if defined?(::ActiveRecord)
+  require 'shoulda/callback/matchers/active_model'
+  module RSpec::Matchers
+    include Shoulda::Callback::Matchers::ActiveModel
+  end
+elsif defined?(::ActiveModel)
+  require 'shoulda/callback/matchers/active_model'
+  module RSpec::Matchers
+    include Shoulda::Callback::Matchers::ActiveModel
+  end
+end

data/lib/shoulda/callback/matchers/integrations/test_unit.rb

@@ -0,0 +1,34 @@
+# :enddoc:
+
+# in environments where test/unit is not required, this is necessary
+unless defined?(Test::Unit::TestCase)
+  begin
+    require 'test/unit' 
+  rescue LoadError
+    # silent
+  end
+end
+
+if defined?(ActiveRecord)
+  require 'shoulda/callback/matchers/active_model'
+
+  module Test
+    module Unit
+      class TestCase
+        include Shoulda::Callback::Matchers::ActiveModel        
+        extend Shoulda::Callback::Matchers::ActiveModel
+      end
+    end
+  end
+elsif defined?(ActiveModel)
+  require 'shoulda/callback/matchers/active_model'
+  
+  module Test
+    module Unit
+      class TestCase
+        include Shoulda::Callback::Matchers::ActiveModel
+        extend Shoulda::Callback::Matchers::ActiveModel
+      end
+    end
+  end
+end

data/lib/shoulda/callback/matchers/version.rb

@@ -0,0 +1,7 @@
+module Shoulda
+  module Callback
+    module Matchers
+      VERSION = '0.1.0'.freeze
+    end
+  end
+end

data/shoulda-callback-matchers.gemspec

@@ -0,0 +1,28 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'shoulda/callback/matchers/version'
+
+Gem::Specification.new do |s|
+  s.name        = "shoulda-callback-matchers"
+  s.version     = Shoulda::Callback::Matchers::VERSION.dup
+  s.authors     = ["Beat Richartz"]
+  s.date        = Time.now.strftime("%Y-%m-%d")
+  s.email       = "attraccessor@gmail.com"
+  s.homepage    = "http://github.com/beatrichartz/shoulda-callback-matchers"
+  s.summary     = "Making callback tests easy on the fingers and eyes"
+  s.description = "Making callback tests easy on the fingers and eyes"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('activesupport', '>= 3.0.0')
+
+  s.add_development_dependency('appraisal',   '~> 0.4.0')
+  s.add_development_dependency('aruba')
+  s.add_development_dependency('bourne',      '~> 1.1.2')
+  s.add_development_dependency('bundler',     '>= 1.1.0')
+  s.add_development_dependency('rails',       '~> 3.0')
+  s.add_development_dependency('rake',        '~> 0.9.2')
+  s.add_development_dependency('rspec-rails', '~> 2.8.1')
+end

data/spec/fixtures/users.yml

@@ -0,0 +1,6 @@
+first:
+  id: 1
+  name: Some dude
+  age: 2
+  email: none@none.com
+  ssn: 123456789

data/spec/shoulda/active_model/callback_matcher_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe Shoulda::Callback::Matchers::ActiveModel do
+  
+  context "invalid use" do
+    before do
+      @model = define_model(:example, :attr  => :string,
+                                      :other => :integer) do
+        attr_accessible :attr, :other
+        before_create :dance!, :if => :evaluates_to_false!
+        after_save  :shake!, :unless => :evaluates_to_true!
+      end.new
+    end
+    it "should return a meaningful failure message when used without a defined lifecycle" do
+      matcher = callback(:dance!)
+      matcher.matches?(@model).should be_false
+      matcher.failure_message.should == "callback dance! can not be tested against an undefined lifecycle, use .before, .after or .around"
+      matcher.negative_failure_message.should == "callback dance! can not be tested against an undefined lifecycle, use .before, .after or .around"
+    end
+    it "should return a meaningful failure message when used with an optional lifecycle without the original lifecycle being validation" do
+      matcher = callback(:dance!).after(:create).on(:save)
+      matcher.matches?(@model).should be_false
+      matcher.failure_message.should == "The .on option is only valid for the validation lifecycle and cannot be used with create, use with .before(:validation) or .after(:validation)"
+      matcher.negative_failure_message.should == "The .on option is only valid for the validation lifecycle and cannot be used with create, use with .before(:validation) or .after(:validation)"
+    end
+  end
+  
+  [:save, :create, :update, :destroy].each do |lifecycle|
+    context "on #{lifecycle}" do
+      before do
+        @model = define_model(:example, :attr  => :string,
+                                        :other => :integer) do
+          attr_accessible :attr, :other
+          send(:"before_#{lifecycle}", :dance!, :if => :evaluates_to_false!)
+          send(:"after_#{lifecycle}", :shake!, :unless => :evaluates_to_true!)
+          send(:"around_#{lifecycle}", :giggle!)
+        end.new
+      end
+      context "as a simple callback test" do
+        it "should find the callback before the fact" do
+          @model.should callback(:dance!).before(lifecycle)
+        end
+        it "should find the callback after the fact" do
+          @model.should callback(:shake!).after(lifecycle)
+        end
+        it "should find the callback around the fact" do
+          @model.should callback(:giggle!).around(lifecycle)
+        end
+        it "should not find callbacks that are not there" do
+          @model.should_not callback(:scream!).around(lifecycle)
+        end
+        it "should have a meaningful description" do
+          matcher = callback(:dance!).before(lifecycle)
+          matcher.description.should == "callback dance! before #{lifecycle}"
+        end
+      end
+      context "with conditions" do
+        it "should match the if condition" do
+          @model.should callback(:dance!).before(lifecycle).if(:evaluates_to_false!)
+        end
+        it "should match the unless condition" do
+          @model.should callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
+        end
+        it "should not find callbacks not matching the conditions" do
+          @model.should_not callback(:giggle!).around(lifecycle).unless(:evaluates_to_false!)
+        end
+        it "should not find callbacks that are not there entirely" do
+          @model.should_not callback(:scream!).before(lifecycle).unless(:evaluates_to_false!)
+        end
+        it "should have a meaningful description" do
+          matcher = callback(:dance!).after(lifecycle).unless(:evaluates_to_false!)
+          matcher.description.should == "callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false"
+        end
+      end
+    end
+  end
+  
+  context "on validation" do
+    before do
+      @model = define_model(:example, :attr  => :string,
+                                      :other => :integer) do
+        attr_accessible :attr, :other
+        before_validation :dance!, :if => :evaluates_to_false!
+        after_validation  :shake!, :unless => :evaluates_to_true!
+        before_validation :dress!, :on => :create
+        after_validation  :shriek!, :on => :update, :unless => :evaluates_to_true!
+        after_validation  :pucker!, :on => :save, :if => :evaluates_to_false!
+      end.new
+    end
+    
+    context "as a simple callback test" do
+      it "should find the callback before the fact" do
+        @model.should callback(:dance!).before(:validation)
+      end
+      it "should find the callback after the fact" do
+        @model.should callback(:shake!).after(:validation)
+      end
+      it "should not find a callback around the fact" do
+        @model.should_not callback(:giggle!).around(:validation)
+      end
+      it "should not find callbacks that are not there" do
+        @model.should_not callback(:scream!).around(:validation)
+      end
+      it "should have a meaningful description" do
+        matcher = callback(:dance!).before(:validation)
+        matcher.description.should == "callback dance! before validation"
+      end
+    end
+    
+    context "with additinal lifecycles defined" do
+      it "should find the callback before the fact on create" do
+        @model.should callback(:dress!).before(:validation).on(:create)
+      end
+      it "should find the callback after the fact on update" do
+        @model.should callback(:shriek!).after(:validation).on(:update)
+      end
+      it "should find the callback after the fact on save" do
+        @model.should callback(:pucker!).after(:validation).on(:save)
+      end
+      it "should not find a callback for pucker! after the fact on update" do
+        @model.should_not callback(:pucker!).after(:validation).on(:update)
+      end
+      it "should have a meaningful description" do
+        matcher = callback(:dance!).after(:validation).on(:update)
+        matcher.description.should == "callback dance! after validation on update"
+      end
+    end
+    
+    context "with conditions" do
+      it "should match the if condition" do
+        @model.should callback(:dance!).before(:validation).if(:evaluates_to_false!)
+      end
+      it "should match the unless condition" do
+        @model.should callback(:shake!).after(:validation).unless(:evaluates_to_true!)
+      end
+      it "should not find callbacks not matching the conditions" do
+        @model.should_not callback(:giggle!).around(:validation).unless(:evaluates_to_false!)
+      end
+      it "should not find callbacks that are not there entirely" do
+        @model.should_not callback(:scream!).before(:validation).unless(:evaluates_to_false!)
+      end
+      it "should have a meaningful description" do
+        matcher = callback(:dance!).after(:validation).unless(:evaluates_to_false!)
+        matcher.description.should == "callback dance! after validation unless evaluates_to_false! evaluates to false"
+      end
+    end
+    
+    context "with conditions and additional lifecycles" do
+      it "should find the callback before the fact on create" do
+        @model.should callback(:dress!).before(:validation).on(:create)
+      end
+      it "should find the callback after the fact on update with the unless condition" do
+        @model.should callback(:shriek!).after(:validation).on(:update).unless(:evaluates_to_true!)
+      end
+      it "should find the callback after the fact on save with the if condition" do
+        @model.should callback(:pucker!).after(:validation).on(:save).if(:evaluates_to_false!)
+      end
+      it "should not find a callback for pucker! after the fact on save with the wrong condition" do
+        @model.should_not callback(:pucker!).after(:validation).on(:save).unless(:evaluates_to_false!)
+      end
+      it "should have a meaningful description" do
+        matcher = callback(:dance!).after(:validation).on(:save).unless(:evaluates_to_false!)
+        matcher.description.should == "callback dance! after validation on save unless evaluates_to_false! evaluates to false"
+      end
+    end
+  end
+  
+  [:initialize, :find, :touch].each do |lifecycle|
+    
+    context "on #{lifecycle}" do
+      before do
+        @model = define_model(:example, :attr  => :string,
+                                        :other => :integer) do
+          attr_accessible :attr, :other
+          send(:"after_#{lifecycle}", :dance!, :if => :evaluates_to_false!)
+          send(:"after_#{lifecycle}", :shake!, :unless => :evaluates_to_true!)
+          
+          define_method :evaluates_to_false! do
+            false
+          end
+          
+          define_method :evaluates_to_true! do
+            true
+          end
+          
+        end.new
+      end
+      
+      context "as a simple callback test" do
+        it "should not find a callback before the fact" do
+          @model.should_not callback(:dance!).before(lifecycle)
+        end
+        it "should find the callback after the fact" do
+          @model.should callback(:shake!).after(lifecycle)
+        end
+        it "should not find a callback around the fact" do
+          @model.should_not callback(:giggle!).around(lifecycle)
+        end
+        it "should not find callbacks that are not there" do
+          @model.should_not callback(:scream!).around(lifecycle)
+        end
+        it "should have a meaningful description" do
+          matcher = callback(:dance!).before(lifecycle)
+          matcher.description.should == "callback dance! before #{lifecycle}"
+        end
+      end
+      
+      context "with conditions" do
+        it "should match the if condition" do
+          @model.should callback(:dance!).after(lifecycle).if(:evaluates_to_false!)
+        end
+        it "should match the unless condition" do
+          @model.should callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
+        end
+        it "should not find callbacks not matching the conditions" do
+          @model.should_not callback(:giggle!).around(lifecycle).unless(:evaluates_to_false!)
+        end
+        it "should not find callbacks that are not there entirely" do
+          @model.should_not callback(:scream!).before(lifecycle).unless(:evaluates_to_false!)
+        end
+        it "should have a meaningful description" do
+          matcher = callback(:dance!).after(lifecycle).unless(:evaluates_to_false!)
+          matcher.description.should == "callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false"
+        end
+      end
+      
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# Create Rails environment based on the version given from Appraisal
+TESTAPP_ROOT = File.join(File.dirname(__FILE__), '..', 'tmp', 'aruba', 'testapp')
+FileUtils.rm_rf(TESTAPP_ROOT) if File.exists?(TESTAPP_ROOT)
+`rails new #{TESTAPP_ROOT}`
+
+ENV['RAILS_ENV'] = 'test'
+ENV['BUNDLE_GEMFILE'] ||= TESTAPP_ROOT + '/Gemfile'
+
+require "#{TESTAPP_ROOT}/config/environment"
+require 'rspec'
+require 'bourne'
+require 'shoulda-callback-matchers'
+require 'rspec/rails'
+
+PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')).freeze
+
+$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
+
+Dir[File.join(PROJECT_ROOT, 'spec', 'support', '**', '*.rb')].each { |file| require(file) }
+
+# Run the migrations
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/support/active_model_versions.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |c|
+  def active_model_3_1?
+    ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1
+  end
+
+  def active_model_3_2?
+    ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 2
+  end
+end

data/spec/support/class_builder.rb

@@ -0,0 +1,42 @@
+module ClassBuilder
+  def self.included(example_group)
+    example_group.class_eval do
+      after do
+        teardown_defined_constants
+      end
+    end
+  end
+
+  def define_class(class_name, base = Object, &block)
+    class_name = class_name.to_s.camelize
+
+    # FIXME: ActionMailer 3.2 calls `name.underscore` immediately upon
+    # subclassing. Class.new.name == nil. So, Class.new(ActionMailer::Base)
+    # errors out since it's trying to do `nil.underscore`. This is very ugly but
+    # allows us to test against ActionMailer 3.2.x.
+    eval <<-A_REAL_CLASS_FOR_ACTION_MAILER_3_2
+    class ::#{class_name} < #{base}
+    end
+    A_REAL_CLASS_FOR_ACTION_MAILER_3_2
+
+    Object.const_get(class_name).tap do |constant_class|
+      constant_class.unloadable
+
+      if block_given?
+        constant_class.class_eval(&block)
+      end
+
+      if constant_class.respond_to?(:reset_column_information)
+        constant_class.reset_column_information
+      end
+    end
+  end
+
+  def teardown_defined_constants
+    ActiveSupport::Dependencies.clear
+  end
+end
+
+RSpec.configure do |config|
+  config.include ClassBuilder
+end

data/spec/support/model_builder.rb

@@ -0,0 +1,73 @@
+module ModelBuilder
+  def self.included(example_group)
+    example_group.class_eval do
+      before do
+        @created_tables ||= []
+      end
+
+      after do
+        drop_created_tables
+      end
+    end
+  end
+
+  def create_table(table_name, options = {}, &block)
+    connection = ActiveRecord::Base.connection
+
+    begin
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      connection.create_table(table_name, options, &block)
+      @created_tables << table_name
+      connection
+    rescue Exception => e
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      raise e
+    end
+  end
+
+  def define_model_class(class_name, &block)
+    define_class(class_name, ActiveRecord::Base, &block)
+  end
+
+  def define_active_model_class(class_name, options = {}, &block)
+    define_class(class_name) do
+      include ActiveModel::Validations
+      extend ActiveModel::Callbacks
+      define_model_callbacks :initialize, :find, :touch, :only => :after
+      define_model_callbacks :save, :create, :update, :destroy
+      
+      options[:accessors].each do |column|
+        attr_accessor column.to_sym
+      end
+
+      if block_given?
+        class_eval(&block)
+      end
+    end
+  end
+
+  def define_model(name, columns = {}, &block)
+    class_name = name.to_s.pluralize.classify
+    table_name = class_name.tableize
+
+    create_table(table_name) do |table|
+      columns.each do |name, type|
+        table.column name, type
+      end
+    end
+
+    define_model_class(class_name, &block)
+  end
+
+  def drop_created_tables
+    connection = ActiveRecord::Base.connection
+
+    @created_tables.each do |table_name|
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ModelBuilder
+end