shoulda-matchers 1.0.0 → 1.1.0

data/spec/shoulda/action_controller/render_with_layout_matcher_spec.rb

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

data/spec/shoulda/action_controller/respond_with_content_type_matcher_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RespondWithContentTypeMatcher do
+  context "a controller responding with content type :xml" do
+    let(:controller) { build_response { render :xml => { :user => "thoughtbot" }.to_xml } }
+
+    it "should accept responding with content type :xml" do
+      controller.should respond_with_content_type(:xml)
+    end
+
+    it "should accept responding with content type 'application/xml'" do
+      controller.should respond_with_content_type('application/xml')
+    end
+
+    it "should accept responding with content type /xml/" do
+      controller.should respond_with_content_type(/xml/)
+    end
+
+    it "should reject responding with another content type" do
+      controller.should_not respond_with_content_type(:json)
+    end
+  end
+
+  it "should generate the correct test name" do
+    respond_with_content_type(:xml).description.
+      should == "respond with content type of application/xml"
+  end
+end

data/spec/shoulda/action_controller/respond_with_matcher_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RespondWithMatcher do
+  context "a controller responding with success" do
+    let(:controller) { build_response { render :text => "text", :status => 200 } }
+
+    it "should accept responding with 200" do
+      controller.should respond_with(200)
+    end
+
+    it "should accept responding with :success" do
+      controller.should respond_with(:success)
+    end
+
+    it "should reject responding with another status" do
+      controller.should_not respond_with(:error)
+    end
+  end
+
+  context "a controller responding with redirect" do
+    let(:controller) { build_response { render :text => "text", :status => 301 } }
+
+    it "should accept responding with 301" do
+      controller.should respond_with(301)
+    end
+
+    it "should accept responding with :redirect" do
+      controller.should respond_with(:redirect)
+    end
+
+    it "should reject responding with another status" do
+      controller.should_not respond_with(:error)
+    end
+  end
+
+  context "a controller responding with missing" do
+    let(:controller) { build_response { render :text => "text", :status => 404 } }
+
+    it "should accept responding with 404" do
+      controller.should respond_with(404)
+    end
+
+    it "should accept responding with :missing" do
+      controller.should respond_with(:missing)
+    end
+
+    it "should reject responding with another status" do
+      controller.should_not respond_with(:success)
+    end
+  end
+
+  context "a controller responding with error" do
+    let(:controller) { build_response { render :text => "text", :status => 500 } }
+
+    it "should accept responding with 500" do
+      controller.should respond_with(500)
+    end
+
+    it "should accept responding with :error" do
+      controller.should respond_with(:error)
+    end
+
+    it "should reject responding with another status" do
+      controller.should_not respond_with(:success)
+    end
+  end
+
+  context "a controller responding with not implemented" do
+    let(:controller) { build_response { render :text => "text", :status => 501 } }
+
+    it "should accept responding with 501" do
+      controller.should respond_with(501)
+    end
+
+    it "should accept responding with :not_implemented" do
+      controller.should respond_with(:not_implemented)
+    end
+
+    it "should reject responding with another status" do
+      controller.should_not respond_with(:success)
+    end
+  end
+end

data/spec/shoulda/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
+    let(:controller) { define_controller('Examples').new }
+
+    before do
+      define_routes do
+        match 'examples/*id', :to => 'examples#example'
+      end
+    end
+
+    it "should accept glob route" do
+      controller.should route(:get, '/examples/foo/bar').
+        to(:action => 'example', :id => 'foo/bar')
+    end
+  end
+
+  context "given a controller with a defined route" do
+    let!(:controller) { define_controller('Examples').new }
+
+    before do
+      define_routes do
+        match 'examples/:id', :to => 'examples#example'
+      end
+    end
+
+    it "should accept routing the correct path to the correct parameters" do
+      controller.should route(:get, '/examples/1').
+        to(:action => 'example', :id => '1')
+    end
+
+    it "should accept a symbol controller" do
+      Object.new.should route(:get, '/examples/1').
+        to(:controller => :examples,
+           :action     => 'example',
+           :id         => '1')
+    end
+
+    it "should accept a symbol action" do
+      controller.should route(:get, '/examples/1').
+        to(:action => :example, :id => '1')
+    end
+
+    it "should accept a non-string parameter" do
+      controller.should route(:get, '/examples/1').
+        to(:action => 'example', :id => 1)
+    end
+
+    it "should reject an undefined route" do
+      controller.should_not route(:get, '/bad_route').to(:var => 'value')
+    end
+
+    it "should reject a route for another controller" do
+      other = define_controller('Other').new
+      other.should_not route(:get, '/examples/1').
+        to(:action => 'example', :id => '1')
+    end
+
+    it "should reject a route for different parameters" do
+      controller.should_not route(:get, '/examples/1').
+        to(:action => 'other', :id => '1')
+    end
+  end
+end

data/spec/shoulda/action_controller/set_session_matcher_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::SetSessionMatcher do
+  context "a controller that sets a session variable" do
+    let(:controller) do
+      build_response do
+        session[:var] = 'value'
+        session[:false_var] = false
+      end
+    end
+
+    it "should accept assigning to that variable" do
+      controller.should set_session(:var)
+    end
+
+    it "should accept assigning the correct value to that variable" do
+      controller.should set_session(:var).to('value')
+    end
+
+    it "should reject assigning another value to that variable" do
+      controller.should_not set_session(:var).to('other')
+    end
+
+    it "should reject assigning to another variable" do
+      controller.should_not set_session(:other)
+    end
+
+    it "should accept assigning nil to another variable" do
+      controller.should set_session(:other).to(nil)
+    end
+
+    it "should accept assigning false to that variable" do
+      controller.should set_session(:false_var).to(false)
+    end
+
+    it "should accept assigning to the same value in the test context" do
+      expected = 'value'
+      controller.should set_session(:var).in_context(self).to { expected }
+    end
+
+    it "should reject assigning to the another value in the test context" do
+      expected = 'other'
+      controller.should_not set_session(:var).in_context(self).to { expected }
+    end
+  end
+end

data/spec/shoulda/action_controller/set_the_flash_matcher_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::SetTheFlashMatcher do
+  context "a controller that sets a flash message" do
+    let(:controller) { build_response { flash[:notice] = 'value' } }
+
+    it "should accept setting any flash message" do
+      controller.should set_the_flash
+    end
+
+    it "should accept setting the exact flash message" do
+      controller.should set_the_flash.to('value')
+    end
+
+    it "should accept setting a matched flash message" do
+      controller.should set_the_flash.to(/value/)
+    end
+
+    it "should reject setting a different flash message" do
+      controller.should_not set_the_flash.to('other')
+    end
+
+    it "should reject setting a different pattern" do
+      controller.should_not set_the_flash.to(/other/)
+    end
+  end
+
+  context "a controller that sets a flash.now message" do
+    let(:controller) { build_response { flash.now[:notice] = 'value' } }
+
+    it "should reject setting any flash message" do
+      controller.should_not set_the_flash
+    end
+
+    it "should accept setting any flash.now message" do
+      controller.should set_the_flash.now
+    end
+
+    it "should accept setting the exact flash.now message" do
+      controller.should set_the_flash.to('value').now
+    end
+
+    it "should accept setting a matched flash.now message" do
+      controller.should set_the_flash.to(/value/).now
+    end
+
+    it "should reject setting a different flash.now message" do
+      controller.should_not set_the_flash.to('other').now
+    end
+
+    it "should reject setting a different flash.now pattern" do
+      controller.should_not set_the_flash.to(/other/).now
+    end
+  end
+
+  context "a controller that sets a flash message of notice and alert" do
+    let(:controller) do
+      build_response do
+        flash[:notice] = 'value'
+        flash[:alert]  = 'other'
+      end
+    end
+
+    it "should accept flash message of notice" do
+      controller.should set_the_flash[:notice]
+    end
+
+    it "should accept flash message of alert" do
+      controller.should set_the_flash[:notice]
+    end
+
+    it "should reject flash message of warning" do
+      controller.should_not set_the_flash[:warning]
+    end
+
+    it "should accept exact flash message of notice" do
+      controller.should set_the_flash[:notice].to('value')
+    end
+
+    it "should accept setting a matched flash message of notice" do
+      controller.should set_the_flash[:notice].to(/value/)
+    end
+
+    it "should reject setting a different flash message of notice" do
+      controller.should_not set_the_flash[:notice].to('other')
+    end
+
+    it "should reject setting a different pattern" do
+      controller.should_not set_the_flash[:notice].to(/other/)
+    end
+  end
+
+  context "a controller that sets multiple flash messages" do
+    let(:controller) do
+      build_response do
+        flash.now[:notice] = 'value'
+        flash[:success] = 'great job'
+      end
+    end
+
+    it "should accept setting any flash.now message" do
+      controller.should set_the_flash.now
+      controller.should set_the_flash
+    end
+
+    it "should accept setting a matched flash.now message" do
+      controller.should set_the_flash.to(/value/).now
+      controller.should set_the_flash.to(/great/)
+    end
+
+    it "should reject setting a different flash.now message" do
+      controller.should_not set_the_flash.to('other').now
+      controller.should_not set_the_flash.to('other')
+    end
+  end
+
+  context "a controller that doesn't set a flash message" do
+    let(:controller) { build_response }
+
+    it "should reject setting any flash message" do
+      controller.should_not set_the_flash
+    end
+  end
+end

data/spec/shoulda/action_mailer/have_sent_email_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionMailer::HaveSentEmailMatcher do
+  subject { Shoulda::Matchers::ActionMailer::HaveSentEmailMatcher.new(self) }
+
+  def add_mail_to_deliveries(params = nil)
+    ::ActionMailer::Base.deliveries << Mailer.the_email(params)
+  end
+
+  context "testing with instance variables with no multipart" do
+    let(:info) do
+      {
+        :from => "do-not-reply@example.com",
+        :reply_to => "reply-to-me@example.com",
+        :to => "myself@me.com",
+        :cc => ["you@you.com", "joe@bob.com", "hello@goodbye.com"],
+        :bcc => ["test@example.com", "sam@bob.com", "goodbye@hello.com"],
+        :subject => "This is spam",
+        :body => "Every email is spam."
+      }
+    end
+
+    before do
+      define_mailer(:mailer, [:the_email]) do
+        def the_email(params)
+          mail params
+        end
+      end
+      add_mail_to_deliveries(info)
+    end
+
+    after { ::ActionMailer::Base.deliveries.clear }
+
+    it "should send an e-mail based on subject" do
+      should have_sent_email.with_subject{ info[:subject] }
+    end
+
+    it "should send an e-mail based on recipient" do
+      should have_sent_email.to(nil) { info[:to] }
+    end
+
+    it "should send an e-mail based on sender" do
+      should have_sent_email.from{ info[:from] }
+    end
+
+    it "should send an e-email based on reply_to" do
+      should have_sent_email.reply_to { info[:reply_to] }
+    end
+
+    it "should send an e-mail based on cc" do
+      should have_sent_email.cc{ info[:cc][0] }
+    end
+
+    it "should send an e-mail based on cc list" do
+      should have_sent_email.with_cc{ info[:cc] }
+    end
+
+    it "should send an e-mail based on bcc" do
+      should have_sent_email.bcc{ info[:bcc][0] }
+    end
+
+    it "should send an e-mail based on bcc list" do
+      should have_sent_email.with_bcc{ info[:bcc] }
+    end
+
+    it "should send an e-mail based on body" do
+      should have_sent_email.with_body{ info[:body] }
+    end
+  end
+
+  context "testing with instance variables with multiple parts" do
+    let(:info) do
+      {
+        :from => "do-not-reply@example.com",
+        :to => "myself@me.com",
+        :cc => ["you@you.com", "joe@bob.com", "hello@goodbye.com"],
+        :bcc => ["test@example.com", "sam@bob.com", "goodbye@hello.com"],
+        :subject => "This is spam",
+        :text => "Every email is spam.",
+        :html => "<h1>HTML is spam.</h1><p>Notably.</p>"
+      }
+    end
+
+    before do
+      define_mailer(:mailer, [:the_email]) do
+        def the_email(params)
+          mail params do |format|
+            format.text { render :text => params[:text] }
+            format.html { render :text => params[:html] }
+          end
+        end
+      end
+      add_mail_to_deliveries(info)
+    end
+
+    after { ::ActionMailer::Base.deliveries.clear }
+
+    it "should send emails with text and html parts" do
+      should have_sent_email.with_part('text/plain') { info[:text] }.with_part('text/html') { info[:html] }
+    end
+
+    it "should have the block override the method argument" do
+      should have_sent_email.with_part('text/plain', 'foo') { info[:text] }.with_part('text/html', /bar/) { info[:html] }
+    end
+  end
+
+  context "an email without multiple parts" do
+    before do
+      define_mailer :mailer, [:the_email] do
+        def the_email(params)
+          mail :from    => "do-not-reply@example.com",
+            :to      => "myself@me.com",
+            :subject => "This is spam",
+            :cc      => ["you@you.com", "joe@bob.com", "hello@goodbye.com"],
+            :bcc     => ["test@example.com", "sam@bob.com", "goodbye@hello.com"],
+            :body    => "Every email is spam."
+        end
+      end
+      add_mail_to_deliveries
+    end
+
+    after { ::ActionMailer::Base.deliveries.clear }
+
+    it "accepts sent-email when it is not multipart" do
+      should_not have_sent_email.multipart
+      matcher = have_sent_email.multipart(true)
+      matcher.matches?(Mailer.the_email(nil))
+      matcher.failure_message.should =~ /Expected sent email being multipart/
+    end
+
+    it "matches the body with a regexp" do
+      should have_sent_email.with_body(/email is spam/)
+    end
+
+    it "matches the body with a string" do
+      should have_sent_email.with_body("Every email is spam.")
+      should_not have_sent_email.with_body("emails is")
+    end
+  end
+
+  context "an email with both a text/plain and text/html part" do
+    before do
+      define_mailer :mailer, [:the_email] do
+        def the_email(params)
+          mail :from    => "do-not-reply@example.com",
+            :to      => "myself@me.com",
+            :cc      => ["you@you.com", "joe@bob.com", "hello@goodbye.com"],
+            :bcc     => ["test@example.com", "sam@bob.com", "goodbye@hello.com"],
+            :subject => "This is spam" do |format|
+
+            format.text { render :text => "Every email is spam." }
+            format.html { render :text => "<h1>HTML is spam.</h1><p>Notably.</p>" }
+            end
+        end
+      end
+      add_mail_to_deliveries
+    end
+
+    after { ::ActionMailer::Base.deliveries.clear }
+
+    it "accepts sent e-mail based on the subject" do
+      should have_sent_email.with_subject(/is spam$/)
+      matcher = have_sent_email.with_subject(/totally safe/)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email with subject/
+    end
+
+    it "accepts sent e-mail based on a string sender" do
+      should have_sent_email.from('do-not-reply@example.com')
+      matcher = have_sent_email.from('you@example.com')
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email from/
+    end
+
+    it "accepts sent e-mail based on a regexp sender" do
+      should have_sent_email.from(/@example\.com/)
+      matcher = have_sent_email.from(/you@/)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email from/
+    end
+
+    it "accepts sent e-mail based on the body" do
+      should have_sent_email.with_body(/is spam\./)
+      matcher = have_sent_email.with_body(/totally safe/)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email with body/
+    end
+
+    it "accepts sent e-mail based on a text/plain part" do
+      should have_sent_email.with_part('text/plain', /is spam\./)
+      matcher = have_sent_email.with_part('text/plain', /HTML is spam/)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email with a text\/plain part containing/
+    end
+
+    it "accepts sent e-mail based on a text/html part" do
+      should have_sent_email.with_part('text/html', /HTML is spam/)
+      matcher = have_sent_email.with_part('text/html', /HTML is not spam\./)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email with a text\/html part containing/
+    end
+
+    it "accept sent e-mail based on the recipient" do
+      should have_sent_email.to('myself@me.com')
+      matcher = have_sent_email.to('you@example.com')
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email to/
+    end
+
+    it "accepts sent e-mail based on cc string" do
+      should have_sent_email.cc('joe@bob.com')
+      matcher = have_sent_email.cc('you@example.com')
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email cc/
+    end
+
+    it "accepts sent-email based on cc regex" do
+      should have_sent_email.cc(/@bob\.com/)
+      matcher = have_sent_email.cc(/us@/)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email cc/
+    end
+
+    it "accepts sent e-mail based on cc list" do
+      should have_sent_email.with_cc(['you@you.com', 'joe@bob.com'])
+      matcher = have_sent_email.with_cc(['you@example.com'])
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email with cc/
+    end
+
+    it "accepts sent e-mail based on bcc string" do
+      should have_sent_email.bcc("goodbye@hello.com")
+      matcher = have_sent_email.bcc("test@hello.com")
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email bcc/
+    end
+
+    it "accepts sent e-mail based on bcc regex" do
+      should have_sent_email.bcc(/@example\.com/)
+      matcher = have_sent_email.bcc(/you@/)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email bcc/
+    end
+
+    it "accepts sent e-mail based on bcc list" do
+      should have_sent_email.with_bcc(['sam@bob.com', 'test@example.com'])
+      matcher = have_sent_email.with_bcc(['you@you.com', 'joe@bob.com'])
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email with bcc/
+    end
+
+    it "accepts sent-email when it is multipart" do
+      should have_sent_email.multipart
+      matcher = have_sent_email.multipart(false)
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Expected sent email not being multipart/
+    end
+
+    it "lists all the deliveries within failure message" do
+      add_mail_to_deliveries
+
+      matcher = have_sent_email.to('you@example.com')
+      matcher.matches?(nil)
+      matcher.failure_message.should =~ /Deliveries:\n"This is spam" to \["myself@me\.com"\]\n"This is spam" to \["myself@me\.com"\]/
+    end
+
+    it "allows chaining" do
+      should have_sent_email.with_subject(/spam/).from('do-not-reply@example.com').with_body(/spam/).
+        with_part('text/plain', /is spam\./).with_part('text/html', /HTML is spam/).to('myself@me.com')
+      should_not have_sent_email.with_subject(/ham/).from('you@example.com').with_body(/ham/).
+        with_part('text/plain', /is ham/).with_part('text/html', /HTML is ham/).to('them@example.com')
+    end
+  end
+
+  it "provides a detailed description of the e-mail expected to be sent" do
+    matcher = have_sent_email
+    matcher.description.should == 'send an email'
+    matcher = matcher.with_subject("Welcome!")
+    matcher.description.should == 'send an email with a subject of "Welcome!"'
+    matcher = matcher.with_body("Welcome, human!")
+    matcher.description.should == 'send an email with a subject of "Welcome!" containing "Welcome, human!"'
+    matcher = matcher.with_part('text/plain', 'plain')
+    matcher.description.should == 'send an email with a subject of "Welcome!" containing "Welcome, human!" having a text/plain part containing "plain"'
+    matcher = matcher.with_part('text/html', 'html')
+    matcher.description.should == 'send an email with a subject of "Welcome!" containing "Welcome, human!" having a text/plain part containing "plain" having a text/html part containing "html"'
+    matcher = matcher.from("alien@example.com")
+    matcher.description.should == 'send an email with a subject of "Welcome!" containing "Welcome, human!" having a text/plain part containing "plain" having a text/html part containing "html" from "alien@example.com"'
+    matcher = matcher.to("human@example.com")
+    matcher.description.should == 'send an email with a subject of "Welcome!" containing "Welcome, human!" having a text/plain part containing "plain" having a text/html part containing "html" from "alien@example.com" to "human@example.com"'
+    matcher = matcher.reply_to("reply-to-me@example.com")
+    matcher.description.should == 'send an email with a subject of "Welcome!" containing "Welcome, human!" having a text/plain part containing "plain" having a text/html part containing "html" from "alien@example.com" reply to "reply-to-me@example.com" to "human@example.com"'
+  end
+end