peck-on-rails 0.2.1 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 983910938947f3b167357b8884551802c68f461b
+  data.tar.gz: 4257a34ffdab95c6d6593a5474ff4a49e42026ff
+SHA512:
+  metadata.gz: 2da9e480923e109174e60bf29b1e9e18e944147398c1cea15f86949d45be1de947e0358b4c779493eb017b0e6ef4a19e9e7c56e001cbea87476ba2ad2b22d099
+  data.tar.gz: b51f97c1df464400c78878bc81dec1b8ba73cd96cd75c38a698d7777ac9a38bd42faef5835e13b145698bac105feade127aa6f9c5343b200277a9654bb0cfb0b

data/README.md

@@ -6,6 +6,197 @@ Peck-On-Rails is an extension for Peck to make testing Rails easier.
 
 ## Getting Started
 
-You can install Peck On Rails as a gem.
+You can install Peck-On-Rails as a gem. Note that the Peck dependency will automatically be fulfilled.
 
-    $ gem install peck-on-rails
+    $ gem install peck-on-rails
+    
+You can also add it to your Rails application's `Gemfile`.
+
+    group :test do
+      gem 'peck-on-rails'
+    end
+
+To use it in your Rails application, create or edit a file named `test/test_helper.rb`;
+
+    ENV["RAILS_ENV"] ||= "test"
+    require File.expand_path('../../config/environment', __FILE__)
+    
+    require 'peck/flavors/vanilla'
+    require 'peck_on_rails'
+
+You can read more about Peck formatting and flavors in [Peck's documentation](https://github.com/Fingertips/Peck).
+
+Don't forget to require your test helper in your test files. We like to require relative to the file so you can use Ruby to run the tests.
+
+    require File.expand_path('../../test_helper', __FILE__)
+    
+    describe AuthorsController do
+      should.find.get :index
+    end
+
+Now just run your test:
+
+    $ ruby test/functional/authors_controller_test.rb
+    .
+    1 spec, 0 failures, finished in 0.13 seconds.
+
+Alternatively Peck has a CLI tool to run tests for you:
+
+    $ peck test/models/book_test.rb
+    .
+    1 spec, 0 failures, finished in 0.0 seconds.
+
+## Test types
+
+Peck-On-Rails automatically supports model, controller, and helper specs. By default it figures out what kind of test your writing by the class found in the context. For example, POR will assume you're operating on an Active Record model when Book inherits from `ActiveRecord::Base`.
+
+    describe "A new", Book do
+      it "does not have any pages" do
+        book = Book.new
+        book.pages.count.should == 0
+      end
+    end
+
+If POR has trouble figuring out what you're doing, you can force it:
+
+    describe Candle, :model do
+    end
+
+Supported types are `:model`, `:controller`, and `:helper`.
+
+## Model specs
+
+POR loads fixtures for `:model` type tests. It also does this for `:controller` and `:helper` tests by the way. This also means it doesn't load fixtures for library specs.
+
+There is one little matcher that you get in your model specs: a validation matcher.
+
+    describe Book do
+      it "requires a title" do
+        book = Book.new
+
+        book.should.not.validate_with(:title, nil)
+        book.should.not.validate_with(:title, '')
+
+        book.should.validate_with(:title, 'The Fault in Our Stars')
+      end
+    end
+
+Note that this matcher is a bit dirty as it changes your instance:
+
+    describe Book do
+      it "requires a title" do
+        book = Book.new
+        book.should.not.validate_with(:title, nil)
+        p book.errors.full_messages
+      end
+    end
+
+## Helper specs
+
+In `:helper` specs you automatically get your helper module included.
+
+    describe BooksHelper do
+      it "formats titles" do
+        book = Book.new(title: 'Little Pinguin', :number = 12)
+        format_book_title(book).should == "12. Little Pinguin"
+      end
+    end
+
+## Controller specs
+
+For controller specs you get a `@controller` instance, a `controller` accessor, routing, and some nifty helpers.
+
+    describe "On the", BooksController, "a visitor" do
+      it "sees an overview of recent books" do
+        get :index
+        status.should == :ok
+        templates.should.include 'books/index'
+        body.should.match_css 'h1' # Only possible when Nokogiri is installed
+        body.should.match_xpath '//h1' # Only possible when Nokogiri is installed
+        body.document # Returns the Nokogiri Document
+      end
+
+      it "sees and overview of recent books in JSON" do
+        get :index, :format => 'json'
+        body.should.not.be.blank
+        body.json.keys.should.include 'books'
+      end
+    end
+
+On top of that you get some macro's to generate specs which will test basic functions of the controller.
+
+    describe "On the", Manage::BooksController, "a visitor" do
+      should.require_login :index
+    end
+   
+    describe "On the", Manage::BooksController, "a regular member" do
+      should.disallow :index
+    end
+   
+    describe "On the", Manage::BooksController, "an admin" do
+      should.find :index
+    end
+
+These generated specs assume there are three methods defined on the spec: `login_required?`, `disallowed?`, and `allowed?`. We usually define them as follows:
+
+    module TestHelper
+      module Authentication
+        def login_required?
+          if @request.format == 'text/html'
+            @response.location == new_session_url
+          else
+            @response.status == 401
+          end
+        end
+
+        def allowed?
+          @response.status == 200
+        end
+        
+        def disallowed?
+          @response.status == 403
+        end
+      end
+    end
+    
+    # Auto include these methods on all `:controller` context instances.
+    Peck::Context.once do |context|
+      case context_type
+      when :controller
+        extend TestHelper::Authentication
+      end
+    end
+
+## Writing matchers
+
+Right now you have to open up the `Peck::Should` class to do this:
+
+    class Peck
+      class Should
+        def validate_with(attribute, value)
+          message = "Expected #{!@negated ? 'no' : ''}errors on" +
+            " #{attribute.inspect} with value `#{value.inspect}' after validation"
+
+          @this.send("#{attribute}=", value)
+          @this.valid?
+          if @this.errors[attribute].kind_of?(Array)
+            satisfy(message) { @this.errors[attribute].empty? }
+          else
+            satisfy(message) { @this.errors[attribute].nil? }
+          end
+        end
+      end
+    end
+
+## Adding before or after methods for all specs
+
+You can use Peck's callback which is ran for each context once:
+
+    Peck::Context.once do |context|
+      class_eval do
+        before do
+          FileUtils.rm_rf(my_nice_directory)
+          FileUtils.mkdir_p(my_nice_directory)
+        end
+      end
+    end

data/lib/peck_on_rails.rb

@@ -6,195 +6,25 @@ require 'active_support/core_ext/kernel/reporting'
 require 'active_support/deprecation'
 require 'rails/backtrace_cleaner'
 
+require 'peck_on_rails/assertions'
+require 'peck_on_rails/backtrace_cleaning'
+require 'peck_on_rails/controller'
+require 'peck_on_rails/helper'
+require 'peck_on_rails/model'
+
 class Peck
   class Rails
-    module BacktraceCleaning
-      protected
-
-      def clean_backtrace(backtrace)
-        super Peck::Rails::BacktraceCleaning.backtrace_cleaner.clean(backtrace)
-      end
-
-      def self.backtrace_cleaner
-        ::Rails.backtrace_cleaner
-      end
-    end
-
-    class Context
-      def self.init(context, context_type, subject)
-        Peck.log("Peck::Rails::Context.init")
-      end
-    end
-
-    class Helper
-      def self.init(context, context_type, subject)
-        if [:helper].include?(context_type)
-          Peck.log("Peck::Rails::Helper.init")
-          context.class_eval do
-            include subject
-          end
-        end
-      end
-    end
-
-    class Model
-      def self.init(context, context_type, subject)
-        if [:model, :controller, :helper].include?(context_type)
-          Peck.log("Peck::Rails::Model.init")
-          context.class_eval do
-            include ::ActiveRecord::TestFixtures
-            self.fixture_path = File.join(::Rails.root, 'test', 'fixtures')
-            fixtures :all
-            define_method(:method_name) { self.class.label }
-          end
-        end
-      end
+    def self.dev_null
+      @dev_null ||= File.open('/dev/null', 'w')
     end
 
-    class Controller
-      def self.init(context, context_type, subject)
-        if context_type == :controller
-          Peck.log("Peck::Rails::Controller.init")
-          context.class_eval do
-            attr_accessor :controller
-
-            before do
-              @routes = ::Rails.application.routes
-            end
-
-            def self.determine_default_controller_class(name)
-              self._controller_class = Peck::Rails.subject(self)
-            end
-
-            include ::ActionController::TestCase::Behavior
-            include ::Peck::Rails::Controller::Helpers
-            extend ::Peck::Rails::Controller::Fixtures
-          end
-        end
-      end
-
-      # Stores expression to be evaluated later in the correct context
-      class LazyValue
-        def initialize(expression)
-          @expression = expression
-        end
-
-        def to_param(spec)
-          spec.instance_eval(@expression)
-        end
-
-        def inspect
-          @expression
-        end
-      end
-
-      module Fixtures
-        # 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 context definition
-        def method_missing(method, *arguments, &block)
-          if known_fixture?(method)
-            arguments = arguments.map { |a| a.inspect }
-            ::Peck::Rails::Controller::LazyValue.new("#{method}(#{arguments.join(', ')})")
-          else
-            super
-          end
-        end
-      end
-
-      module Helpers
-        def status
-          Peck::Rails::Controller::Status.new(@response)
-        end
-
-        def templates
-          # Force body to be read in case the template is being streamed
-          response.body
-          (@templates || @_templates).keys
-        end
-
-        def body
-          Peck::Rails::Controller::Body.new(@response)
-        end
-
-        # 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 ::Peck::Rails::Controller::LazyValue
-              value.to_param(self)
-            when Proc
-              value.call
-            else
-              value
-            end
-          end
-          result
-        end
-      end
-
-      class Status
-        def initialize(response)
-          @response = response
-        end
-
-        def ==(other)
-          case other
-          when Numeric
-            @response.status == other
-          else
-            code = Rack::Utils::SYMBOL_TO_STATUS_CODE[other]
-            @response.status === code
-          end
-        end
-
-        def inspect
-          "#<Peck::Rails::Controller::Status:#{@response.status}>"
-        end
-      end
-
-      class Body
-        def initialize(response)
-          @response = response
-        end
-
-        def document
-          if defined?(:Nokogiri)
-            @document ||= Nokogiri::HTML.parse(@response.body)
-          else
-            raise RuntimeError, "Please install Nokogiri to use the CSS or Xpath matchers (gem install nokogiri)"
-          end
-        end
-
-        def json
-          if defined?(:JSON)
-            @json ||= JSON.parse(@response.body)
-          else
-            raise RuntimeError, "Please install a JSON gem to use the json accessor (gem install json)"
-          end
-        end
-
-        def match_css?(query)
-          !document.css(query).empty?
-        end
-
-        def match_xpath?(query)
-          !document.xpath(query).empty?
-        end
-
-        def blank?
-          @response.body.blank?
-        end
-
-        def inspect
-          "#<html body=\"#{@response.body}\">"
-        end
+    def self.silence
+      stdout, stderr = $stdout, $stderr
+      $stdout, $stderr = dev_null, dev_null
+      begin
+        yield
+      ensure
+        $stdout, $stderr = stdout, stderr
       end
     end
 
@@ -213,9 +43,9 @@ class Peck
     def self.context_type_for_subject(context, subject)
       if subject.nil?
         :plain
-      elsif subject < ActionController::Base
+      elsif defined?(ActionController) && subject < ActionController::Base
         :controller
-      elsif subject < ActiveRecord::Base
+      elsif defined?(ActiveRecord) && subject < ActiveRecord::Base
         :model
       elsif subject.name =~ HELPER_RE
         :helper
@@ -233,12 +63,15 @@ class Peck
     end
 
     def self.init
+      if defined?(ActiveRecord)
+        Peck.log("Migrate database if necessary")
+        ActiveRecord::Migration.load_schema_if_pending!
+      end
       Peck.log("Setting up Peck::Rails")
       proc do |context|
         subject      = Peck::Rails.subject(context)
         context_type = Peck::Rails.context_type(context, subject)
         [
-          Peck::Rails::Context,
           Peck::Rails::Helper,
           Peck::Rails::Model,
           Peck::Rails::Controller
@@ -247,132 +80,23 @@ class Peck
         end
 
         context.before do
-          setup_fixtures if respond_to?(:setup_fixtures)
+          if respond_to?(:setup_fixtures)
+            begin
+              setup_fixtures
+            rescue ActiveRecord::ConnectionNotEstablished
+            end
+          end
         end
 
         context.after do
-          teardown_fixtures if respond_to?(:teardown_fixtures)
-        end
-      end
-    end
-  end
-end
-
-class Peck
-  class Should
-    class ResponseRequirement < Peck::Should::Proxy
-      SUPPORTED_VERBS = [:get, :post, :put, :delete, :options]
-
-      attr_accessor :method, :exception, :expected
-
-      def define_specification(verb, action, params={})
-        _method = self.method
-        _negated = self.negated
-        _expected = self.expected
-        _exception = self.exception
-        context.it(description(verb, action, params)) do
-          begin
-            send(verb, action, immediate_values(params))
-          rescue => raised_exception
-            if _negated
-              raised_exception.should.be.kind_of(_exception)
-            else
-              raised_exception.should.not.be.kind_of(_exception)
-            end
-          else
-            if _negated
-              send(_method).should.not == _expected
-            else
-              send(_method).should == _expected
+          if respond_to?(:teardown_fixtures)
+            begin
+              teardown_fixtures
+            rescue ActiveRecord::ConnectionNotEstablished
             end
           end
         end
       end
-
-      def method_missing(method, *attributes, &block)
-        verb = method.to_sym
-        if self.class.supported_verbs.include?(verb)
-          define_specification(verb, *attributes)
-        else
-          super
-        end
-      end
-
-      def self.supported_verbs
-        SUPPORTED_VERBS
-      end
-    end
-
-    class RequireLogin < ResponseRequirement
-      def description(verb, action, params={})
-        description = []
-        description << "should not" if (negated == false)
-        description << "#{verb.upcase}s `#{action}' without logging in"
-        description << "#{params.inspect}" unless params.blank?
-        description.join(' ')
-      end
-    end
-
-    class Disallow < ResponseRequirement
-      def description(verb, action, params={})
-        description = ["should"]
-        description << "not" if (negated == false)
-        description << "be allowed to #{verb.upcase}s `#{action}'"
-        description << "#{params.inspect}" unless params.blank?
-        description.join(' ')
-      end
-    end
-
-    class Response < ResponseRequirement
-      attr_accessor :verb_description
-
-      def description(verb, action, params={})
-        description = ["should"]
-        description << "not" if (negated == false)
-        description << "#{verb_description} `#{action}'"
-        description << "#{params.inspect}" unless params.blank?
-        description.join(' ')
-      end
-    end
-
-    class Specification
-      def require_login
-        requirement = RequireLogin.new(context)
-        requirement.negated = @negated
-        requirement.method = :login_required?
-        requirement.expected = true
-        requirement
-      end
-
-      def disallow
-        requirement = Disallow.new(context)
-        requirement.negated = @negated
-        requirement.method = :disallowed?
-        requirement.expected = true
-        requirement
-      end
-
-      def allow
-        requirement = Disallow.new(context)
-        requirement.negated = @negated
-        requirement.method = :allowed?
-        requirement.expected = true
-        requirement
-      end
-
-      def find
-        requirement = Response.new(context)
-        requirement.negated = @negated
-        requirement.verb_description = 'find'
-        requirement.method = :status
-        if @negated
-          requirement.expected = :not_found
-          requirement.exception = ActiveRecord::RecordNotFound
-        else
-          requirement.expected = :ok
-        end
-        requirement
-      end
     end
   end
 end
@@ -385,20 +109,4 @@ class Peck
   end
 end
 
-class Peck
-  class Should
-    def validate_with(attribute, value)
-      message = "Expected #{!@negated ? 'no' : ''}errors on #{attribute.inspect} with value `#{value.inspect}' after validation"
-
-      @this.send("#{attribute}=", value)
-      @this.valid?
-      if @this.errors[attribute].kind_of?(Array)
-        satisfy(message) { @this.errors[attribute].empty? }
-      else
-        satisfy(message) { @this.errors[attribute].nil? }
-      end
-    end
-  end
-end
-
 Peck::Context.once(&Peck::Rails.init)

data/lib/peck_on_rails/assertions.rb

@@ -0,0 +1,182 @@
+class Peck
+  class Should
+    class ResponseRequirement < Peck::Should::Proxy
+      SUPPORTED_VERBS = [:get, :post, :put, :delete, :options]
+
+      attr_accessor :method, :allowed_exceptions, :expected
+
+      def define_specification(verb, action, params={})
+        _method = self.method
+        _negated = self.negated
+        _expected = self.expected
+        _allowed_exceptions = self.allowed_exceptions
+        context.it(description(verb, action, params)) do
+          begin
+            send(verb, action, immediate_values(params))
+          rescue => raised_exception
+            if _allowed_exceptions
+              _allowed_exceptions.any? { |exception| raised_exception.should.be.kind_of(exception) }
+              true.should == true # Force the expectations counter
+            else
+              raise
+            end
+          else
+            if _negated
+              send(_method).should.not == _expected
+            else
+              send(_method).should == _expected
+            end
+          end
+        end
+      end
+
+      def method_missing(method, *attributes, &block)
+        verb = method.to_sym
+        if self.class.supported_verbs.include?(verb)
+          define_specification(verb, *attributes)
+        else
+          super
+        end
+      end
+
+      def self.supported_verbs
+        SUPPORTED_VERBS
+      end
+    end
+
+    class RequireLogin < ResponseRequirement
+      def description(verb, action, params={})
+        description = []
+        description << "should not" if (negated == false)
+        description << "#{verb.upcase}s `#{action}' without logging in"
+        description << "#{params.inspect}" unless params.blank?
+        description.join(' ')
+      end
+    end
+
+    class Disallow < ResponseRequirement
+      def description(verb, action, params={})
+        description = ["should"]
+        description << "not" if (negated == false)
+        description << "be allowed to #{verb.upcase}s `#{action}'"
+        description << "#{params.inspect}" unless params.blank?
+        description.join(' ')
+      end
+    end
+
+    class Response < ResponseRequirement
+      attr_accessor :verb_description
+
+      def description(verb, action, params={})
+        description = ["should"]
+        description << "not" if (negated == false)
+        description << "#{verb_description} `#{action}'"
+        description << "#{params.inspect}" unless params.blank?
+        description.join(' ')
+      end
+    end
+
+    class Specification
+      def self.allowed_exceptions
+        allowed_exceptions = []
+        if defined?(ActiveRecord)
+          allowed_exceptions << ActiveRecord::RecordNotFound
+        end
+        if defined?(AbstractController)
+          allowed_exceptions << AbstractController::ActionNotFound
+        end
+        allowed_exceptions
+      end
+      ALLOWED_EXCEPTIONS = allowed_exceptions
+      
+      def require_login
+        requirement = RequireLogin.new(context)
+        requirement.negated = @negated
+        requirement.method = :login_required?
+        requirement.expected = true
+        requirement
+      end
+
+      def disallow
+        requirement = Disallow.new(context)
+        requirement.negated = @negated
+        requirement.method = :disallowed?
+        requirement.expected = true
+        requirement
+      end
+
+      def allow
+        requirement = Disallow.new(context)
+        requirement.negated = @negated
+        requirement.method = :allowed?
+        requirement.expected = true
+        requirement
+      end
+
+      def find
+        requirement = Response.new(context)
+        requirement.verb_description = 'find'
+        requirement.method = :status
+        if @negated
+          requirement.expected = :not_found
+          requirement.allowed_exceptions = ALLOWED_EXCEPTIONS
+        else
+          requirement.expected = :ok
+        end
+        requirement
+      end
+    end
+
+    def equal_record_set(*others)
+      left = @this.flatten
+      right = others.flatten
+
+      message = "Expected the record set to be #{!@negated ? 'equal' : 'unequal'}: #{left.map(&:id).inspect} - #{right.map(&:id).inspect}"
+      satisfy(message) { Set.new(left) == Set.new(right) }
+    end
+
+    def equal_record_array(*others)
+      left = @this.flatten
+      right = others.flatten
+
+      message = "Expected the array of records to be #{!@negated ? 'equal' : 'unequal'}: #{left.map(&:id).inspect} - #{right.map(&:id).inspect}"
+      satisfy(message) { left == right }
+    end
+
+    def equal_set(*others)
+      left = @this.flatten
+      right = others.flatten
+
+      message = "Expected sets to be #{!@negated ? 'equal' : 'unequal'}: #{left.inspect} - #{right.inspect}"
+      satisfy(message) { Set.new(left) == Set.new(right) }
+    end
+
+    def equal_keys(other)
+      left = @this.keys.map(&:to_s).sort
+      right = other.map(&:to_s).sort
+
+      missing_from_left = left - right
+      missing_from_right = right - left
+      message = "Expected the object to #{!@negated ? 'have' : 'not have'} the same keys:\n#{left.inspect}\n#{right.inspect}\n>>> #{missing_from_left.inspect}\n<<< #{missing_from_right.inspect}"
+      satisfy(message) { left == right }
+    end
+
+    def redirect_to(somewhere)
+      message = "Expected to redirect to `#{somewhere}'"
+      response = @this.send(:response)
+      satisfy(message) { [301, 302].include?(response.status.to_i) && response.location == somewhere }
+    end
+
+    def validate_with(attribute, value)
+      message = "Expected #{!@negated ? 'no' : ''}errors on #{attribute.inspect} with value `#{value.inspect}' after validation"
+
+      @this.send("#{attribute}=", value)
+      @this.valid?
+      if @this.errors[attribute].kind_of?(Array)
+        satisfy(message) { @this.errors[attribute].empty? }
+      else
+        satisfy(message) { @this.errors[attribute].nil? }
+      end
+    end
+  end
+end

data/lib/peck_on_rails/backtrace_cleaning.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+class Peck
+  class Rails
+    module BacktraceCleaning
+      protected
+
+      def clean_backtrace(backtrace)
+        super Peck::Rails::BacktraceCleaning.backtrace_cleaner.clean(backtrace)
+      end
+
+      def self.backtrace_cleaner
+        ::Rails.backtrace_cleaner
+      end
+    end
+  end
+end

data/lib/peck_on_rails/controller.rb

@@ -0,0 +1,152 @@
+class Peck
+  class Rails
+    class Controller
+      def self.init(context, context_type, subject)
+        if context_type == :controller
+          Peck.log("Peck::Rails::Controller.init")
+          context.class_eval do
+            attr_accessor :controller
+
+            before do
+              @routes = ::Rails.application.routes
+            end
+
+            def self.determine_default_controller_class(name)
+              self._controller_class = Peck::Rails.subject(self)
+            end
+
+            Peck::Rails.silence do
+              include ::ActionController::TestCase::Behavior
+            end
+            include ::Peck::Rails::Controller::Helpers
+            extend ::Peck::Rails::Controller::Fixtures
+          end
+        end
+      end
+
+      # Stores expression to be evaluated later in the correct context
+      class LazyValue
+        def initialize(expression)
+          @expression = expression
+        end
+
+        def to_param(spec)
+          spec.instance_eval(@expression)
+        end
+
+        def inspect
+          @expression
+        end
+      end
+
+      module Fixtures
+        # 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 context definition
+        def method_missing(method, *arguments, &block)
+          if known_fixture?(method)
+            arguments = arguments.map { |a| a.inspect }
+            ::Peck::Rails::Controller::LazyValue.new("#{method}(#{arguments.join(', ')})")
+          else
+            super
+          end
+        end
+      end
+
+      module Helpers
+        def status
+          Peck::Rails::Controller::Status.new(@response)
+        end
+
+        def templates
+          # Force body to be read in case the template is being streamed
+          response.body
+          (@templates || @_templates).keys
+        end
+
+        def body
+          Peck::Rails::Controller::Body.new(@response)
+        end
+
+        # 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 ::Peck::Rails::Controller::LazyValue
+              value.to_param(self)
+            when Proc
+              value.call
+            else
+              value
+            end
+          end
+          result
+        end
+      end
+
+      class Status
+        def initialize(response)
+          @response = response
+        end
+
+        def ==(other)
+          case other
+          when Numeric
+            @response.status == other
+          else
+            code = Rack::Utils::SYMBOL_TO_STATUS_CODE[other]
+            @response.status === code
+          end
+        end
+
+        def inspect
+          "#<Peck::Rails::Controller::Status:#{@response.status}>"
+        end
+      end
+
+      class Body
+        def initialize(response)
+          @response = response
+        end
+
+        def document
+          if defined?(Nokogiri)
+            @document ||= Nokogiri::HTML.parse(@response.body)
+          else
+            raise RuntimeError, "Please install Nokogiri to use the CSS or Xpath matchers (gem install nokogiri)"
+          end
+        end
+
+        def json
+          if defined?(JSON)
+            @json ||= JSON.parse(@response.body)
+          else
+            raise RuntimeError, "Please install a JSON gem to use the json accessor (gem install json)"
+          end
+        end
+
+        def match_css?(query)
+          !document.css(query).empty?
+        end
+
+        def match_xpath?(query)
+          !document.xpath(query).empty?
+        end
+
+        def blank?
+          @response.body.blank?
+        end
+
+        def inspect
+          "#<html body=\"#{@response.body}\">"
+        end
+      end
+    end
+  end
+end

data/lib/peck_on_rails/helper.rb

@@ -0,0 +1,17 @@
+
+# encoding: utf-8
+
+class Peck
+  class Rails
+    class Helper
+      def self.init(context, context_type, subject)
+        if [:helper].include?(context_type)
+          Peck.log("Peck::Rails::Helper.init")
+          context.class_eval do
+            include subject
+          end
+        end
+      end
+    end
+  end
+end

data/lib/peck_on_rails/model.rb

@@ -0,0 +1,19 @@
+class Peck
+  class Rails
+    class Model
+      def self.init(context, context_type, subject)
+        if [:model, :controller, :helper].include?(context_type)
+          Peck.log("Peck::Rails::Model.init")
+          context.class_eval do
+            if defined?(::ActiveRecord)
+              include ::ActiveRecord::TestFixtures
+            end
+            self.fixture_path = File.join(::Rails.root, 'test', 'fixtures')
+            fixtures :all
+            define_method(:method_name) { self.class.label }
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,84 +1,82 @@
 --- !ruby/object:Gem::Specification
 name: peck-on-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.1
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Manfred Stienstra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2014-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: peck
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! '    Peck-On-Rails is an extension for Peck to make testing Rails easier.
-
-'
+description: |2
+      Peck-On-Rails is an extension for Peck to make testing Rails easier.
 email: manfred@fngtps.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - COPYING
 files:
-- lib/peck_on_rails.rb
 - COPYING
 - README.md
+- lib/peck_on_rails.rb
+- lib/peck_on_rails/assertions.rb
+- lib/peck_on_rails/backtrace_cleaning.rb
+- lib/peck_on_rails/controller.rb
+- lib/peck_on_rails/helper.rb
+- lib/peck_on_rails/model.rb
 homepage: 
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --charset=utf-8
+- "--charset=utf-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Peck-On-Rails adds useful helpers and context extensions to make testing
   Ruby on Rails apps easier.
 test_files: []