0
@@ -10,7 +10,7 @@ Assertions:: Many common rails testing idioms have been distilled into a set of
0
 
0
 = Usage
0
 
0
-=== Context Helpers (Shoulda::Context)
0
+=== Context Helpers (ThoughtBot::Shoulda::Context)
0
 
0
 Stop killing your fingers with all of those underscores...  Name your tests with plain sentences!
0
 
0
@@ -43,7 +43,7 @@ Produces the following test methods:
0
 
0
 So readable!
0
 
0
-=== ActiveRecord Tests (Shoulda::ActiveRecord)
0
+=== ActiveRecord Tests (ThoughtBot::Shoulda::ActiveRecord)
0
 
0
 Quick macro tests for your ActiveRecord associations and validations:
0
 
0
@@ -73,7 +73,7 @@ Quick macro tests for your ActiveRecord associations and validations:
0
 
0
 Makes TDD so much easier.
0
 
0
-=== Controller Tests (Shoulda::Controller::ClassMethods)
0
+=== Controller Tests (ThoughtBot::Shoulda::Controller::ClassMethods)
0
 
0
 Macros to test the most common controller patterns...
0
 
0
@@ -105,7 +105,7 @@ Test entire controllers in a few lines...
0
 
0
 should_be_restful generates 40 tests on the fly, for both html and xml requests.
0
 
0
-=== Helpful Assertions (Shoulda::General)
0
+=== Helpful Assertions (ThoughtBot::Shoulda::General)
0
 
0
 More to come here, but have fun with what's there.
0
 

0
@@ -6,7 +6,7 @@ require 'rake/rdoctask'
0
 
0
 Rake::TestTask.new do |t|
0
   t.libs << 'lib'
0
-  t.pattern = 'test/**/*_test.rb'
0
+  t.pattern = 'test/{unit,functional,other}/**/*_test.rb'
0
   t.verbose = false
0
 end
0
 

0
@@ -1,144 +1,43 @@
0
-require 'shoulda/context'
0
+require 'shoulda/gem/shoulda'
0
 require 'shoulda/private_helpers'
0
 require 'shoulda/general'
0
+require 'shoulda/active_record_helpers'
0
+require 'shoulda/controller_tests/controller_tests.rb'
0
 require 'yaml'
0
 
0
-require 'shoulda/active_record_helpers'                if defined?(ActiveRecord)
0
-require 'shoulda/controller_tests/controller_tests.rb' if defined?(ActionController)
0
-
0
-config_files = []
0
-config_files << "shoulda.conf"
0
-config_files << File.join("test", "shoulda.conf")
0
-config_files << File.join(RAILS_ROOT, "test", "shoulda.conf") if defined?(RAILS_ROOT) 
0
-config_files << File.join(ENV["HOME"], ".shoulda.conf")       if ENV["HOME"]
0
-
0
 shoulda_options = {}
0
-config_files.each do |file|
0
-  shoulda_options.merge!(YAML.load_file(file).symbolize_keys) if File.exists? file
0
-end
0
 
0
-require 'shoulda/color' if shoulda_options[:color]
0
+possible_config_paths = []
0
+possible_config_paths << File.join(ENV["HOME"], ".shoulda.conf")       if ENV["HOME"]
0
+possible_config_paths << "shoulda.conf"
0
+possible_config_paths << File.join("test", "shoulda.conf")
0
+possible_config_paths << File.join(RAILS_ROOT, "test", "shoulda.conf") if defined?(RAILS_ROOT) 
0
 
0
-module Shoulda
0
-  class << self
0
-    attr_accessor :current_context
0
+possible_config_paths.each do |config_file|
0
+  if File.exists? config_file
0
+    shoulda_options = YAML.load_file(config_file).symbolize_keys
0
+    break
0
   end
0
+end
0
 
0
-  # Should statements are just syntactic sugar over normal Test::Unit test methods.  A should block 
0
-  # contains all the normal code and assertions you're used to seeing, with the added benefit that 
0
-  # they can be wrapped inside context blocks (see below).
0
-  #
0
-  # == Example:
0
-  #
0
-  #  class UserTest << Test::Unit::TestCase
0
-  #    
0
-  #    def setup
0
-  #      @user = User.new("John", "Doe")
0
-  #    end
0
-  #
0
-  #    should "return its full name"
0
-  #      assert_equal 'John Doe', @user.full_name
0
-  #    end
0
-  #  
0
-  #  end
0
-  #   
0
-  # ...will produce the following test:
0
-  # * <tt>"test: User should return its full name. "</tt>
0
-  #
0
-  # Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
0
-
0
-  def should(name, &blk)
0
-    should_eventually(name) && return unless block_given?
0
-    
0
-    if Shoulda.current_context
0
-      Shoulda.current_context.should(name, &blk)
0
-    else
0
-      context_name = self.name.gsub(/Test/, "")
0
-      context = Shoulda::Context.new(context_name, self) do
0
-        should(name, &blk)
0
-      end
0
-      context.build
0
-    end
0
-  end
0
+require 'shoulda/color' if shoulda_options[:color]
0
 
0
-  # Just like should, but never runs, and instead prints a differed message in the Test::Unit output.
0
-  def should_eventually(name, &blk)
0
-    context_name = self.name.gsub(/Test/, "")
0
-    context = Shoulda::Context.new(context_name, self) do
0
-      should_eventually(name, &blk)
0
-    end
0
-    context.build
0
-  end
0
+module Test # :nodoc: all
0
+  module Unit 
0
+    class TestCase
0
 
0
-  # A context block groups should statements under a common set of setup/teardown methods.  
0
-  # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
0
-  # and readability of your test code.
0
-  #
0
-  # A context block can contain setup, should, should_eventually, and teardown blocks.
0
-  #
0
-  #  class UserTest << Test::Unit::TestCase
0
-  #    context "A User instance" do
0
-  #      setup do
0
-  #        @user = User.find(:first)
0
-  #      end
0
-  #    
0
-  #      should "return its full name"
0
-  #        assert_equal 'John Doe', @user.full_name
0
-  #      end
0
-  #    end
0
-  #  end
0
-  #
0
-  # This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
0
-  #
0
-  # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each 
0
-  # should statement.  They then run their teardown blocks from in to out after each should statement.
0
-  #
0
-  #  class UserTest << Test::Unit::TestCase
0
-  #    context "A User instance" do
0
-  #      setup do
0
-  #        @user = User.find(:first)
0
-  #      end
0
-  #    
0
-  #      should "return its full name"
0
-  #        assert_equal 'John Doe', @user.full_name
0
-  #      end
0
-  #    
0
-  #      context "with a profile" do
0
-  #        setup do
0
-  #          @user.profile = Profile.find(:first)
0
-  #        end
0
-  #      
0
-  #        should "return true when sent :has_profile?"
0
-  #          assert @user.has_profile?
0
-  #        end
0
-  #      end
0
-  #    end
0
-  #  end
0
-  #
0
-  # This code will produce the following methods 
0
-  # * <tt>"test: A User instance should return its full name. "</tt>
0
-  # * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
0
-  #
0
-  # <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt> 
0
-  # tests</b>.  This means you do not have to fully commit to the context/should syntax in a test file.
0
+      include ThoughtBot::Shoulda::General
0
+      include ThoughtBot::Shoulda::Controller
0
 
0
-  def context(name, &blk)
0
-    if Shoulda.current_context
0
-      Shoulda.current_context.context(name, &blk)
0
-    else
0
-      context = Shoulda::Context.new(name, self, &blk)
0
-      context.build
0
+      extend ThoughtBot::Shoulda::ActiveRecord
0
     end
0
   end
0
 end
0
 
0
-module Test # :nodoc: all
0
-  module Unit 
0
-    class TestCase
0
-      include Shoulda::General
0
-      include Shoulda::Controller
0
-      extend  Shoulda::ActiveRecord
0
+module ActionController #:nodoc: all
0
+  module Integration
0
+    class Session 
0
+      include ThoughtBot::Shoulda::General
0
     end
0
   end
0
 end
0
-

0
@@ -1,602 +1,604 @@
0
-module Shoulda
0
-  # = Macro test helpers for your active record models
0
-  #
0
-  # These helpers will test most of the validations and associations for your ActiveRecord models.
0
-  #
0
-  #   class UserTest < Test::Unit::TestCase
0
-  #     should_require_attributes :name, :phone_number
0
-  #     should_not_allow_values_for :phone_number, "abcd", "1234"
0
-  #     should_allow_values_for :phone_number, "(123) 456-7890"
0
-  #     
0
-  #     should_protect_attributes :password
0
-  #     
0
-  #     should_have_one :profile
0
-  #     should_have_many :dogs
0
-  #     should_have_many :messes, :through => :dogs
0
-  #     should_belong_to :lover
0
-  #   end
0
-  #
0
-  # For all of these helpers, the last parameter may be a hash of options.
0
-  #
0
-  module ActiveRecord
0
-    # Ensures that the model cannot be saved if one of the attributes listed is not present.
0
-    #
0
-    # Options:
0
-    # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
0
-    #   Regexp or string.  Default = <tt>/blank/</tt>
0
-    #
0
-    # Example:
0
-    #   should_require_attributes :name, :phone_number
0
-    #
0
-    def should_require_attributes(*attributes)
0
-      message = get_options!(attributes, :message)
0
-      message ||= /blank/
0
-      klass = model_class
0
-      
0
-      attributes.each do |attribute|
0
-        should "require #{attribute} to be set" do
0
-          object = klass.new
0
-          object.send("#{attribute}=", nil)
0
-          assert !object.valid?, "#{klass.name} does not require #{attribute}."
0
-          assert object.errors.on(attribute), "#{klass.name} does not require #{attribute}."
0
-          assert_contains(object.errors.on(attribute), message)
0
+module ThoughtBot # :nodoc:
0
+  module Shoulda # :nodoc:
0
+    # = Macro test helpers for your active record models
0
+    #
0
+    # These helpers will test most of the validations and associations for your ActiveRecord models.
0
+    #
0
+    #   class UserTest < Test::Unit::TestCase
0
+    #     should_require_attributes :name, :phone_number
0
+    #     should_not_allow_values_for :phone_number, "abcd", "1234"
0
+    #     should_allow_values_for :phone_number, "(123) 456-7890"
0
+    #     
0
+    #     should_protect_attributes :password
0
+    #     
0
+    #     should_have_one :profile
0
+    #     should_have_many :dogs
0
+    #     should_have_many :messes, :through => :dogs
0
+    #     should_belong_to :lover
0
+    #   end
0
+    #
0
+    # For all of these helpers, the last parameter may be a hash of options.
0
+    #
0
+    module ActiveRecord
0
+      # Ensures that the model cannot be saved if one of the attributes listed is not present.
0
+      #
0
+      # Options:
0
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
0
+      #   Regexp or string.  Default = <tt>/blank/</tt>
0
+      #
0
+      # Example:
0
+      #   should_require_attributes :name, :phone_number
0
+      #
0
+      def should_require_attributes(*attributes)
0
+        message = get_options!(attributes, :message)
0
+        message ||= /blank/
0
+        klass = model_class
0
+        
0
+        attributes.each do |attribute|
0
+          should "require #{attribute} to be set" do
0
+            object = klass.new
0
+            object.send("#{attribute}=", nil)
0
+            assert !object.valid?, "#{klass.name} does not require #{attribute}."
0
+            assert object.errors.on(attribute), "#{klass.name} does not require #{attribute}."
0
+            assert_contains(object.errors.on(attribute), message)
0
+          end
0
         end
0
       end
0
-    end
0
 
0
-    # Ensures that the model cannot be saved if one of the attributes listed is not unique.
0
-    # Requires an existing record
0
-    #
0
-    # Options:
0
-    # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
0
-    #   Regexp or string.  Default = <tt>/taken/</tt>
0
-    # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
0
-    #
0
-    # Examples:
0
-    #   should_require_unique_attributes :keyword, :username
0
-    #   should_require_unique_attributes :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
0
-    #   should_require_unique_attributes :email, :scoped_to => :name
0
-    #   should_require_unique_attributes :address, :scoped_to => [:first_name, :last_name]
0
-    #
0
-    def should_require_unique_attributes(*attributes)
0
-      message, scope = get_options!(attributes, :message, :scoped_to)
0
-      scope = [*scope].compact
0
-      message ||= /taken/
0
-      
0
-      klass = model_class
0
-      attributes.each do |attribute|
0
-        attribute = attribute.to_sym
0
-        should "require unique value for #{attribute}#{" scoped to #{scope.join(', ')}" if scope}" do
0
-          assert existing = klass.find(:first), "Can't find first #{klass}"
0
-          object = klass.new
0
-          
0
-          object.send(:"#{attribute}=", existing.send(attribute))
0
-          if !scope.blank?