svenaas-woulda 0.2.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sean Hussey and Josh Nichols
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,86 @@
+h1. woulda
+
+Testing is love. Especially when done with "Shoulda":http://thoughtbot.com/projects/shoulda. Shoulda makes testing your Rails app pretty easy.
+
+There are tons of Rails plugins and gems out there. It should be easy to test your Rails app that uses these as well. That kind of support doesn't really belong in Shoulda itself, though.
+
+That's where Woulda comes in.
+
+h2. Installing
+
+It's available as a gem: <pre>gem install seanhussey-woulda --source http://gems.github.com</pre>
+
+Use it in a Rails app by placing in config/environments/test.rb:
+
+<pre>config.gem 'seanhussey-woulda', :lib => 'woulda', :source => 'http://gems.github.com'</pre>
+
+Woulda requires "shoulda":http://github.com/thoughtbot/shoulda/tree/master >= 2.0.0.
+
+h2. Included Macros
+
+<pre><code># acts_as_ferret
+class PostTest < Test::Unit::TestCase
+  should_act_as_ferret :title, :contents
+end
+
+# acts_as_list
+class NewsItemTest < Test::Unit::TestCase
+  should_act_as_list
+end
+
+# acts_as_paranoid
+class DocumentTest < Test::Unit::TestCase
+  should_act_as_paranoid
+end
+
+# acts_as_taggable_on_steroids
+class PersonTest < Test::Unit::TestCase
+  should_act_as_taggable_on_steroids
+end
+
+# attachment_fu
+class ImageTest < Test::Unit::TestCase
+  should_have_attachment :content_type => :image
+end
+
+# enumeration_mixin
+class RoleTest < Test::Unit::TestCase
+  should_act_as_enumerated
+end
+
+# paperclip
+class UserTest < Test::Unit::TestCase
+  should_have_attached_file :avatar
+end
+
+# will_paginate
+class PostTest < Test::Unit::TestCase
+  should_have_per_page 10
+end
+
+# acts_as_solr
+class ProductTest < Test::Unit::TestCase
+  should_act_as_solr :name, :price
+end
+
+# acts_as_xapian
+class ProductTest < Test::Unit::TestCase
+  should_act_as_xapian :name, :description
+end 
+
+# acts_as_state_machine
+class OrderTest < Test::Unit::TestCase
+  should_act_as_state_machine :initial => :open, :states => [:closed], :events => {:close_order => {:to => :closed, :from :open}}
+end</code></pre>
+
+h2. The source
+
+The source is available from "GitHub":http://github.com/seanhussey/woulda/tree/master.
+
+Clone it: <pre>git clone git://github.com/seanhussey/woulda.git</pre>
+
+h2. Credit
+
+Written by "Sean Hussey":mailto:sean@seanhussey.com and "Josh Nichols":http://technicalpickles.com
+
+Copyright 2008 Sean Hussey and Josh Nichols.

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "woulda"
+    s.summary = "woulda is a home for shoulda macros that don't belong in the main shoulda library"
+    s.email = ["sean@seanhussey.com", "josh@technicalpickles.com"]
+    s.homepage = "http://github.com/seanhussey/woulda"
+    s.description = "TODO"
+    s.authors = ["Sean Hussey", "Josh Nichols"]
+    s.add_dependency "thoughtbot-shoulda", ">= 2.10.2"
+    s.rubyforge_project = "woulda"
+    s.files       = FileList["[A-Z]*", "{shoulda_macros}/**/*", "lib/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc "Run all tests"
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 2
+:major: 0
+:minor: 2

data/lib/woulda/acts_as_ferret/macros.rb

@@ -0,0 +1,24 @@
+module Woulda
+  module ActsAsFerret
+    module Macros
+      # should_act_as_ferret :any, :fields, :i_may, :have, :specified
+      # Original source: http://www.soyunperdedor.com/node/34
+      def should_act_as_ferret(*fields)
+        klass = self.name.gsub(/Test$/, '').constantize
+
+        should "include ActsAsFerret methods" do
+          assert klass.extended_by.include?(ActsAsFerret::ClassMethods)
+          assert klass.include?(ActsAsFerret::InstanceMethods)
+          assert klass.include?(ActsAsFerret::MoreLikeThis::InstanceMethods)
+          assert klass.include?(ActsAsFerret::ResultAttributes)
+        end
+
+        fields.each do |f|
+          should "create an index for field named #{f}" do
+            assert klass.aaf_configuration[:fields].include?(f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/woulda/acts_as_ferret.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/acts_as_ferret/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ActsAsFerret::Macros
+end

data/lib/woulda/acts_as_list/macros.rb

@@ -0,0 +1,20 @@
+module Woulda
+  module ActsAsList
+    module Macros
+      # Original source: http://www.soyunperdedor.com/node/34
+      def should_act_as_list
+        klass = self.name.gsub(/Test$/, '').constantize
+
+        context "To support acts_as_list" do
+          should_have_db_column('position', :type => :integer)
+        end
+
+        should "include ActsAsList methods" do
+          assert klass.include?(ActiveRecord::Acts::List::InstanceMethods)
+        end
+
+        should_have_instance_methods :acts_as_list_class, :position_column, :scope_condition
+      end
+    end
+  end
+end

data/lib/woulda/acts_as_list.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/acts_as_list/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ActsAsList::Macros
+end

data/lib/woulda/acts_as_paranoid/macros.rb

@@ -0,0 +1,39 @@
+module Woulda
+  module ActsAsParanoid
+    module Macros
+      def should_act_as_paranoid
+        klass = described_type
+        should_have_db_column :deleted_at
+
+        context "A #{klass.name}" do
+          should "be paranoid (it will not be deleted from the database)" do
+            assert klass.paranoid?
+            assert klass.included_modules.include?(Caboose::Acts::Paranoid)
+          end
+
+          should "not have a value for deleted_at" do
+            assert object = klass.find(:first)
+            assert_nil object.deleted_at
+          end
+
+          context "when destroyed" do
+            setup do
+              assert object = klass.find(:first), "This context requires there to be an existing #{klass}"
+              @deleted_id = object.id
+              object.destroy
+            end
+
+            should "not be found" do
+              assert_raise(ActiveRecord::RecordNotFound) { klass.find(@deleted_id) }
+            end
+
+            should "still exist in the database" do
+              deleted_object = klass.find_with_deleted(@deleted_id)
+              assert_not_nil deleted_object.deleted_at
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/woulda/acts_as_paranoid.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/acts_as_paranoid/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ActsAsParanoid::Macros
+end

data/lib/woulda/acts_as_solr/macros.rb

@@ -0,0 +1,49 @@
+module Woulda
+  module ActsAsSolr
+    module Macros
+      def should_act_as_solr(opts={})
+        klass = described_type
+        
+        associations = get_options!([opts], :associations)
+
+        associations ||= []
+
+        context "A #{klass.name}" do
+          # should "include the ActsAsSolr::ParserMethods module" do
+          #   assert klass.included_modules.include?(ActsAsSolr::ParserMethods)
+          # end
+          # 
+          # should "include the ActsAsSolr::CommonMethods module" do
+          #   assert klass.included_modules.include?(ActsAsSolr::CommonMethods)
+          # end
+          # 
+          # should "include the ActsAsSolr::InstanceMethods module" do
+          #   assert klass.included_modules.include?(ActsAsSolr::InstanceMethods)
+          # end
+          # 
+          # should "be extended by the ActsAsSolr::ClassMethods module" do
+          #   assert klass.extended_by.include?(ActsAsSolr::ClassMethods)
+          # end
+          # 
+          # should "be extended by the ActsAsSolr::ParserMethods module" do
+          #   assert klass.extended_by.include?(ActsAsSolr::ParserMethods)
+          # end
+          # 
+          # should "be extended by the ActsAsSolr::CommonMethods module" do
+          #   assert klass.extended_by.include?(ActsAsSolr::CommonMethods)
+          # end
+          # 
+          # should "be extended by the ActsAsSolr::PaginationExtension module" do
+          #   assert klass.extended_by.include?(ActsAsSolr::PaginationExtension)
+          # end
+
+          associations.each do |association|
+            should "include the #{association.to_s} association in solr indexing" do
+              klass.configuration[:include].include?(association)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/woulda/acts_as_solr.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/acts_as_solr/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ActsAsSolr::Macros
+end

data/lib/woulda/acts_as_state_machine/macros_new.rb

@@ -0,0 +1,87 @@
+module Woulda
+  module ActsAsStateMachine
+    module Macros
+      # Example:
+      #
+      # class Order < ActiveRecord::Base
+      #   acts_as_state_machine :initial => :open
+      #
+      #   state :open
+      #   state :closed
+      #
+      #   event :close_order do
+      #     transitions :to => :closed, :from => :open
+      #   end
+      # end
+      #
+      # class OrderTest < Test::Unit::TestCase
+      #
+      #   # check the inital state
+      #   should_act_as_state_machine :initial => :open
+      #
+      #   # check states in addition to :initial
+      #   should_act_as_state_machine :initial => :open, :states => [:closed]
+      #
+      #   # check events and transitions
+      #   should_act_as_state_machine :events => {:close_order => {:to => :closed, :from :open}}
+      #
+      #   should_act_as_state_machine :initial => :open, :states => [:closed], :events => {:close_order => {:to => :closed, :from :open}}
+      # end
+      #
+      def should_act_as_state_machine(opts={})
+        klass = described_type
+
+        initial_state, states, events, db_column = get_options!([opts], :initial, :states, :events, :column)
+
+        states ||= []
+        events ||= {}
+        db_column ||= :state
+
+        context "A #{klass.name}" do
+
+          should_have_db_column db_column
+
+          should "include the ActsAsStateMachine module" do
+            assert klass.included_modules.include?(AASM)
+          end
+
+          should "define ActsAsStateMachine class methods" do
+             assert klass.extended_by.include?(AASM::ClassMethods), "#{klass} doesn't define ActsAsStateMachine class methods"
+          end
+
+          should "define ActsAsStateMachine instance methods" do
+            assert klass.include?(AASM::InstanceMethods), "#{klass} doesn't define ActsAsStateMachine instance methods"
+          end
+
+          should "have an intital state of #{initial_state}" do
+            assert_equal initial_state, klass.aasm_initial_state, "#{klass} does not have an initial state of #{initial_state}"
+          end
+
+          states.each do |state|
+            should "include state #{state}" do
+              assert klass.aasm_states.map { |state| state.name}.include?(state), "#{klass} does not include state #{state}"
+            end
+          end
+
+          events.each do |event, transition|
+
+            should "define an event #{event}" do
+              assert klass.aasm_events.has_key?(event), "#{klass} does not define event #{event}"
+            end
+
+            to   = transition[:to]
+            from = transition[:from].is_a?(Symbol) ? [transition[:from]] : transition[:from]
+
+            from.each do |from_state|
+              should "transition to #{to} from #{from_state} on event #{event}" do
+                assert_not_nil klass.aasm_events[event].instance_variable_get("@transitions").detect { |t| t.to == to && t.from == from_state }, "#{event} does not transition to #{to} from #{from_state}"
+              end
+            end
+
+          end
+        end   
+
+      end
+    end
+  end
+end

data/lib/woulda/acts_as_state_machine/macros_old.rb

@@ -0,0 +1,87 @@
+module Woulda
+  module ActsAsStateMachine
+    module Macros
+      # Example:
+      #
+      # class Order < ActiveRecord::Base
+      #   acts_as_state_machine :initial => :open
+      #
+      #   state :open
+      #   state :closed
+      #
+      #   event :close_order do
+      #     transitions :to => :closed, :from => :open
+      #   end
+      # end
+      #
+      # class OrderTest < Test::Unit::TestCase
+      #
+      #   # check the inital state
+      #   should_act_as_state_machine :initial => :open
+      #
+      #   # check states in addition to :initial
+      #   should_act_as_state_machine :initial => :open, :states => [:closed]
+      #
+      #   # check events and transitions
+      #   should_act_as_state_machine :events => {:close_order => {:to => :closed, :from :open}}
+      #
+      #   should_act_as_state_machine :initial => :open, :states => [:closed], :events => {:close_order => {:to => :closed, :from :open}}
+      # end
+      #
+      def should_act_as_state_machine(opts={})
+        klass = described_type
+
+        initial_state, states, events, db_column = get_options!([opts], :initial, :states, :events, :column)
+
+        states ||= []
+        events ||= {}
+        db_column ||= :state
+
+        context "A #{klass.name}" do
+
+          should_have_db_column db_column
+
+          should "include the ActsAsStateMachine module" do
+            assert klass.included_modules.include?(ScottBarron::Acts::StateMachine)
+          end
+
+          should "define ActsAsStateMachine class methods" do
+             assert klass.extended_by.include?(ScottBarron::Acts::StateMachine::ClassMethods), "#{klass} doesn't define ActsAsStateMachine class methods"
+          end
+
+          should "define ActsAsStateMachine instance methods" do
+            assert klass.include?(ScottBarron::Acts::StateMachine::InstanceMethods), "#{klass} doesn't define ActsAsStateMachine instance methods"
+          end
+
+          should "have an intital state of #{initial_state}" do
+            assert_equal initial_state, klass.initial_state, "#{klass} does not have an initial state of #{initial_state}"
+          end
+
+          states.each do |state|
+            should "include state #{state}" do
+              assert klass.states.include?(state), "#{klass} does not include state #{state}"
+            end
+          end
+
+          events.each do |event, transition|
+
+            should "define an event #{event}" do
+              assert klass.transition_table.has_key?(event), "#{klass} does not define event #{event}"
+            end
+
+            to   = transition[:to]
+            from = transition[:from].is_a?(Symbol) ? [transition[:from]] : transition[:from]
+
+            from.each do |from_state|
+              should "transition to #{to} from #{from_state} on event #{event}" do
+                assert_not_nil klass.transition_table[event].detect { |t| t.to == to && t.from == from_state }, "#{event} does not transition to #{to} from #{from_state}"
+              end
+            end
+
+          end
+        end   
+
+      end
+    end
+  end
+end

data/lib/woulda/acts_as_state_machine.rb

@@ -0,0 +1,7 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/acts_as_state_machine/macros_old' unless defined?(AASM)
+require File.dirname(__FILE__) + '/acts_as_state_machine/macros_new' if defined?(AASM)
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ActsAsStateMachine::Macros
+end

data/lib/woulda/acts_as_taggable_on_steroids/macros.rb

@@ -0,0 +1,18 @@
+module Woulda
+  module ActsAsTaggableOnSteroids
+    module Macros
+      # Original source: http://www.soyunperdedor.com/node/34
+      def should_act_as_taggable_on_steroids
+        klass = self.name.gsub(/Test$/, '').constantize
+
+        should "include ActsAsTaggableOnSteroids methods" do
+          assert klass.extended_by.include?(ActiveRecord::Acts::Taggable::ClassMethods)
+          assert klass.extended_by.include?(ActiveRecord::Acts::Taggable::SingletonMethods)
+          assert klass.include?(ActiveRecord::Acts::Taggable::InstanceMethods)
+        end
+
+        should_have_many :taggings, :tags
+      end
+    end
+  end
+end

data/lib/woulda/acts_as_taggable_on_steroids.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/acts_as_taggable_on_steroids/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ActsAsTaggableOnSteroids::Macros
+end

data/lib/woulda/acts_as_xapian/macros.rb

@@ -0,0 +1,27 @@
+module Woulda
+  module ActsAsXapian
+    module Macros
+      
+      #
+      # should_act_as_xapian :name, :description
+      #
+      def should_act_as_xapian(*fields)
+        klass = described_type
+
+        context "A #{klass}" do
+          should "include ActsAsXapian methods" do
+            assert klass.include?(ActsAsXapian::InstanceMethods)
+          end  
+
+          fields.each do |field|
+            should "index field #{field}" do
+              assert klass.xapian_options[:texts].include?(field)
+            end
+          end
+        end
+
+      end
+      
+    end    
+  end  
+end

data/lib/woulda/acts_as_xapian.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/acts_as_xapian/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ActsAsXapian::Macros
+end

data/lib/woulda/attachment_fu/macros.rb

@@ -0,0 +1,27 @@
+module Woulda
+  module AttachmentFu
+    module Macros
+      def should_have_attachment(options = {})
+        klass = described_type
+
+        should_have_db_columns :size, :content_type, :filename
+        if options[:content_type] == :image
+          should_have_db_columns :height, :width
+        end
+
+        should "define AttachmentFu class methods" do
+          # breakpoint
+          class_modules = (class << klass; included_modules; end)
+          assert class_modules.include?(Technoweenie::AttachmentFu::ClassMethods),
+                                        "#{klass} doesn't define AttachmentFu class methods"
+        end
+
+        should "define AttachmentFu instance methods" do
+          instance_modules = klass.included_modules
+          assert instance_modules.include?(Technoweenie::AttachmentFu::InstanceMethods),
+                                            "#{klass} doesn't define AttachmentFu instance methods"
+        end
+      end
+    end
+  end
+end

data/lib/woulda/attachment_fu.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/attachment_fu/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::AttachmentFu::Macros
+end

data/lib/woulda/enumerations_mixin/macros.rb

@@ -0,0 +1,26 @@
+module Woulda
+  module EnumerationsMixin
+    module Macros
+      def should_act_as_enumerated(options = {})
+        klass = described_type
+
+        should_have_db_columns :name
+
+        should "define Enumerated macro methods" do
+          class_modules = (class << klass; included_modules; end)
+          assert class_modules.include?(ActiveRecord::Acts::Enumerated::MacroMethods), "#{klass} doesn't define Enumerated macro methods"
+        end
+
+        should "define Enumerated class methods" do
+          class_modules = (class << klass; included_modules; end)
+          assert class_modules.include?(ActiveRecord::Acts::Enumerated::ClassMethods), "#{klass} doesn't define Enumerated class methods"
+        end
+
+        should "define Enumerated instance methods" do
+          instance_modules = klass.included_modules
+          assert instance_modules.include?(ActiveRecord::Acts::Enumerated::InstanceMethods), "#{klass} doesn't define Enumerated instance methods"
+        end
+      end
+    end
+  end
+end

data/lib/woulda/enumerations_mixin.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/enumerations_mixin/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::EnumerationsMixin::Macros
+end

data/lib/woulda/paperclip/macros.rb

@@ -0,0 +1,22 @@
+module Woulda
+  module Paperclip
+    module Macros
+      # Original source: http://giantrobots.thoughtbot.com/2008/6/3/testing-paperclip-with-shoulda
+      def should_have_attached_file(attachment)
+        klass = self.name.gsub(/Test$/, '').constantize
+
+        context "To support a paperclip attachment named #{attachment}, #{klass}" do
+          should_have_db_column("#{attachment}_file_name", :type => :string)
+          should_have_db_column("#{attachment}_content_type", :type => :string)
+          should_have_db_column("#{attachment}_file_size", :type => :integer)
+        end
+
+        should "have a paperclip attachment named ##{attachment}" do
+          assert klass.new.respond_to?(attachment.to_sym),
+                 "@#{klass.name.underscore} doesn't have a paperclip field named #{attachment}"
+          assert_equal ::Paperclip::Attachment, klass.new.send(attachment.to_sym).class
+        end
+      end
+    end
+  end
+end

data/lib/woulda/paperclip.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/paperclip/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::Paperclip::Macros
+end

data/lib/woulda/should_raise/macros.rb

@@ -0,0 +1,102 @@
+# Copyright (c) 2008 Mathieu Martin
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# TODO
+# - nest contexts/should differently so the message verifications don't clobber each other.
+#   Put exactly same message in last few tests for an example.
+
+module Woulda
+  module ShouldRaise
+    module Macros
+      # Make sure a block raises an exception.
+      # Call with optional arguments :instance_of/:kind_of and :message
+      # If :instance_of or :kind_of is specified, assert on the given type. 
+      #   Otherwise only assert that an exception is raised.
+      #   Note: The shorthand should_raise(LoadError) is equivalent to should_raise(:instance_of => LoadError)
+      # If :message is specified, will assert that exception.message =~ :message.
+      #
+      # Examples:
+      #   should_raise {a block}
+      #   should_raise(LoadError) {a block}
+      #   should_raise(:instance_of => LoadError) {a block}
+      #   should_raise(:kind_of => LoadError) {a block}
+      #   should_raise(:message => "no such file to load") {a block}
+      #   should_raise(:message => /load/) {a block}
+      #   should_raise(LoadError, :message => /load/) {a block}
+      #   should_raise(:kind_of => LoadError, :message => /load/) {a block}
+      #   should_raise(:instance_of => LoadError, :message => /load/) {a block}
+      def should_raise(*args, &block)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+
+        if args.first.is_a?(Class)
+          type  = args.first
+          exact = true
+        else
+          type  = opts[:instance_of] || opts[:kind_of]
+          exact = !!opts[:instance_of]
+        end
+        message = opts[:message]
+
+        # Make sure we don't have a false sense of security and bork if incorrect options are supplied.
+        [:message, :instance_of, :kind_of].each { |acceptable_arg| opts.delete(acceptable_arg) }
+        raise ArgumentError, "Unknown parameter(s): #{opts.keys.inspect}. Only :message, :instance_of and :kind_of are supported." if opts.size > 0
+
+        context "block #{block.inspect}" do # To avoid dupe test names. Any other ideas?
+          should_string  = "raise an exception"
+          should_string += " %s type #{type.inspect}" % (exact ? 'of' : 'descending from') if type
+          
+          should should_string do
+            begin
+              instance_eval &block
+            rescue Exception => ex
+              @raised_exception = ex
+            end
+            if @raised_exception && type
+              if exact
+                assert_instance_of type, @raised_exception
+              else
+                assert_kind_of type, @raised_exception
+              end
+            else
+              assert @raised_exception, "The block was expected to raise an exception, but didn't"
+            end
+          end
+        end
+
+        if message
+          context "raising an exception" do
+            setup do
+              begin
+                instance_eval &block
+              rescue Exception => ex
+                @raised_exception = ex
+              end
+            end
+
+            should "contain a message that matches #{message.inspect}" do
+              assert_match message, @raised_exception.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/woulda/should_raise.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require File.dirname(__FILE__) + '/should_raise/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::ShouldRaise::Macros
+end

data/lib/woulda/will_paginate/macros.rb

@@ -0,0 +1,18 @@
+module Woulda
+  module WillPaginate
+    module Macros
+      def should_have_per_page(count)
+        klass = self.name.gsub(/Test$/, '').constantize
+        context "#{klass}" do
+          should "respond to per_page" do
+            assert klass.respond_to?(:per_page), "#{klass} does not respond to :per_page"
+          end
+
+          should "have #{count} per page" do
+            assert_equal count, klass.per_page
+          end
+        end
+      end
+    end
+  end
+end

data/lib/woulda/will_paginate.rb

@@ -0,0 +1,6 @@
+require 'shoulda'
+require 'woulda/will_paginate/macros'
+
+Test::Unit::TestCase.class_eval do
+  extend Woulda::WillPaginate::Macros
+end

data/lib/woulda.rb

@@ -0,0 +1,17 @@
+woulda_dir = File.expand_path(File.dirname(__FILE__)) + '/woulda'
+
+# Standalone Macros
+require "#{woulda_dir}/should_raise"
+
+# Macros for gems and plugins
+require "#{woulda_dir}/acts_as_ferret" if defined? ActsAsFerret
+require "#{woulda_dir}/acts_as_list" if defined? ActiveRecord::Acts::List
+require "#{woulda_dir}/acts_as_paranoid" if defined? Caboose::Acts::Paranoid
+require "#{woulda_dir}/acts_as_taggable_on_steroids" if defined? ActiveRecord::Acts::Taggable
+require "#{woulda_dir}/attachment_fu" if defined? Technoweenie::AttachmentFu
+require "#{woulda_dir}/enumerations_mixin" if defined? ActiveRecord::Acts::Enumerated
+require "#{woulda_dir}/paperclip" if defined? Paperclip
+require "#{woulda_dir}/will_paginate" if defined? WillPaginate
+require "#{woulda_dir}/acts_as_solr" if defined? ActsAsSolr
+require "#{woulda_dir}/acts_as_state_machine" if defined? ScottBarron::Acts::StateMachine
+require "#{woulda_dir}/acts_as_xapian" if defined? ActsAsXapian

data/shoulda_macros/woulda_macros.rb

@@ -0,0 +1 @@
+require 'woulda'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: svenaas-woulda
+version: !ruby/object:Gem::Version 
+  version: 0.2.3
+platform: ruby
+authors: 
+- Sean Hussey
+- Josh Nichols
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-16 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.10.2
+    version: 
+description: |
+  Testing is love. Especially when done with "Shoulda":http://thoughtbot.com/projects/shoulda. Shoulda makes testing your Rails app pretty easy.
+  
+  There are tons of Rails plugins and gems out there. It should be easy to test your Rails app that uses these as well. That kind of support doesn't really belong in Shoulda itself, though.
+  
+  That's where Woulda comes in.
+
+email: 
+- sean@seanhussey.com
+- josh@technicalpickles.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- Rakefile
+- README.textile
+- VERSION.yml
+- shoulda_macros/woulda_macros.rb
+- lib/woulda/acts_as_ferret/macros.rb
+- lib/woulda/acts_as_ferret.rb
+- lib/woulda/acts_as_list/macros.rb
+- lib/woulda/acts_as_list.rb
+- lib/woulda/acts_as_paranoid/macros.rb
+- lib/woulda/acts_as_paranoid.rb
+- lib/woulda/acts_as_solr/macros.rb
+- lib/woulda/acts_as_solr.rb
+- lib/woulda/acts_as_state_machine/macros_new.rb
+- lib/woulda/acts_as_state_machine/macros_old.rb
+- lib/woulda/acts_as_state_machine.rb
+- lib/woulda/acts_as_taggable_on_steroids/macros.rb
+- lib/woulda/acts_as_taggable_on_steroids.rb
+- lib/woulda/acts_as_xapian/macros.rb
+- lib/woulda/acts_as_xapian.rb
+- lib/woulda/attachment_fu/macros.rb
+- lib/woulda/attachment_fu.rb
+- lib/woulda/enumerations_mixin/macros.rb
+- lib/woulda/enumerations_mixin.rb
+- lib/woulda/paperclip/macros.rb
+- lib/woulda/paperclip.rb
+- lib/woulda/should_raise/macros.rb
+- lib/woulda/should_raise.rb
+- lib/woulda/will_paginate/macros.rb
+- lib/woulda/will_paginate.rb
+- lib/woulda.rb
+has_rdoc: true
+homepage: http://github.com/seanhussey/woulda
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: woulda
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: woulda is a home for shoulda macros that don't belong in the main shoulda library
+test_files: []
+