putio 0.0.1.pre

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/respond_with_matcher.rb

@@ -0,0 +1,85 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures a controller responded with expected 'response' status code.
+      #
+      # You can pass an explicit status number like 200, 301, 404, 500
+      # or its symbolic equivalent :success, :redirect, :missing, :error.
+      # See ActionController::StatusCodes for a full list.
+      #
+      # Example:
+      #
+      #   it { should respond_with(:success)  }
+      #   it { should respond_with(:redirect) }
+      #   it { should respond_with(:missing)  }
+      #   it { should respond_with(:error)    }
+      #   it { should respond_with(501)       }
+      def respond_with(status)
+        RespondWithMatcher.new(status)
+      end
+
+      class RespondWithMatcher # :nodoc:
+
+        def initialize(status)
+          @status = symbol_to_status_code(status)
+        end
+
+        def matches?(controller)
+          @controller = controller
+          correct_status_code? || correct_status_code_range?
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          "respond with #{@status}"
+        end
+
+        protected
+
+        def correct_status_code?
+          response_code == @status
+        end
+
+        def correct_status_code_range?
+          @status.is_a?(Range) &&
+            @status.include?(response_code)
+        end
+
+        def response_code
+          @controller.response.response_code
+        end
+
+        def symbol_to_status_code(potential_symbol)
+          case potential_symbol
+          when :success  then 200
+          when :redirect then 300..399
+          when :missing  then 404
+          when :error    then 500..599
+          when Symbol
+            if defined?(::Rack::Utils::SYMBOL_TO_STATUS_CODE)
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[potential_symbol]
+            else
+              ::ActionController::Base::SYMBOL_TO_STATUS_CODE[potential_symbol]
+            end
+          else
+            potential_symbol
+          end
+        end
+
+        def expectation
+          "response to be a #{@status}, but was #{response_code}"
+        end
+
+      end
+
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/route_matcher.rb

@@ -0,0 +1,93 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that requesting +path+ using +method+ routes to +options+.
+      #
+      # If you don't specify a controller, it will use the controller from the
+      # example group.
+      #
+      # +to_param+ is called on the +options+ given.
+      #
+      # Examples:
+      #
+      #   it { should route(:get, "/posts").
+      #                 to(:controller => :posts, :action => :index) }
+      #   it { should route(:get, "/posts/new").to(:action => :new) }
+      #   it { should route(:post, "/posts").to(:action => :create) }
+      #   it { should route(:get, "/posts/1").to(:action => :show, :id => 1) }
+      #   it { should route(:edit, "/posts/1").to(:action => :show, :id => 1) }
+      #   it { should route(:put, "/posts/1").to(:action => :update, :id => 1) }
+      #   it { should route(:delete, "/posts/1").
+      #                 to(:action => :destroy, :id => 1) }
+      #   it { should route(:get, "/users/1/posts/1").
+      #                 to(:action => :show, :id => 1, :user_id => 1) }
+      def route(method, path)
+        RouteMatcher.new(method, path, self)
+      end
+
+      class RouteMatcher # :nodoc:
+
+        def initialize(method, path, context)
+          @method  = method
+          @path    = path
+          @context = context
+        end
+
+        def to(params)
+          @params = params
+          stringify_params!
+          self
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          guess_controller!
+          route_recognized?
+        end
+
+        attr_reader :failure_message, :negative_failure_message
+
+        def description
+          "route #{@method.to_s.upcase} #{@path} to/from #{@params.inspect}"
+        end
+
+        private
+
+        def guess_controller!
+          @params[:controller] ||= @controller.controller_path
+        end
+
+        def stringify_params!
+          @params.each do |key, value|
+            @params[key] = value.is_a?(Array) ? value.collect {|v| v.to_param } : value.to_param
+          end
+        end
+
+        def route_recognized?
+          begin
+            @context.send(:assert_routing,
+                          { :method => @method, :path => @path },
+                          @params)
+
+            @negative_failure_message = "Didn't expect to #{description}"
+            true
+          rescue ::ActionController::RoutingError => error
+            @failure_message = error.message
+            false
+          rescue Test::Unit::AssertionFailedError => error
+            @failure_message = error.message
+            false
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/set_session_matcher.rb

@@ -0,0 +1,98 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that a session key was set to the expected value.
+      #
+      # Example:
+      #
+      #   it { should set_session(:message) }
+      #   it { should set_session(:user_id).to(@user.id) }
+      #   it { should_not set_session(:user_id) }
+      def set_session(key)
+        SetSessionMatcher.new(key)
+      end
+
+      class SetSessionMatcher # :nodoc:
+
+        def initialize(key)
+          @key = key.to_s
+        end
+
+        def to(value = nil, &block)
+          @value = value
+          @value_block = block
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          @value = @context.instance_eval(&@value_block) if @value_block
+          (assigned_value? && assigned_correct_value?) || cleared_value?
+        end
+
+        def failure_message
+          "Expected #{expectation}, but #{result}"
+        end
+
+        def negative_failure_message
+          "Didn't expect #{expectation}, but #{result}"
+        end
+
+        def description
+          description = "set session variable #{@key.inspect}"
+          description << " to #{@value.inspect}" if defined?(@value)
+          description
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        private
+
+        def assigned_value?
+          !assigned_value.nil?
+        end
+
+        def cleared_value?
+          defined?(@value) && @value.nil? && assigned_value.nil?
+        end
+
+        def assigned_correct_value?
+          return true if @value.nil?
+          assigned_value == @value
+        end
+
+        def assigned_value
+          session[@key]
+        end
+
+        def session
+          if @controller.request.respond_to?(:session)
+            @controller.request.session.to_hash
+          else
+            @controller.response.session.data
+          end
+        end
+
+        def expectation
+          expectation = "session variable #{@key} to be set"
+          expectation << " to #{@value.inspect}" if @value
+          expectation
+        end
+
+        def result
+          if session.empty?
+            "no session variables were set"
+          else
+            "the session was #{session.inspect}"
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/set_the_flash_matcher.rb

@@ -0,0 +1,100 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that the flash contains the given value. Can be a String, a
+      # Regexp, or nil (indicating that the flash should not be set).
+      #
+      # Example:
+      #
+      #   it { should set_the_flash }
+      #   it { should set_the_flash.to("Thank you for placing this order.") }
+      #   it { should set_the_flash.to(/created/i) }
+      #   it { should set_the_flash.to(/logged in/i).now }
+      #   it { should_not set_the_flash }
+      def set_the_flash
+        SetTheFlashMatcher.new
+      end
+
+      class SetTheFlashMatcher # :nodoc:
+
+        def to(value)
+          @value = value
+          self
+        end
+
+        def now
+          @now = true
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          sets_the_flash? && string_value_matches? && regexp_value_matches?
+        end
+
+        attr_reader :failure_message, :negative_failure_message
+
+        def description
+          description = "set the flash"
+          description << " to #{@value.inspect}" unless @value.nil?
+          description
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        private
+
+        def sets_the_flash?
+          !flash.blank?
+        end
+
+        def string_value_matches?
+          return true unless String === @value
+          flash.values.any? {|value| value == @value }
+        end
+
+        def regexp_value_matches?
+          return true unless Regexp === @value
+          flash.values.any? {|value| value =~ @value }
+        end
+
+        def flash
+          return @flash if @flash
+          flash_and_now = @controller.request.session["flash"].dup if @controller.request.session["flash"]
+          flash         = @controller.send(:flash)
+
+          @flash = if @now
+            flash.keys.each {|key| flash_and_now.delete(key) }
+            flash_and_now
+          else
+            flash
+          end
+        end
+
+        def expectation
+          expectation = "the flash#{".now" if @now} to be set"
+          expectation << " to #{@value.inspect}" unless @value.nil?
+          expectation << ", but #{flash_description}"
+          expectation
+        end
+
+        def flash_description
+          if flash.blank?
+            "no flash was set"
+          else
+            "was #{flash.inspect}"
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers.rb

@@ -0,0 +1,39 @@
+require 'shoulda/action_controller/matchers/assign_to_matcher'
+require 'shoulda/action_controller/matchers/filter_param_matcher'
+require 'shoulda/action_controller/matchers/set_the_flash_matcher'
+require 'shoulda/action_controller/matchers/render_with_layout_matcher'
+require 'shoulda/action_controller/matchers/respond_with_matcher'
+require 'shoulda/action_controller/matchers/respond_with_content_type_matcher'
+require 'shoulda/action_controller/matchers/set_session_matcher'
+require 'shoulda/action_controller/matchers/route_matcher'
+require 'shoulda/action_controller/matchers/redirect_to_matcher'
+require 'shoulda/action_controller/matchers/render_template_matcher'
+
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+
+    # By using the macro helpers you can quickly and easily create concise and
+    # easy to read test suites.
+    #
+    # This code segment:
+    #
+    #   describe UsersController, "on GET to show with a valid id" do
+    #     before(:each) do
+    #       get :show, :id => User.first.to_param
+    #     end
+    #
+    #     it { should assign_to(:user) }
+    #     it { should respond_with(:success) }
+    #     it { should render_template(:show) }
+    #     it { should not_set_the_flash) }
+    #
+    #     it "should do something else really cool" do
+    #       assigns[:user].id.should == 1
+    #     end
+    #   end
+    #
+    # Would produce 5 tests for the show action
+    module Matchers
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller.rb

@@ -0,0 +1,34 @@
+require 'shoulda'
+require 'shoulda/action_controller/matchers'
+require 'shoulda/action_controller/macros'
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      include Shoulda::ActionController::Matchers
+      extend Shoulda::ActionController::Macros
+    end
+  end
+end
+
+require 'shoulda/active_record/assertions'
+require 'shoulda/action_mailer/assertions'
+
+module ActionController #:nodoc: all
+  module Integration
+    class Session
+      include Shoulda::Assertions
+      include Shoulda::Helpers
+      include Shoulda::ActiveRecord::Assertions
+      include Shoulda::ActionMailer::Assertions
+    end
+  end
+end
+
+if defined?(ActionController::TestCase)
+  class ActionController::TestCase
+    def subject
+      @controller
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_mailer/assertions.rb

@@ -0,0 +1,42 @@
+module Shoulda # :nodoc:
+  module ActionMailer # :nodoc:
+    module Assertions
+      # Asserts that an email was delivered.  Can take a block that can further
+      # narrow down the types of emails you're expecting.
+      #
+      #  assert_sent_email
+      #
+      # Passes if ActionMailer::Base.deliveries has an email
+      #
+      #  assert_sent_email do |email|
+      #    email.subject =~ /hi there/ && email.to.include?('none@none.com')
+      #  end
+      #
+      # Passes if there is an email with subject containing 'hi there' and
+      # 'none@none.com' as one of the recipients.
+      #
+      def assert_sent_email
+      ::ActiveSupport::Deprecation.warn("use: should have_sent_email")
+        emails = ::ActionMailer::Base.deliveries
+        assert !emails.empty?, "No emails were sent"
+        if block_given?
+          matching_emails = emails.select {|email| yield email }
+          assert !matching_emails.empty?, "None of the emails matched."
+        end
+      end
+
+      # should have_sent_email.with_subject(/hi there/).to('none@none.com').from('noreply@example.com').with_body(/reach out/)
+
+      # Asserts that no ActionMailer mails were delivered
+      #
+      #  assert_did_not_send_email
+      def assert_did_not_send_email
+        ::ActiveSupport::Deprecation.warn("use: should_not have_sent_email")
+        msg = "Sent #{::ActionMailer::Base.deliveries.size} emails.\n"
+        ::ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
+        assert ::ActionMailer::Base.deliveries.empty?, msg
+      end
+    end
+  end
+end
+

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_mailer/matchers/have_sent_email.rb

@@ -0,0 +1,110 @@
+module Shoulda # :nodoc:
+  module ActionMailer # :nodoc:
+    module Matchers
+
+      # The right email is sent.
+      #
+      #   it { should have_sent_email.with_subject(/is spam$/) }
+      #   it { should have_sent_email.from('do-not-reply@example.com') }
+      #   it { should have_sent_email.with_body(/is spam\./) }
+      #   it { should have_sent_email.to('myself@me.com') }
+      #   it { should have_sent_email.with_subject(/spam/).
+      #                               from('do-not-reply@example.com').
+      #                               with_body(/spam/).
+      #                               to('myself@me.com') }
+      def have_sent_email
+        HaveSentEmailMatcher.new
+      end
+
+      class HaveSentEmailMatcher # :nodoc:
+
+        def initialize
+        end
+
+        def with_subject(email_subject)
+          @email_subject = email_subject
+          self
+        end
+
+        def from(sender)
+          @sender = sender
+          self
+        end
+
+        def with_body(body)
+          @body = body
+          self
+        end
+
+        def to(recipient)
+          @recipient = recipient
+          self
+        end
+
+        def matches?(subject)
+          ::ActionMailer::Base.deliveries.each do |mail|
+            @subject_failed = !regexp_or_string_match(mail.subject, @email_subject) if @email_subject
+            @body_failed = !regexp_or_string_match(mail.body, @body) if @body
+            @sender_failed = !regexp_or_string_match_in_array(mail.from, @sender) if @sender
+            @recipient_failed = !regexp_or_string_match_in_array(mail.to, @recipient) if @recipient
+            return true unless anything_failed?
+          end
+
+          false
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          "send an email"
+        end
+
+        private
+
+        def expectation
+          expectation = "sent email"
+          expectation << " with subject #{@email_subject.inspect}" if @subject_failed
+          expectation << " with body #{@body.inspect}" if @body_failed
+          expectation << " from #{@sender.inspect}" if @sender_failed
+          expectation << " to #{@recipient.inspect}" if @recipient_failed
+          expectation << "\nDeliveries:\n#{inspect_deliveries}"
+        end
+
+        def inspect_deliveries
+          ::ActionMailer::Base.deliveries.map do |delivery|
+            "#{delivery.subject.inspect} to #{delivery.to.inspect}"
+          end.join("\n")
+        end
+
+        def anything_failed?
+          @subject_failed || @body_failed || @sender_failed || @recipient_failed
+        end
+
+        def regexp_or_string_match(a_string, a_regexp_or_string)
+          case a_regexp_or_string
+          when Regexp
+            a_string =~ a_regexp_or_string
+          when String
+            a_string == a_regexp_or_string
+          end
+        end
+
+        def regexp_or_string_match_in_array(an_array, a_regexp_or_string)
+          case a_regexp_or_string
+          when Regexp
+            an_array.detect{|e| e =~ a_regexp_or_string}.any?
+          when String
+            an_array.include?(a_regexp_or_string)
+          end
+        end
+      end
+    end
+  end
+end
+

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_mailer/matchers.rb

@@ -0,0 +1,22 @@
+require 'shoulda/action_mailer/matchers/have_sent_email'
+
+module Shoulda # :nodoc:
+  module ActionMailer # :nodoc:
+    # = Matchers for your mailers
+    #
+    # This matcher will test that email is sent properly
+    #
+    #   describe User do
+    #     it { should have_sent_email.with_subject(/is spam$/) }
+    #     it { should have_sent_email.from('do-not-reply@example.com') }
+    #     it { should have_sent_email.with_body(/is spam\./) }
+    #     it { should have_sent_email.to('myself@me.com') }
+    #     it { should have_sent_email.with_subject(/spam/).
+    #                                 from('do-not-reply@example.com').
+    #                                 with_body(/spam/).
+    #                                 to('myself@me.com') }
+    #   end
+    module Matchers
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_mailer.rb

@@ -0,0 +1,13 @@
+require 'shoulda'
+require 'shoulda/action_mailer/assertions'
+require 'shoulda/action_mailer/matchers'
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      include Shoulda::ActionMailer::Assertions
+      include Shoulda::ActionMailer::Matchers
+      extend Shoulda::ActionMailer::Matchers
+    end
+  end
+end