on-test-spec 0.2.6 → 0.3.0

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rake/testtask'
+require 'rake/rdoctask'
 
 desc "By default run all tests"
 task :default => :test
@@ -9,6 +10,15 @@ Rake::TestTask.new do |t|
   t.verbose = true
 end
 
+desc 'Generate documentation'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'On Test-spec'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |s|

data/VERSION.yml

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

data/lib/test/spec/rails.rb

@@ -1,5 +1,6 @@
 require 'test/spec'
 
+require 'active_support'
 require 'active_support/test_case'
 
 require 'active_record'
@@ -11,36 +12,51 @@ require 'action_controller/test_case'
 require 'action_view'
 require 'action_view/test_case'
 
-%w(test_spec_ext spec_responder expectations).each { |lib| require "test/spec/rails/#{lib}" }
-Dir[File.dirname(__FILE__) + '/rails/**/*_helpers.rb'].each { |lib| require lib }
-
 module Test
   module Spec
     module Rails
-      def self.extract_test_case_args(args)
-        class_to_test = args.find { |a| a.is_a?(Module) }
-        superclass    = test_case_for_class(class_to_test)
+    end
+  end
+end
 
-        args.delete(class_to_test) if superclass == class_to_test
-        name          = args.map { |a| a.to_s }.join(' ')
+require 'test/spec/rails/test_spec_ext'
+require 'test/spec/rails/spec_responder'
+require 'test/spec/rails/expectations'
 
-        [name, class_to_test, superclass]
-      end
-      
-      def self.test_case_for_class(klass)
-        if klass
-          if klass.ancestors.include?(ActiveRecord::Base)
-            ActiveRecord::TestCase
-          elsif klass.ancestors.include?(ActionController::Base)
-            ActionController::TestCase
-          elsif klass.ancestors.include?(ActiveSupport::TestCase)
-            klass
-          elsif !klass.is_a?(Class) && klass.to_s.ends_with?('Helper')
-            ActionView::TestCase
-          end
-        end || ActiveSupport::TestCase
+require 'test/spec/rails/request_helpers'
+require 'test/spec/rails/response_helpers'
+require 'test/spec/rails/controller_helpers'
+
+
+module Test::Spec::Rails
+  # Returns the test class for a definition line in a spec.
+  #
+  #   extract_test_case_args(["A", User, "concerning validation"]) # => ActiveRecord::TestCase
+  def self.extract_test_case_args(args)
+    class_to_test = args.find { |a| a.is_a?(Module) }
+    superclass    = test_case_for_class(class_to_test)
+
+    args.delete(class_to_test) if superclass == class_to_test
+    name          = args.map { |a| a.to_s }.join(' ')
+
+    [name, class_to_test, superclass]
+  end
+
+  # Returns the test class for a class
+  #
+  #   extract_test_case_for_class(UsersController) # => ActionController::TestCase
+  def self.test_case_for_class(klass)
+    if klass
+      if klass.ancestors.include?(ActiveRecord::Base)
+        ActiveRecord::TestCase
+      elsif klass.ancestors.include?(ActionController::Base)
+        ActionController::TestCase
+      elsif klass.ancestors.include?(ActiveSupport::TestCase)
+        klass
+      elsif !klass.is_a?(Class) && klass.to_s.ends_with?('Helper')
+        ActionView::TestCase
       end
-    end
+    end || ActiveSupport::TestCase
   end
 end
 
@@ -89,12 +105,12 @@ module Kernel
     spec.testcase.class_eval(&block)
     spec
   end
-  
+
   def xcontext(*args, &block)
     name, _, superclass = Test::Spec::Rails.extract_test_case_args(args)
     xcontext_before_on_test_spec(name, superclass, &block)
   end
-  
+
   private :context, :xcontext
   
   alias :describe :context

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

@@ -1,10 +1,6 @@
-module Test
-  module Spec
-    module Rails
-      module ControllerHelpers
-        attr_reader :controller
-      end
-    end
+module Test::Spec::Rails
+  module ControllerHelpers
+    attr_reader :controller
   end
 end
 

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

@@ -1,189 +1,209 @@
-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)
-          redirect_url = @object.response.respond_to?(:redirect_url) ? @object.response.redirect_url : @object.response.redirected_to
-          if args.empty?
-            test_case.assert_response redirect_url, :redirect
-          elsif args.length == 1 and args.first.is_a?(String)
-            test_case.assert_equal args.first, redirect_url
-          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 redirect_url.starts_with?('https:')
-            elsif secure == false
-              test_case.assert redirect_url.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]
+module Test::Spec::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)
+      redirect_url = @object.response.respond_to?(:redirect_url) ? @object.response.redirect_url : @object.response.redirected_to
+      if args.empty?
+        test_case.assert_response redirect_url, :redirect
+      elsif args.length == 1 and args.first.is_a?(String)
+        test_case.assert_equal args.first, redirect_url
+      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
-          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)
+        @object.instance_eval { test_case.assert_redirected_to *args }
+        if secure == true
+          test_case.assert redirect_url.starts_with?('https:')
+        elsif secure == false
+          test_case.assert redirect_url.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
       
-      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
+      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
+    
+    # Tests if the model has errors on the attribute after validation for the presented value
+    def validate_with(attribute, value)
+      message = "Expected #{attribute.inspect} with value `#{value.inspect}' to validate"
+      @object.send("#{attribute}=", value)
+      @object.valid?
+      if @object.errors[attribute].kind_of?(Array)
+        test_case.assert(@object.errors[attribute].empty?, message)
+      else
+        test_case.assert(@object.errors.on(attribute).nil?, message)
+      end
+    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
+    
+    # Tests if the model has errors on the attribute after validation for the presented value
+    def validate_with(attribute, value)
+      message = "Expected errors on #{attribute.inspect} with value `#{value.inspect}' after validation"
+      @object.send("#{attribute}=", value)
+      @object.valid?
+      if @object.errors[attribute].kind_of?(Array)
+        test_case.assert(!@object.errors[attribute].empty?, message)
+      else
+        test_case.assert(!@object.errors.on(attribute).nil?, message)
       end
     end
   end

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

@@ -1,72 +1,68 @@
-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
+module Test::Spec::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
-        
-        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
+    
+    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

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

@@ -1,77 +1,73 @@
-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
+module Test::Spec::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
           
-          # 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
+          super(test_case)
         end
         
-        module Authorization
-          class TestGenerator < Proxy
-            attr_accessor :validation_method, :message, :expected
+        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?
             
-            def initialize(test_case, validation_method, expected, message)
-              self.validation_method = validation_method
-              self.expected = expected
-              self.message = message
-              
-              super(test_case)
-            end
+            validation_method = self.validation_method
+            expected = self.expected
+            message = self.message
             
-            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
+            test_case.it description do
+              send(verb, action, immediate_values(params))
+              send(validation_method).should.messaging(message) == expected
             end
+          else
+            super
           end
         end
       end

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

@@ -1,54 +1,50 @@
-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
+module Test::Spec::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
+        def initialize(test_case, status, message)
+          self.status = status
+          self.message = message
 
-              super(test_case)
-            end
+          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?
+        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
+            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
-              else
-                super
+              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

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

@@ -1,10 +1,6 @@
-module Test
-  module Spec
-    module Rails
-      module RequestHelpers
-        attr_reader :request
-      end
-    end
+module Test::Spec::Rails
+  module RequestHelpers
+    attr_reader :request
   end
 end
 

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

@@ -1,40 +1,36 @@
-module Test
-  module Spec
-    module Rails
-      class Status < SpecResponder
-        def should_equal(status, message=nil)
-          @test_case.send(:assert_response, status, message)
-        end
-      end
-      
-      class Template < SpecResponder
-        def should_equal(template, message=nil)
-          @test_case.send(:assert_template, template, message)
-        end
-      end
-      
-      class Layout < SpecResponder
-        def should_equal(layout, message=nil)
-          rendered_layout = @test_case.response.layout.gsub(/layouts\//, '')
-          @test_case.send(:assert_equal, layout, rendered_layout, message)
-        end
-      end
-      
-      module ResponseHelpers
-        attr_reader :response
-        
-        def status
-          Test::Spec::Rails::Status.new(self)
-        end
-        
-        def template
-          Test::Spec::Rails::Template.new(self)
-        end
-        
-        def layout
-          Test::Spec::Rails::Layout.new(self)
-        end
-      end
+module Test::Spec::Rails
+  class Status < SpecResponder
+    def should_equal(status, message=nil)
+      @test_case.send(:assert_response, status, message)
+    end
+  end
+  
+  class Template < SpecResponder
+    def should_equal(template, message=nil)
+      @test_case.send(:assert_template, template, message)
+    end
+  end
+  
+  class Layout < SpecResponder
+    def should_equal(layout, message=nil)
+      rendered_layout = @test_case.response.layout.gsub(/layouts\//, '')
+      @test_case.send(:assert_equal, layout, rendered_layout, message)
+    end
+  end
+  
+  module ResponseHelpers
+    attr_reader :response
+    
+    def status
+      Test::Spec::Rails::Status.new(self)
+    end
+    
+    def template
+      Test::Spec::Rails::Template.new(self)
+    end
+    
+    def layout
+      Test::Spec::Rails::Layout.new(self)
     end
   end
 end

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

@@ -1,12 +1,6 @@
-module Test
-  module Spec
-    module Rails
-      class SpecResponder
-        attr_accessor :test_case
-        def initialize(test_case)
-          self.test_case = test_case
-        end
-      end
-    end
+class Test::Spec::Rails::SpecResponder
+  attr_accessor :test_case
+  def initialize(test_case)
+    self.test_case = test_case
   end
 end

data/lib/test/spec/share.rb

@@ -45,4 +45,5 @@ module SharedSpecsInclusionHelper
     self.class_eval &$shared_specs[name]
   end
 end
+
 Test::Unit::TestCase.send(:extend, SharedSpecsInclusionHelper)

data/test/expectations_test.rb

@@ -395,6 +395,66 @@ describe "Record expectations" do
   end
 end
 
+class Account < ActiveRecord::Base
+  validates_presence_of :username
+end
+
+describe "Validation expectations" do
+  include AssertionAssertions
+  
+  def configure_database
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+    ActiveRecord::Migration.verbose = false
+  end
+
+  def setup_database
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :accounts do |t|
+        t.column :fullname, :string
+        t.column :email, :string
+        t.column :username, :string
+        t.column :password, :string
+      end
+    end
+  end
+
+  def teardown_database
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+  end
+  
+  before(:all) { configure_database }
+  
+  before do
+    setup_database
+    TestingAssertionsThemselves.setup
+    @account = Account.new
+  end
+  
+  after { teardown_database }
+  
+  it "succeeds when there are no validation errors on the attribute and there were no expected" do
+    @account.should.validate_with(:username, 'admin')
+    assert_assert_success
+  end
+  
+  it "fails when there are no validation errors on the attribute and there was one expected" do
+    @account.should.not.validate_with(:email, '')
+    assert_assert_failure("Expected errors on :email with value `\"\"' after validation")
+  end
+  
+  it "succeeds when there is a validation error on the attribute and there was one expected" do
+    @account.should.not.validate_with(:username, '')
+    assert_assert_success
+  end
+  
+  it "fails when there is a validation error on the attribute and there were no expected" do
+    @account.should.validate_with(:username, '')
+    assert_assert_failure("Expected :username with value `\"\"' to validate")
+  end
+end
+
 class TestController
   def request
     unless @request

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: on-test-spec
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 6
-  version: 0.2.6
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Manfred Stienstra
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-23 00:00:00 +01:00
+date: 2011-03-23 00:00:00 +01:00
 default_executable: 
 dependencies: []