on-test-spec 0.2.4

data/.gitignore

@@ -0,0 +1 @@
+pkg/

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008, Fingertips
+- Manfred Stienstra <manfred@fngtps.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,12 @@
+On Test Spec
+------------
+
+Makes testing Rails apps with test/spec easier and more fun. Created with a
+half eye on the test_spec_on_rails plugin, thanks!
+
+Autotest
+--------
+
+To use autotest with test/spec on Rails, copy the "dot.autotest" sample file to
+your project's root directory and name it ".autotest". Edit the file if you
+need any custom mappings.

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rake/testtask'
+
+desc "By default run all tests"
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name     = "on-test-spec"
+    s.homepage = "http://github.com/Fingertips/on-test-spec"
+    s.email    = "eloy.de.enige@gmail.com"
+    s.authors  = ["Manfred Stienstra", "Eloy Duran", "Cristi Balan"]
+    s.summary  = s.description = "Rails plugin to make testing Rails on test/spec easier."
+  end
+rescue LoadError
+end
+
+begin
+  require 'jewelry_portfolio/tasks'
+  JewelryPortfolio::Tasks.new do |p|
+    p.account = 'Fingertips'
+  end
+rescue LoadError
+end

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:minor: 2
+:patch: 4
+:major: 0
+:build: 

data/dot.autotest

@@ -0,0 +1,93 @@
+Autotest.add_hook :initialize do |at|
+  at.unit_diff = 'cat'
+  at.failed_results_re = /^\s+\d+\) (?:Failure|Error):\n(.*?)\((.*?)\)\n\[([^:]*):.*\]/
+  
+  at.add_exception %r%^\./(?:db|doc|log|public|script|tmp|vendor|data|content|config)%
+  at.add_exception %r%\.svn%
+  
+  at.clear_mappings
+  
+  # Add your custom mappings:
+  #
+  # at.add_mapping %r%^app/(concerns)/(.*)\.rb$% do |_, match|
+  #   "test/unit/#{match[1]}/#{match[2]}_test.rb"
+  # end
+  # 
+  # at.add_mapping %r%^test/unit/(concerns)/.*rb$% do |filename, _|
+  #   filename
+  # end
+  # 
+  # at.add_mapping %r%^lib/(.*).rb% do |_, match|
+  #   sqwat = match[1].gsub('/', '_')
+  #   "test/lib/#{sqwat}_test.rb"
+  # end
+  # 
+  # at.add_mapping %r%^test/lib/.*rb$% do |filename, _|
+  #   filename
+  # end
+  
+  # Standard Rails
+  
+  at.add_mapping %r%^test/fixtures/(.*)s.yml% do |_, m|
+    ["test/unit/#{m[1]}_test.rb",
+     "test/controllers/#{m[1]}_controller_test.rb",
+     "test/views/#{m[1]}_view_test.rb",
+     "test/functional/#{m[1]}_controller_test.rb"]
+  end
+  
+  at.add_mapping %r%^test/(unit|integration|controllers|views|functional|helpers)/.*rb$% do |filename, _|
+    filename
+  end
+  
+  at.add_mapping %r%^app/models/(.*)\.rb$% do |_, m|
+    "test/unit/#{m[1]}_test.rb"
+  end
+  
+  at.add_mapping %r%^app/helpers/application_helper.rb% do
+    ["test/helpers/applications_helper_test.rb"] + at.files_matching(%r%^test/(views|functional)/.*_test\.rb$%)
+  end
+  
+  at.add_mapping %r%^app/helpers/(.*)_helper.rb% do |_, m|
+    if m[1] == "application" then
+      at.files_matching %r%^test/(views|functional)/.*_test\.rb$%
+    else
+      ["test/helpers/#{m[1]}_helper_test.rb",
+       "test/views/#{m[1]}_view_test.rb",
+       "test/functional/#{m[1]}_controller_test.rb"]
+    end
+  end
+  
+  at.add_mapping %r%^app/views/(.*)/% do |_, m|
+    ["test/views/#{m[1]}_view_test.rb",
+     "test/functional/#{m[1]}_controller_test.rb"]
+  end
+  
+  at.add_mapping %r%^app/controllers/(.*)\.rb$% do |_, m|
+    if m[1] == "application" then
+      at.files_matching %r%^test/(controllers|views|functional)/.*_test\.rb$%
+    else
+      ["test/controllers/#{m[1]}_test.rb",
+       "test/functional/#{m[1]}_test.rb"]
+    end
+  end
+  
+  at.add_mapping %r%^app/views/layouts/% do
+    "test/views/layouts_view_test.rb"
+  end
+  
+  at.add_mapping %r%^config/routes.rb$% do
+    at.files_matching %r%^test/(controllers|views|functional)/.*_test\.rb$%
+  end
+  
+  at.add_mapping %r%^test/test_helper.rb|config/((boot|environment(s/test)?).rb|database.yml)% do
+    at.files_matching %r%^test/(unit|controllers|views|functional)/.*_test\.rb$%
+  end
+  
+  class << at
+    def consolidate_failures(failed)
+      failed.inject(new_hash_of_arrays) do |filters, (method, klass, filename)|
+        filters[File.expand_path(filename)] << method; filters
+      end
+    end
+  end
+end

data/lib/test/spec/add_allow_switch.rb

@@ -0,0 +1,53 @@
+require 'active_support'
+
+class Class
+  def add_allow_switch(method, options={})
+    default = options[:default] || false
+    
+    class_eval do
+      cattr_accessor "allow_#{method}"
+      self.send("allow_#{method}=", default)
+      
+      alias_method "original_#{method}", method
+      
+      eval %{
+        def #{method}(*args)
+          if allow_#{method}
+            original_#{method}(*args)
+          else
+            raise RuntimeError, "You're trying to call `#{method}' on `#{self}', which you probably don't want in a test."
+          end
+        end
+      }, binding, __FILE__, __LINE__
+    end
+  end
+end
+
+class Module
+  def add_allow_switch(method, options={})
+    default = options[:default] || false
+    
+    mattr_accessor "allow_#{method}"
+    send("allow_#{method}=", default)
+    
+    unless respond_to?(:__metaclass___)
+      def __metaclass__
+        class << self; self; end
+      end
+    end
+    
+    __metaclass__.class_eval do
+      alias_method "original_#{method}", method
+      
+      eval %{
+        def #{method}(*args)
+          if allow_#{method}
+            original_#{method}(*args)
+          else
+            raise RuntimeError, "You're trying to call `#{method}' on `#{self}', which you probably don't want in a test."
+          end
+        end
+      }, binding, __FILE__, __LINE__
+    end
+  end  
+end

data/lib/test/spec/rails/controller_helpers.rb

@@ -0,0 +1,11 @@
+module Test
+  module Spec
+    module Rails
+      module ControllerHelpers
+        attr_reader :controller
+      end
+    end
+  end
+end
+
+ActionController::TestCase.send(:include, Test::Spec::Rails::ControllerHelpers)

data/lib/test/spec/rails/expectations.rb

@@ -0,0 +1,192 @@
+module Test
+  module Spec
+    module Rails
+      module Helpers
+        def self.inspect_records(records)
+          "[#{records.map { |record| "#{record.class}[#{record.id}]" }.join(', ')}]"
+        end
+      end
+      
+      module ShouldExpectations
+        # Test that we were redirected somewhere:
+        #   should.redirect
+        #
+        # Test that we were redirected to a specific url:
+        #   should.redirect :controller => 'foo', :action => 'bar'
+        # or:
+        #   should.redirect_to :controller => 'foo', :action => 'bar', :secure => true
+        def redirect(*args)
+          if args.empty?
+            test_case.assert_response @object.response.redirected_to, :redirect
+          elsif args.length == 1 and args.first.is_a?(String)
+            test_case.assert_equal args.first, @object.response.redirected_to
+          else
+            options = args.extract_options!
+            if secure = options.delete(:secure)
+              unless secure == true or secure == false
+                raise ArgumentError, ":secure option should be a boolean"
+              end
+            end
+            
+            @object.instance_eval { test_case.assert_redirected_to *args }
+            if secure == true
+              test_case.assert @object.response.redirected_to.starts_with?('https:')
+            elsif secure == false
+              test_case.assert @object.response.redirected_to.starts_with?('http:')
+            end
+          end
+        end
+        alias :redirect_to :redirect
+        
+        # Tests whether a redirect back to the HTTP_REFERER was send.
+        #
+        #   lambda { delete :destroy, :id => 1 }.should.redirect_back_to(articles_url)
+        #   lambda { delete :destroy, :id => 1 }.should.redirect_back_to(:action => :index)
+        def redirect_back_to(url_options)
+          test_case = eval("self", @object.binding)
+          url = test_case.controller.url_for(url_options)
+          test_case.controller.request.env["HTTP_REFERER"] = url
+          
+          block_result = @object.call
+          test_case.should.redirect_to(url)
+          
+          block_result
+        end
+        
+        # Test that the object is valid
+        def validate
+          test_case.assert_valid @object
+        end
+        
+        # Tests whether the evaluation of the expression changes.
+        #
+        #   lambda { Norm.create }.should.differ('Norm.count')
+        #   lambda { Norm.create; Norm.create }.should.differ('Norm.count', +2)
+        #   lambda { Norm.create; Option.create }.should.differ('Norm.count', +2, 'Option.count', +1)
+        #
+        #   norm = lambda { Norm.create }.should.differ('Norm.count')
+        #   norm.name.should == 'Latency'
+        def differ(*expected)
+          block_binding = @object.send(:binding)
+          before = expected.in_groups_of(2).map do |expression, _|
+            eval(expression, block_binding)
+          end
+          
+          block_result = @object.call
+          
+          expected.in_groups_of(2).each_with_index do |(expression, difference), index|
+            difference = 1 if difference.nil?
+            error = "#{expression.inspect} didn't change by #{difference}"
+            test_case.assert_equal(before[index] + difference, eval(expression, block_binding), error)
+          end
+          
+          block_result
+        end
+        alias change differ
+        
+        # Tests whether certain pages are cached.
+        #
+        #   lambda { get :index }.should.cache_pages(posts_path)
+        #   lambda { get :show, :id => post }.should.cache_pages(post_path(post), formatted_posts_path(:js, post))
+        def cache_pages(*pages, &block)
+          if block
+            block.call
+          else
+            @object.call
+          end
+          cache_dir = ActionController::Base.page_cache_directory
+          files = Dir.glob("#{cache_dir}/**/*").map do |filename|
+            filename[cache_dir.length..-1]
+          end
+          test_case.assert pages.all? { |page| files.include?(page) }
+        end
+        
+        # Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
+        def dom_equal(expected)
+          test_case.assert_dom_equal expected, @object
+        end
+        
+        # Tests if the array of records is the same, order may vary
+        def equal_set(expected)
+          message = "#{Helpers.inspect_records(@object)} does not have the same records as #{Helpers.inspect_records(expected)}"
+          
+          left = @object.map(&:id).sort
+          right = expected.map(&:id).sort
+          
+          test_case.assert(left == right, message)
+        end
+        
+        # Tests if the array of records is the same, order must be the same
+        def equal_list(expected)
+          message = "#{Helpers.inspect_records(@object)} does not have the same records as #{Helpers.inspect_records(expected)}"
+          
+          left = @object.map(&:id)
+          right = expected.map(&:id)
+          
+          test_case.assert(left == right, message)
+        end
+      end
+      
+      module ShouldNotExpectations
+        # Test that an object is not valid
+        def validate
+          test_case.assert !@object.valid?
+        end
+        
+        # Tests that the evaluation of the expression shouldn't change
+        #
+        #   lambda { Norm.new }.should.not.differ('Norm.count')
+        #   lambda { Norm.new }.should.not.differ('Norm.count', 'Option.count')
+        #
+        #   norm = lambda { Norm.new }.should.not.differ('Norm.count')
+        #   norm.token.should.match /(\d\w){4}/
+        def differ(*expected)
+          block_binding = @object.send(:binding)
+          before = expected.map do |expression|
+            eval(expression, block_binding)
+          end
+          
+          block_result = @object.call
+          
+          expected.each_with_index do |expression, index|
+            difference = eval(expression, block_binding) - before[index]
+            error = "#{expression.inspect} changed by #{difference}, expected no change"
+            test_case.assert_equal(0, difference, error)
+          end
+          
+          block_result
+          
+        end
+        alias change differ
+        
+        # Test that two HTML strings are not equivalent
+        def dom_equal(expected)
+          test_case.assert_dom_not_equal expected, @object
+        end
+        
+        # Tests if the array of records is not the same, order may vary
+        def equal_set(expected)
+          message = "#{Helpers.inspect_records(@object)} has the same records as #{Helpers.inspect_records(expected)}"
+          
+          left = @object.map(&:id).sort
+          right = expected.map(&:id).sort
+          
+          test_case.assert(left != right, message)
+        end
+        
+        # Tests if the array of records is not the same, order may vary
+        def equal_list(expected)
+          message = "#{Helpers.inspect_records(@object)} has the same records as #{Helpers.inspect_records(expected)}"
+          
+          left = @object.map(&:id)
+          right = expected.map(&:id)
+          
+          test_case.assert(left != right, message)
+        end
+      end
+    end
+  end
+end
+
+Test::Spec::Should.send(:include, Test::Spec::Rails::ShouldExpectations)
+Test::Spec::ShouldNot.send(:include, Test::Spec::Rails::ShouldNotExpectations)

data/lib/test/spec/rails/macros/authorization.rb

@@ -0,0 +1,80 @@
+module Test
+  module Spec
+    module Rails
+      module Macros
+        class Should
+          # Generates a test which tests authorization code. It assumes a method called <code>access_denied?</code>
+          # on the test case. The <code>access_denied?</code> method should return true when access is denied
+          # (ie. a 403 status code) and false in other cases.
+          #
+          # Example:
+          #   should.disallow.get :index
+          def disallow
+            Test::Spec::Rails::Macros::Authorization::TestGenerator.new(test_case,
+              :access_denied?, true,
+              'Expected access to be denied'
+            )
+          end
+          
+          # Generates a test which tests authorization code. It assumes a method called <code>access_denied?</code>
+          # on the test case. The <code>access_denied?</code> method should return true when access is denied
+          # (ie. a 403 status code) and false in other cases.
+          #
+          # Example:
+          #   should.allow.get :index
+          def allow
+            Test::Spec::Rails::Macros::Authorization::TestGenerator.new(test_case,
+              :access_denied?, false,
+              'Expected access to be allowed'
+            )
+          end
+          
+          # Generates a test which tests authorization code. It assumes a method called <code>access_denied?</code>
+          # on the test case. The <code>login_required?</code> method should return true when the visitor was
+          # asked for credentials (ie. a 401 status code or a redirect to a login page) and false in other cases.
+          #
+          # Example:
+          #   should.require_login.get :index
+          def require_login
+            Test::Spec::Rails::Macros::Authorization::TestGenerator.new(test_case,
+              :login_required?, true,
+              'Expected login to be required'
+            )
+          end
+        end
+        
+        module Authorization
+          class TestGenerator < Proxy
+            attr_accessor :validation_method, :message, :expected
+            
+            def initialize(test_case, validation_method, expected, message)
+              self.validation_method = validation_method
+              self.expected = expected
+              self.message = message
+              
+              super(test_case)
+            end
+            
+            def method_missing(verb, action, params={})
+              if [:get, :post, :put, :delete, :options].include?(verb.to_sym)
+                description = "should disallow #{verb.to_s.upcase} on `#{action}'"
+                description << " #{params.inspect}" unless params.blank?
+                
+                validation_method = self.validation_method
+                expected = self.expected
+                message = self.message
+                
+                test_case.it description do
+                  send(verb, action, immediate_values(params))
+                  send(validation_method).should.messaging(message) == expected
+                end
+              else
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test/spec/rails/macros/response.rb

@@ -0,0 +1,57 @@
+module Test
+  module Spec
+    module Rails
+      module Macros
+        class Should
+          def not_find
+            Test::Spec::Rails::Macros::Response::TestGenerator.new(test_case,
+              :not_found,
+              'Expected to not find a resource'
+            )
+          end
+        end
+        
+        module Response
+          class TestGenerator < Proxy
+            attr_accessor :status, :message, :expected
+
+            def initialize(test_case, status, message)
+              self.status = status
+              self.message = message
+
+              super(test_case)
+            end
+
+            def method_missing(verb, action, params={})
+              if [:get, :post, :put, :delete, :options].include?(verb.to_sym)
+                description = "should not find resource with #{verb.to_s.upcase} on `#{action}'"
+                description << " #{params.inspect}" unless params.blank?
+
+                status = self.status
+                message = self.message
+                
+                if defined?(:ActiveRecord)
+                  test_case.it description do
+                    begin
+                      send(verb, action, immediate_values(params))
+                      status.should.messaging(message) == status
+                    rescue ActiveRecord::RecordNotFound
+                      :not_found.should.messaging(message) == status
+                    end
+                  end
+                else
+                  test_case.it description do
+                    send(verb, action, immediate_values(params))
+                    status.should.messaging(message) == status
+                  end
+                end
+              else
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test/spec/rails/macros.rb

@@ -0,0 +1,79 @@
+module Test
+  module Spec
+    module Rails
+      module Macros
+        # Base class for all the proxy classes defined in the macros
+        class Proxy
+          attr_accessor :test_case
+          
+          def initialize(test_case)
+            self.test_case = test_case
+          end
+        end
+        
+        # Macros define methods on the Should class if they want to be called from the test case.
+        class Should < Proxy
+        end
+        
+        # Stores expression to be evaluated later in the correct binding
+        class LazyValue
+          attr_accessor :value
+          def initialize(value)
+            self.value = value
+          end
+        end
+        
+        module ClassMethods
+          # Returns an instance of the Should class, this allows you to call macros from the test
+          # case is a nice way:
+          #
+          #   should.disallow.get :index
+          def should
+            Test::Spec::Rails::Macros::Should.new(self)
+          end
+          
+          # Returns true when the passed name is a known table, we assume known tables also have fixtures
+          def known_fixture?(name)
+            respond_to?(:fixture_table_names) && fixture_table_names.include?(name.to_s)
+          end
+          
+          # Filter calls to fixture methods so we can use them in the definitions
+          def method_missing(method, *arguments, &block)
+            if known_fixture?(method)
+              arguments = arguments.map { |a| a.inspect }
+              Test::Spec::Rails::Macros::LazyValue.new("#{method}(#{arguments.join(', ')})")
+            else
+              super
+            end
+          end
+        end
+        
+        module InstanceMethods
+          # Interpret the non-immediate values in params and replace them
+          def immediate_values(params)
+            result = {}
+            params.each do |key, value|
+              result[key] = case value
+              when Hash
+                immediate_values(value)
+              when Test::Spec::Rails::Macros::LazyValue
+                eval(value.value).to_param
+              when Proc
+                value.call
+              else
+                value
+              end
+            end
+            result
+          end
+        end
+      end
+    end
+  end
+end
+
+Test::Spec::TestCase::ClassMethods.send(:include,    Test::Spec::Rails::Macros::ClassMethods)
+Test::Spec::TestCase::InstanceMethods.send(:include, Test::Spec::Rails::Macros::InstanceMethods)
+
+require 'test/spec/rails/macros/response'
+require 'test/spec/rails/macros/authorization'

data/lib/test/spec/rails/request_helpers.rb

@@ -0,0 +1,11 @@
+module Test
+  module Spec
+    module Rails
+      module RequestHelpers
+        attr_reader :request
+      end
+    end
+  end
+end
+
+ActionController::TestCase.send(:include, Test::Spec::Rails::RequestHelpers)