challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
+  context "a unique attribute" do
+    before do
+      @model = define_model(:example, :attr  => :string,
+                                      :other => :integer) do
+        attr_accessible :attr, :other
+        validates_uniqueness_of :attr
+      end.new
+    end
+
+    context "with an existing value" do
+      before do
+        @existing = Example.create!(:attr => 'value', :other => 1)
+      end
+
+      it "should require a unique value for that attribute" do
+        @model.should validate_uniqueness_of(:attr)
+      end
+
+      it "should pass when the subject is an existing record" do
+        @existing.should validate_uniqueness_of(:attr)
+      end
+
+      it "should fail when a scope is specified" do
+        @model.should_not validate_uniqueness_of(:attr).scoped_to(:other)
+      end
+    end
+
+    context "without an existing value" do
+      before do
+        Example.first.should be_nil
+        @matcher = validate_uniqueness_of(:attr)
+      end
+
+      it "does not not require a created instance" do
+        @model.should @matcher
+      end
+    end
+  end
+
+  context "a unique attribute with a custom error and an existing value" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :message => 'Bad value'
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should fail when checking the default message" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+
+    it "should fail when checking a message that doesn't match" do
+      @model.should_not validate_uniqueness_of(:attr).with_message(/abc/i)
+    end
+
+    it "should pass when checking a message that matches" do
+      @model.should validate_uniqueness_of(:attr).with_message(/bad/i)
+    end
+  end
+
+  context "a scoped unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr   => :string,
+                                      :scope1 => :integer,
+                                      :scope2 => :integer,
+                                      :other => :integer) do
+        attr_accessible :attr, :scope1, :scope2, :other
+        validates_uniqueness_of :attr, :scope => [:scope1, :scope2]
+      end.new
+      @existing = Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2, :other => 3)
+    end
+
+    it "should pass when the correct scope is specified" do
+      @model.should validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2)
+    end
+
+    it "should pass when the subject is an existing record" do
+      @existing.should validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2)
+    end
+
+    it "should fail when too narrow of a scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2, :other)
+    end
+
+    it "should fail when too broad of a scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:scope1)
+    end
+
+    it "should fail when a different scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:other)
+    end
+
+    it "should fail when no scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+
+    it "should fail when a non-existent attribute is specified as a scope" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:fake)
+    end
+  end
+
+  context "a non-unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        attr_accessible :attr
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should not require a unique value for that attribute" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "a case sensitive unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr  => :string) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should not require a unique, case-insensitive value for that attribute" do
+      @model.should_not validate_uniqueness_of(:attr).case_insensitive
+    end
+
+    it "should require a unique, case-sensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "a case sensitive unique integer attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr  => :integer) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should require a unique, case-insensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr).case_insensitive
+    end
+
+    it "should require a unique, case-sensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "when the validation allows nil" do
+    before do
+      @model = define_model(:example, :attr  => :integer) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :allow_nil => true
+      end.new
+    end
+
+    context "when there is an existing entry with a nil" do
+      it "should allow_nil" do
+        Example.create!(:attr => nil)
+        @model.should validate_uniqueness_of(:attr).allow_nil
+      end
+    end
+
+    it "should create a nil and verify that it is allowed" do
+      @model.should validate_uniqueness_of(:attr).allow_nil
+      Example.all.any?{ |instance| instance.attr.nil? }
+    end
+  end
+
+  context "when the validation does not allow a nil" do
+    before do
+      @model = define_model(:example, :attr  => :integer) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr
+      end.new
+    end
+
+    context "when there is an existing entry with a nil" do
+      it "should not allow_nil" do
+        Example.create!(:attr => nil)
+        @model.should_not validate_uniqueness_of(:attr).allow_nil
+      end
+    end
+
+    it "should not allow_nil" do
+      @model.should_not validate_uniqueness_of(:attr).allow_nil
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/matchers/action_controller/filter_param_matcher_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::FilterParamMatcher do
+  it 'accepts filtering a filtered parameter' do
+    filter(:secret)
+
+    nil.should filter_param(:secret)
+  end
+
+  it 'rejects filtering an unfiltered parameter' do
+    filter(:secret)
+    matcher = filter_param(:other)
+
+    matcher.matches?(nil).should be_false
+
+    matcher.failure_message_for_should.should =~ /Expected other to be filtered.*secret/
+  end
+
+  def filter(param)
+    Rails.application.config.filter_parameters = [param]
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/matchers/action_controller/redirect_to_matcher_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RedirectToMatcher do
+  context 'a controller that redirects' do
+    it 'accepts redirecting to that url' do
+      controller_redirecting_to('/some/url').should redirect_to('/some/url')
+    end
+
+    it 'rejects redirecting to a different url' do
+      controller_redirecting_to('/some/url').
+        should_not redirect_to('/some/other/url')
+    end
+
+    it 'accepts redirecting to that url in a block' do
+      controller_redirecting_to('/some/url').
+        should redirect_to('somewhere') { '/some/url' }
+    end
+
+    it 'rejects redirecting to a different url in a block' do
+      controller_redirecting_to('/some/url').
+        should_not redirect_to('somewhere else') { '/some/other/url' }
+    end
+
+    def controller_redirecting_to(url)
+      build_response { redirect_to url }
+    end
+  end
+
+  context 'a controller that does not redirect' do
+    it 'rejects redirecting to a url' do
+      controller = build_response { render :text => 'hello' }
+
+      controller.should_not redirect_to('/some/url')
+    end
+  end
+
+  it 'provides the correct description when provided a block' do
+    matcher = redirect_to('somewhere else') { '/some/other/url' }
+
+    matcher.description.should == 'redirect to somewhere else'
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/matchers/action_controller/render_template_matcher_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RenderTemplateMatcher do
+  include ActionController::TemplateAssertions
+
+  context 'a controller that renders a template' do
+    it 'accepts rendering that template' do
+      controller_with_show.should render_template(:show)
+    end
+
+    it 'rejects rendering a different template' do
+      controller_with_show.should_not render_template(:index)
+    end
+
+    it 'accepts rendering that template in the given context' do
+      controller_with_show.should render_template(:show).in_context(self)
+    end
+
+    it 'rejects rendering a different template in the given context' do
+      controller_with_show.should_not render_template(:index).in_context(self)
+    end
+
+    def controller_with_show
+      build_response(:action => 'show') { render }
+    end
+  end
+
+  context 'a controller that renders a partial' do
+    it 'accepts rendering that partial' do
+      controller_with_customer_partial.
+        should render_template(:partial => '_customer')
+    end
+
+    it 'rejects rendering a different template' do
+      controller_with_customer_partial.
+        should_not render_template(:partial => '_client')
+    end
+
+    it 'accepts rendering that template in the given context' do
+      controller_with_customer_partial.
+        should render_template(:partial => '_customer').in_context(self)
+    end
+
+    it 'rejects rendering a different template in the given context' do
+      controller_with_customer_partial.
+        should_not render_template(:partial => '_client').in_context(self)
+    end
+
+    def controller_with_customer_partial
+      build_response(:partial => '_customer') { render :partial => 'customer' }
+    end
+  end
+
+  context 'a controller that does not render partials' do
+    it 'accepts not rendering a partial' do
+      controller = build_response(:action => 'show') { render }
+
+      controller.should render_template(:partial => false)
+    end
+  end
+
+  context 'a controller that renders a partial several times' do
+    it 'accepts rendering that partial twice' do
+      controller = build_response(:partial => '_customer') do
+        render :partial => 'customer', :collection => [1,2]
+      end
+
+      controller.should render_template(:partial => '_customer', :count => 2)
+    end
+  end
+
+  context 'a controller that does not render a template' do
+    it 'rejects rendering a template' do
+      build_response { render :nothing => true }.
+        should_not render_template(:show)
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/matchers/action_controller/render_with_layout_matcher_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher do
+  include ActionController::TemplateAssertions
+
+  context 'a controller that renders with a layout' do
+    it 'accepts rendering with any layout' do
+      controller_with_wide_layout.should render_with_layout
+    end
+
+    it 'accepts rendering with that layout' do
+      controller_with_wide_layout.should render_with_layout(:wide)
+    end
+
+    it 'rejects rendering with another layout' do
+      controller_with_wide_layout.should_not render_with_layout(:other)
+    end
+
+    def controller_with_wide_layout
+      create_view('layouts/wide.html.erb', 'some content, <%= yield %>')
+      build_response { render :layout => 'wide' }
+    end
+  end
+
+  context 'a controller that renders without a layout' do
+
+    it 'rejects rendering with a layout' do
+      controller_without_layout = build_response { render :layout => false }
+
+      controller_without_layout.should_not render_with_layout
+    end
+  end
+
+  context 'a controller that renders a partial' do
+    it 'rejects rendering with a layout' do
+      controller_with_partial = build_response { render :partial => 'partial' }
+
+      controller_with_partial.should_not render_with_layout
+    end
+  end
+
+  context 'given a context with layouts' do
+    it 'accepts that layout in that context' do
+      set_in_context_layout('happy')
+
+      controller_without_layout.should render_with_layout('happy').in_context(self)
+    end
+
+    def set_in_context_layout(layout)
+      @layouts = Hash.new(0)
+      @layouts[layout] = 1
+    end
+
+    def controller_without_layout
+      build_response { render :layout => false }
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/matchers/action_controller/respond_with_matcher_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RespondWithMatcher do
+  statuses = { :success => 200, :redirect => 301, :missing => 404, :error => 500,
+    :not_implemented => 501 }
+
+  statuses.each do |human_name, numeric_code|
+    context "a controller responding with #{human_name}" do
+      it 'accepts responding with a numeric response code' do
+        controller_with_status(numeric_code).should respond_with(numeric_code)
+      end
+
+      it 'accepts responding with a symbol response code' do
+        controller_with_status(numeric_code).should respond_with(human_name)
+      end
+
+      it 'rejects responding with another status' do
+        another_status = statuses.except(human_name).keys.first
+
+        controller_with_status(numeric_code).
+          should_not respond_with(another_status)
+      end
+    end
+  end
+
+  def controller_with_status(status)
+    build_response do
+      render :text => 'text', :status => status
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/matchers/action_controller/route_matcher_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RouteMatcher do
+  context 'given a controller with a defined glob url' do
+    it 'accepts glob route' do
+      controller = define_controller('Examples').new
+
+      define_routes do
+        match 'examples/*id', :to => 'examples#example'
+      end
+
+      controller.should route(:get, '/examples/foo/bar').
+        to(:action => 'example', :id => 'foo/bar')
+    end
+  end
+
+  context 'given a controller with a defined route' do
+
+    it 'accepts routing the correct path to the correct parameters' do
+      route_examples_to_examples.should route(:get, '/examples/1').
+        to(:action => 'example', :id => '1')
+    end
+
+    it 'accepts a symbol controller' do
+      route_examples_to_examples
+      Object.new.should route(:get, '/examples/1').
+        to(:controller => :examples, :action => 'example', :id => '1')
+    end
+
+    it 'accepts a symbol action' do
+      route_examples_to_examples.should route(:get, '/examples/1').
+        to(:action => :example, :id => '1')
+    end
+
+    it 'accepts a non-string parameter' do
+      route_examples_to_examples.should route(:get, '/examples/1').
+        to(:action => 'example', :id => 1)
+    end
+
+    it 'rejects an undefined route' do
+      route_examples_to_examples.
+        should_not route(:get, '/bad_route').to(:var => 'value')
+    end
+
+    it 'rejects a route for another controller' do
+      route_examples_to_examples
+      other = define_controller('Other').new
+      other.should_not route(:get, '/examples/1').
+        to(:action => 'example', :id => '1')
+    end
+
+    it 'rejects a route for different parameters' do
+      route_examples_to_examples.should_not route(:get, '/examples/1').
+        to(:action => 'other', :id => '1')
+    end
+
+    def route_examples_to_examples
+      define_routes do
+        get 'examples/:id', :to => 'examples#example'
+      end
+
+      define_controller('Examples').new
+    end
+  end
+end

data/vendor/bundle/gems/shoulda-matchers-2.1.0/spec/shoulda/matchers/action_controller/set_session_matcher_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::SetSessionMatcher do
+  context 'a controller that sets a session variable' do
+    it 'accepts assigning to that variable' do
+      controller_with_session(:var => 'hi').should set_session(:var)
+    end
+
+    it 'accepts assigning the correct value to that variable' do
+      controller_with_session(:var => 'hi').should set_session(:var).to('hi')
+    end
+
+    it 'rejects assigning another value to that variable' do
+      controller_with_session(:var => 'hi').should_not set_session(:var).to('other')
+    end
+
+    it 'rejects assigning to another variable' do
+      controller_with_session(:var => 'hi').should_not set_session(:other)
+    end
+
+    it 'accepts assigning nil to another variable' do
+      controller_with_session(:var => 'hi').should set_session(:other).to(nil)
+    end
+
+    it 'accepts assigning false to that variable' do
+      controller_with_session(:var => false).should set_session(:var).to(false)
+    end
+
+    it 'accepts assigning to the same value in the test context' do
+      expected = 'value'
+
+      controller_with_session(:var => expected).
+        should set_session(:var).in_context(self).to { expected }
+    end
+
+    it 'rejects assigning to the another value in the test context' do
+      expected = 'other'
+
+      controller_with_session(:var => 'unexpected').
+        should_not set_session(:var).in_context(self).to { expected }
+    end
+
+    def controller_with_session(session_hash)
+      build_response do
+        session_hash.each do |key, value|
+          session[key] = value
+        end
+      end
+    end
+  end
+end