shoulda 2.0.6 → 2.9.0

data/test/matchers/validate_uniqueness_of_matcher_test.rb

@@ -0,0 +1,141 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ValidateUniquenessOfMatcherTest < Test::Unit::TestCase # :nodoc:
+
+  context "a unique attribute" do
+    setup do
+      @model = define_model(:example, :attr  => :string,
+                                           :other => :integer) do
+        validates_uniqueness_of :attr
+      end.new
+    end
+
+    context "with an existing value" do
+      setup do
+        @existing = Example.create!(:attr => 'value', :other => 1)
+      end
+
+      should "require a unique value for that attribute" do
+        assert_accepts validate_uniqueness_of(:attr), @model
+      end
+
+      should "pass when the subject is an existing record" do
+        assert_accepts validate_uniqueness_of(:attr), @existing
+      end
+
+      should "fail when a scope is specified" do
+        assert_rejects validate_uniqueness_of(:attr).scoped_to(:other), @model
+      end
+    end
+
+    context "without an existing value" do
+      setup do
+        assert_nil Example.find(:first)
+      end
+
+      should "fail to require a unique value" do
+        assert_rejects validate_uniqueness_of(:attr), @model
+      end
+    end
+  end
+
+  context "a unique attribute with a custom error and an existing value" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_uniqueness_of :attr, :message => 'Bad value'
+      end.new
+      Example.create!
+    end
+
+    should "fail when checking the default message" do
+      assert_rejects validate_uniqueness_of(:attr), @model
+    end
+
+    should "fail when checking a message that doesn't match" do
+      assert_rejects validate_uniqueness_of(:attr).with_message(/abc/i), @model
+    end
+
+    should "pass when checking a message that matches" do
+      assert_accepts validate_uniqueness_of(:attr).with_message(/bad/i), @model
+    end
+  end
+
+  context "a scoped unique attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr   => :string,
+                                           :scope1 => :integer,
+                                           :scope2 => :integer) do
+        validates_uniqueness_of :attr, :scope => [:scope1, :scope2]
+      end.new
+      @existing = Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2)
+    end
+
+    should "pass when the correct scope is specified" do
+      assert_accepts validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2),
+        @model
+    end
+
+    should "pass when the subject is an existing record" do
+      assert_accepts validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2),
+        @existing
+    end
+
+    should "fail when a different scope is specified" do
+      assert_rejects validate_uniqueness_of(:attr).scoped_to(:scope1), @model
+    end
+
+    should "fail when no scope is specified" do
+      assert_rejects validate_uniqueness_of(:attr), @model
+    end
+
+    should "fail when a non-existent attribute is specified as a scope" do
+      assert_rejects validate_uniqueness_of(:attr).scoped_to(:fake), @model
+    end
+  end
+
+  context "a non-unique attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr => :string).new
+      Example.create!(:attr => 'value')
+    end
+
+    should "not require a unique value for that attribute" do
+      assert_rejects validate_uniqueness_of(:attr), @model
+    end
+  end
+
+  context "a case sensitive unique attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr  => :string) do
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    should "not require a unique, case-insensitive value for that attribute" do
+      assert_rejects validate_uniqueness_of(:attr).case_insensitive, @model
+    end
+
+    should "require a unique, case-sensitive value for that attribute" do
+      assert_accepts validate_uniqueness_of(:attr), @model
+    end
+  end
+
+  context "a case sensitive unique integer attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr  => :integer) do
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    should "require a unique, case-insensitive value for that attribute" do
+      assert_accepts validate_uniqueness_of(:attr).case_insensitive, @model
+    end
+
+    should "require a unique, case-sensitive value for that attribute" do
+      assert_accepts validate_uniqueness_of(:attr), @model
+    end
+  end
+
+end

data/test/model_builder.rb

@@ -0,0 +1,61 @@
+class Test::Unit::TestCase  
+  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_model_class(class_name, &block)
+    klass = Class.new(ActiveRecord::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(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 teardown_with_models
+    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
+
+    teardown_without_models
+  end
+  alias_method :teardown_without_models, :teardown
+  alias_method :teardown, :teardown_with_models
+end

data/test/other/autoload_macro_test.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AutoloadMacroTest < Test::Unit::TestCase # :nodoc:
+  context "The macro auto-loader" do
+    should "load macros from the plugins" do
+      assert self.class.respond_to?('plugin_macro')
+    end
+
+    should "load macros from the gems" do
+      assert self.class.respond_to?('gem_macro')
+    end
+
+    should "load custom macros from ROOT/test/shoulda_macros" do
+      assert self.class.respond_to?('custom_macro')
+    end
+  end
+end
+

data/test/other/helpers_test.rb

@@ -180,4 +180,62 @@ class HelpersTest < Test::Unit::TestCase # :nodoc:
       end
     end
   end
+
+  context "a matching matcher" do
+    setup do
+      @matcher = stub('matcher', :matches?                 => true,
+                                 :failure_message          => 'bad failure message',
+                                 :negative_failure_message => 'big time failure')
+    end
+
+    should "pass when given to assert_accepts" do
+      assert_accepts @matcher, 'target'
+    end
+
+    context "when given to assert_rejects" do
+      setup do
+        begin
+          assert_rejects @matcher, 'target'
+        rescue Test::Unit::AssertionFailedError => @error
+        end
+      end
+
+      should "fail" do
+        assert_not_nil @error
+      end
+
+      should "use the error message from the matcher" do
+        assert_equal 'big time failure', @error.message
+      end
+    end
+  end
+
+  context "a non-matching matcher" do
+    setup do
+      @matcher = stub('matcher', :matches?                 => false,
+                                 :failure_message          => 'big time failure',
+                                 :negative_failure_message => 'bad failure message')
+    end
+
+    should "pass when given to assert_rejects" do
+      assert_rejects @matcher, 'target'
+    end
+
+    context "when given to assert_accepts" do
+      setup do
+        begin
+          assert_accepts @matcher, 'target'
+        rescue Test::Unit::AssertionFailedError => @error
+        end
+      end
+
+      should "fail" do
+        assert_not_nil @error
+      end
+
+      should "use the error message from the matcher" do
+        assert_equal 'big time failure', @error.message
+      end
+    end
+  end
 end

data/test/other/private_helpers_test.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class PrivateHelpersTest < Test::Unit::TestCase # :nodoc:
-  include ThoughtBot::Shoulda::Private
+  include Shoulda::Private
   context "get_options!" do
     should "remove opts from args" do
       args = [:a, :b, {}]

data/test/other/should_test.rb

@@ -119,21 +119,21 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
 
   def test_should_create_a_new_context
     assert_nothing_raised do
-      Thoughtbot::Shoulda::Context.new("context name", self) do; end
+      Shoulda::Context.new("context name", self) do; end
     end
   end
 
   def test_should_create_a_nested_context
     assert_nothing_raised do
-      parent = Thoughtbot::Shoulda::Context.new("Parent", self) do; end
-      child  = Thoughtbot::Shoulda::Context.new("Child", parent) do; end
+      parent = Shoulda::Context.new("Parent", self) do; end
+      child  = Shoulda::Context.new("Child", parent) do; end
     end
   end
 
   def test_should_name_a_contexts_correctly
-    parent     = Thoughtbot::Shoulda::Context.new("Parent", self) do; end
-    child      = Thoughtbot::Shoulda::Context.new("Child", parent) do; end
-    grandchild = Thoughtbot::Shoulda::Context.new("GrandChild", child) do; end
+    parent     = Shoulda::Context.new("Parent", self) do; end
+    child      = Shoulda::Context.new("Child", parent) do; end
+    grandchild = Shoulda::Context.new("GrandChild", child) do; end
 
     assert_equal "Parent", parent.full_name
     assert_equal "Parent Child", child.full_name
@@ -143,7 +143,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   # Should statements
 
   def test_should_have_should_hashes_when_given_should_statements
-    context = Thoughtbot::Shoulda::Context.new("name", self) do
+    context = Shoulda::Context.new("name", self) do
       should "be good" do; end
       should "another" do; end
     end
@@ -155,7 +155,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   # setup and teardown
 
   def test_should_capture_setup_and_teardown_blocks
-    context = Thoughtbot::Shoulda::Context.new("name", self) do
+    context = Shoulda::Context.new("name", self) do
       setup    do; "setup";    end
       teardown do; "teardown"; end
     end
@@ -167,7 +167,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   # building
 
   def test_should_create_shoulda_test_for_each_should_on_build
-    context = Thoughtbot::Shoulda::Context.new("name", self) do
+    context = Shoulda::Context.new("name", self) do
       should "one" do; end
       should "two" do; end
     end
@@ -178,7 +178,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
 
   def test_should_create_test_methods_on_build
     tu_class = Test::Unit::TestCase
-    context = Thoughtbot::Shoulda::Context.new("A Context", tu_class) do
+    context = Shoulda::Context.new("A Context", tu_class) do
       should "define the test" do; end
     end
 
@@ -188,7 +188,7 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
 
   def test_should_create_test_methods_on_build_when_subcontext
     tu_class = Test::Unit::TestCase
-    context = Thoughtbot::Shoulda::Context.new("A Context", tu_class) do
+    context = Shoulda::Context.new("A Context", tu_class) do
       context "with a child" do
         should "define the test" do; end
       end
@@ -203,21 +203,21 @@ class ShouldTest < Test::Unit::TestCase # :nodoc:
   def test_should_create_a_new_context_and_build_it_on_Test_Unit_context
     c = mock("context")
     c.expects(:build)
-    Thoughtbot::Shoulda::Context.expects(:new).with("foo", kind_of(Class)).returns(c)
+    Shoulda::Context.expects(:new).with("foo", kind_of(Class)).returns(c)
     self.class.context "foo" do; end
   end
 
   def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should
     s = mock("test")
-    Thoughtbot::Shoulda::Context.any_instance.expects(:should).with("rock", {}).returns(s)
-    Thoughtbot::Shoulda::Context.any_instance.expects(:build)
+    Shoulda::Context.any_instance.expects(:should).with("rock", {}).returns(s)
+    Shoulda::Context.any_instance.expects(:build)
     self.class.should "rock" do; end
   end
 
   def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should_eventually
     s = mock("test")
-    Thoughtbot::Shoulda::Context.any_instance.expects(:should_eventually).with("rock").returns(s)
-    Thoughtbot::Shoulda::Context.any_instance.expects(:build)
+    Shoulda::Context.any_instance.expects(:should_eventually).with("rock").returns(s)
+    Shoulda::Context.any_instance.expects(:build)
     self.class.should_eventually "rock" do; end
   end
 

data/test/rails_root/app/controllers/posts_controller.rb

@@ -1,7 +1,7 @@
 class PostsController < ApplicationController
   before_filter :ensure_logged_in
   before_filter :load_user
-  
+
   def index
     @posts = @user.posts
 
@@ -19,6 +19,7 @@ class PostsController < ApplicationController
 
   def show
     @post = @user.posts.find(params[:id])
+    @false_flag = false
 
     respond_to do |format|
       format.html { render :layout => 'wide' }
@@ -68,17 +69,17 @@ class PostsController < ApplicationController
   def destroy
     @post = @user.posts.find(params[:id])
     @post.destroy
-    
+
     flash[:notice] = "Post was removed"
-    
+
     respond_to do |format|
       format.html { redirect_to user_posts_url(@post.user) }
       format.xml  { head :ok }
     end
   end
-  
+
   private
-  
+
   def load_user
     @user = User.find(params[:user_id])
   end

data/test/rails_root/app/models/pets/dog.rb

@@ -0,0 +1,10 @@
+module Pets
+  class Dog < ActiveRecord::Base
+    belongs_to :user, :foreign_key => :owner_id
+    belongs_to :address, :dependent => :destroy
+    has_many :treats
+    has_and_belongs_to_many :fleas, :join_table => :fleas
+    validates_presence_of :treats, :fleas
+    validates_presence_of :owner_id
+  end
+end

data/test/rails_root/app/models/treat.rb

@@ -0,0 +1,3 @@
+class Treat < ActiveRecord::Base
+  
+end