micronaut-rails 0.3.3

data/LICENSE

@@ -0,0 +1,45 @@
+Copyright (c) 2008 Chad Humphries
+
+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.
+
+
+The matchers and expectations are licensed:
+(The MIT License)
+
+Copyright (c) 2005-2008 The RSpec Development Team
+
+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,25 @@
+= Micronaut Rails
+
+* http://github.com/spicycode/micronaut-rails
+* http://relevance.lighthouseapp.com/projects/22819-micronaut
+
+== DESCRIPTION:
+
+Micronaut Rails is a set of extension to deal with rails mode testing. For the moment think of it is a prototype of
+RSpec lite.  Definitely pre alpha at the moment.
+
+== REQUIREMENTS:
+
+* Ruby 1.8.6+
+* ActionPack
+* Micronaut (via spicycode-micronaut on GitHub) 
+
+== ISSUES
+
+* No support for pure Rails fixtures, and no plans to add it - we use Factory Girl/Fixture Replacement instead, so send a patch if you want support for this).
+* No support for Rails integration tests -- use Cucumber (http://github.com/aslakhellesoy/cucumber) instead!
+* In use in real-world projects on Rails 2.3+ - older versions may have issues.
+
+== CREDITS:
+
+* RSpec for the great ideas and matchers

data/RSPEC-LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+ 
+Copyright (c) 2005-2008 The RSpec Development Team
+ 
+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/Rakefile

@@ -0,0 +1,37 @@
+begin 
+  require 'jeweler' 
+  Jeweler::Tasks.new do |s| 
+    s.name = "micronaut-rails" 
+    s.summary = "An excellent replacement for the wheel on rails..."
+    s.email = "chad@spicycode.com" 
+    s.homepage = "http://github.com/spicycode/micronaut-rails" 
+    s.description = "An excellent replacement for the wheel on rails..."
+    s.authors = ["Chad Humphries"] 
+    s.files =  FileList["[A-Z]*", "{bin,lib,examples}/**/*"] 
+    s.add_dependency "actionpack", '>= 2.3.0'
+    s.add_dependency "micronaut", '>= 0.3.0'
+  end 
+rescue LoadError 
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com" 
+end
+
+gem 'micronaut'
+require 'micronaut/rake_task'
+
+desc "Run all micronaut examples"
+Micronaut::RakeTask.new :examples do |t|
+  t.pattern = "examples/**/*_example.rb"
+end
+
+namespace :examples do
+  
+  desc "Run all micronaut examples using rcov"
+  Micronaut::RakeTask.new :coverage do |t|
+    t.pattern = "examples/**/*_example.rb"
+    t.rcov = true
+    t.rcov_opts = %[--exclude "examples/*,gems/*,db/*,/Library/Ruby/*,config/*" --text-summary  --sort coverage]
+  end
+
+end
+
+task :default => 'examples:coverage'

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 3
+:major: 0
+:minor: 3

data/examples/example_helper.rb

@@ -0,0 +1,56 @@
+lib_path = File.expand_path(File.dirname(__FILE__) + "/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+require 'rubygems'
+
+begin
+  gem "micronaut", ">= 0.3.0"
+rescue LoadError => e
+  puts "\nERROR - This version of micronaut-rails requires micronaut 0.2.2 or higher."
+  puts "gem install micronaut --version 0.2.2"
+  puts
+  exit(1)
+end
+require 'action_controller'
+require 'micronaut'
+require 'micronaut-rails'
+
+gem "mocha"
+
+module Micronaut  
+  module Matchers
+    def fail
+      raise_error(::Micronaut::Expectations::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(::Micronaut::Expectations::ExpectationNotMetError, message)
+    end
+  end
+end
+
+def remove_last_describe_from_world
+  Micronaut.world.behaviours.pop
+end
+
+class DummyFormatter <  Micronaut::Formatters::BaseTextFormatter; end
+
+def dummy_reporter
+  DummyFormatter.new({}, StringIO.new)
+end
+
+def use_color?
+  !ENV.has_key?('TM_MODE')
+end
+
+# allow including links to lighthouse tickets in examples, for regression tests, pending features, etc.
+def ticket(number)
+  %[http://relevance.lighthouseapp.com/projects/22819-micronaut/tickets/#{number}]
+end
+
+Micronaut.configure do |config|
+  config.mock_with :mocha
+  config.color_enabled = use_color?
+  config.formatter = :documentation
+  config.filter_run :focused => true
+end

data/examples/lib/micronaut/rails/configuration_example.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Rails::Configuration do
+
+  example "loading micronaut rails include it in the micronaut configuration class" do
+    Micronaut::Configuration.included_modules.should include(Micronaut::Rails::Configuration)
+  end
+  
+  it "should add a #rails method" do
+    Micronaut.configuration.should respond_to(:rails)
+  end
+  
+  it "should add an #enable_active_record_transactional_support method" do
+    Micronaut.configuration.should respond_to(:enable_active_record_transactional_support)
+  end
+  
+  describe "helpers for standard Rails testing support" do
+    
+    method_to_modules = { :enable_helper_support => Micronaut::Rails::Helpers,
+                          :enable_active_record_transactional_support => Micronaut::Rails::TransactionalDatabaseSupport,
+                          :enable_controller_support => Micronaut::Rails::Controllers
+                        }
+    method_to_modules.each do |method, mod| 
+      example "##{method} with no filter options" do
+        Micronaut.configuration.send(method)
+        Micronaut.configuration.include_or_extend_modules.should include([:extend, mod, {}])
+      end
+      
+      example "##{method} with filter options" do
+        filter_options = {:options => { "foo" => "bar" } }
+        Micronaut.configuration.send(method, filter_options)
+        Micronaut.configuration.include_or_extend_modules.should include([:extend, mod, filter_options])
+      end
+    end
+    
+    example "#enable_rails_specific_mocking_extensions for mocha with no filter options" do
+      Micronaut.configuration.mock_with :mocha
+      Micronaut.configuration.enable_rails_specific_mocking_extensions
+      Micronaut.configuration.include_or_extend_modules.should include([:include, Micronaut::Rails::Mocking::WithMocha, {}])
+    end
+
+  end
+
+end

data/examples/lib/micronaut-rails_example.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + "/../example_helper")
+
+describe Micronaut::Rails do
+  
+  pending "should never include lib/autotest in the gemspec, as it breaks autotest for Micronaut - see #{ticket 4}
+            PENDING due to jeweler changing the gemspec tasks..." do
+    # We jump through hoops to make sure the Rake deprecation notice doesn't show up in the build (via stderr) or
+    # in the gemspec itself
+    silence_stream(STDERR) do
+      @spec_string = `rake --silent gemspec`
+    end
+    @spec_string.gsub! /Gem::manage_gems is deprecated/, "" 
+    gem_spec = eval(@spec_string)
+    gem_spec.files.each { |f| f.should_not match(%r|lib/autotest|) }
+  end
+end

data/lib/micronaut/rails/configuration.rb

@@ -0,0 +1,48 @@
+module Micronaut
+  module Rails
+    
+    module Configuration
+      
+      def rails
+        self
+      end
+      
+      # :behaviour => { :describes => lambda { |dt| dt < ActiveRecord::Base }
+      def enable_active_record_transactional_support(filter_options={})
+        ::Micronaut.configuration.extend(::Micronaut::Rails::TransactionalDatabaseSupport, filter_options)
+      end
+      
+      # :behaviour => { :describes => lambda { |dt| dt.to_s.ends_with?('Helper') }
+      def enable_helper_support(filter_options={})
+        ::Micronaut.configuration.extend(::Micronaut::Rails::Helpers, filter_options)
+      end
+      
+      # :behaviour => { :describes => lambda { |dt| dt < ActionController::Base } 
+      def enable_controller_support(filter_options={})
+        ::Micronaut.configuration.extend(::Micronaut::Rails::Controllers, filter_options)
+      end
+      
+      def enable_rails_specific_mocking_extensions(filter_options={})
+        case ::Micronaut.configuration.mock_framework.to_s
+        when /mocha/i
+          require 'micronaut/rails/mocking/with_mocha'
+          ::Micronaut.configuration.include(::Micronaut::Rails::Mocking::WithMocha, filter_options)
+         when /rr/i
+          require 'micronaut/rails/mocking/with_rr'
+          ::Micronaut.configuration.include(::Micronaut::Rails::Mocking::WithRR, filter_options)
+        end
+      end
+      
+      def enable_reasonable_defaults!
+        enable_active_record_transactional_support
+        enable_helper_support :behaviour => { :describes => lambda { |dt| dt.to_s.ends_with?('Helper') } }
+        enable_controller_support :behaviour => { :describes => lambda { |dt| dt < ::ActionController::Base } }
+        enable_rails_specific_mocking_extensions
+      end
+      
+    end
+    
+  end
+end
+
+::Micronaut::Configuration.send(:include, ::Micronaut::Rails::Configuration)

data/lib/micronaut/rails/controllers.rb

@@ -0,0 +1,86 @@
+require 'action_controller'
+require 'action_controller/test_process'
+
+module Micronaut
+  module Rails
+    module Controllers
+
+      module InstanceMethods
+        attr_reader :request, :response, :controller
+
+        def route_for(options)
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+          ActionController::Routing::Routes.generate(options)
+        end
+
+        def params_from(method, path)
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+          ActionController::Routing::Routes.recognize_path(path, :method => method)
+        end
+
+      end
+
+      module TemplateIsolationExtensions
+        def file_exists?(ignore); true; end
+        
+        def render_file(*args)
+          @first_render ||= args[0] unless args[0] =~ /^layouts/
+        end
+        
+        def render(*args)
+          return super if Hash === args.last && args.last[:inline]
+          record_render(args[0])
+        end
+      
+      private
+      
+        def record_render(opts)
+          @_rendered ||= {}
+          (@_rendered[:template] ||= opts[:file]) if opts[:file]
+          (@_rendered[:partials][opts[:partial]] += 1) if opts[:partial]
+        end
+
+      end
+
+
+      module RenderOverrides
+
+        def render_views!
+          @render_views = true
+        end
+
+        def rendering_views?
+          @render_views
+        end
+        
+        def render(options=nil, extra_options={}, &block)
+          unless block_given?
+            unless rendering_views?
+              @template.extend TemplateIsolationExtensions
+            end
+          end
+ 
+          super
+        end
+
+      end
+
+      def self.extended(extended_behaviour)
+        extended_behaviour.send :include, ::ActionController::TestProcess, InstanceMethods, ::Micronaut::Rails::Matchers::Controllers
+        extended_behaviour.describes.send :include, RenderOverrides, ::ActionController::TestCase::RaiseActionExceptions
+
+        extended_behaviour.before do
+          @request = ::ActionController::TestRequest.new
+          @response = ::ActionController::TestResponse.new
+          @controller = self.class.describes.new
+
+          @controller.request = @request
+          @controller.params = {}
+          @controller.send(:initialize_current_url)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/micronaut/rails/extensions/active_record.rb

@@ -0,0 +1,19 @@
+module Micronaut
+  module Rails
+    module Extensions
+      
+      module ActiveRecord
+        def errors_on(attribute)
+          self.valid?
+          [self.errors.on(attribute)].flatten.compact
+        end
+        alias :error_on :errors_on  
+      end
+      
+    end
+  end
+end
+
+if defined?(::ActiveRecord::Base)
+  ::ActiveRecord::Base.send(:include, ::Micronaut::Rails::Extensions::ActiveRecord)
+end

data/lib/micronaut/rails/helpers.rb

@@ -0,0 +1,99 @@
+module Micronaut
+  module Rails
+    module Helpers
+
+      class HelperController < ActionController::Base; end
+
+      module InstanceMethods
+
+        class HelperObject < ActionView::Base
+          def protect_against_forgery?
+            false
+          end
+
+          def session=(session)
+            @session = session
+          end
+
+          def request=(request)
+            @request = request
+          end
+
+          def flash=(flash)
+            @flash = flash
+          end
+
+          def params=(params)
+            @params = params
+          end
+
+          def controller=(controller)
+            @controller = controller
+          end
+
+          private
+          attr_reader :session, :request, :flash, :params, :controller
+        end
+
+        def helper
+          @helper_object ||= returning HelperObject.new do |helper_object|
+            if self.class.describes.class == Module
+              helper_object.extend self.class.describes
+            end
+          end
+        end
+
+        def params
+          request.parameters
+        end
+
+        def flash
+          response.flash
+        end
+
+        def session
+          response.session
+        end
+
+        def method_missing(sym, *args)
+          if helper.respond_to?(sym)
+            helper.send(sym, *args)
+          else
+            super
+          end
+        end
+
+      end
+
+      def self.extended(kls)
+        kls.send(:include, InstanceMethods)
+
+        kls.send(:attr_reader, :request, :response)
+
+        ActionView::Base.included_modules.reverse.each do |mod|
+          kls.send(:include, mod) if mod.parents.include?(ActionView::Helpers)
+        end
+
+        kls.before do
+          @controller = ::Micronaut::Rails::Helpers::HelperController.new
+          @request = ActionController::TestRequest.new
+          @response = ActionController::TestResponse.new
+          @response.session = @request.session
+          @controller.request = @request
+          @flash = ActionController::Flash::FlashHash.new
+          @response.session['flash'] = @flash
+
+          ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
+
+          helper.session = @response.session
+          helper.request = @request
+          helper.flash = @flash
+          helper.params = params
+          helper.controller = @controller
+        end
+
+      end
+
+    end
+  end
+end

data/lib/micronaut/rails/matchers/controllers/redirect_to.rb

@@ -0,0 +1,115 @@
+module Micronaut
+  module Rails
+    module Matchers
+      module Controllers
+
+        class RedirectTo  #:nodoc:
+
+          def initialize(request, expected)
+            @expected = expected
+            @request = request
+          end
+
+          def matches?(response)
+            @redirected = response.redirect?
+            @actual = response.redirect_url
+            return false unless @redirected
+            if @expected.instance_of? Hash
+              return false unless @actual =~ %r{^\w+://#{@request.host}}
+              return false unless actual_redirect_to_valid_route
+              return actual_hash == expected_hash
+            else
+              return @actual == expected_url
+            end
+          end
+
+          def actual_hash
+            hash_from_url @actual
+          end
+
+          def expected_hash
+            hash_from_url expected_url
+          end
+
+          def actual_redirect_to_valid_route
+            actual_hash
+          end
+
+          def hash_from_url(url)
+            query_hash(url).merge(path_hash(url)).with_indifferent_access
+          end
+
+          def path_hash(url)
+            path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
+            ActionController::Routing::Routes.recognize_path path
+          end
+
+          def query_hash(url)
+            query = url.split("?", 2)[1] || ""
+            QueryParameterParser.parse_query_parameters(query, @request)
+          end
+
+          def expected_url
+            case @expected
+            when Hash
+              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+            when :back
+              return @request.env['HTTP_REFERER']
+            when %r{^\w+://.*}
+              return @expected
+            else
+              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+            end
+          end
+
+          def failure_message
+            if @redirected
+              return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+            else
+              return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+            end
+          end
+
+          def negative_failure_message
+            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+          end
+
+          def description
+            "redirect to #{@actual.inspect}"
+          end
+
+          class QueryParameterParser
+            def self.parse_query_parameters(query, request)
+              if defined?(CGIMethods)
+                CGIMethods.parse_query_parameters(query)
+              else
+                request.class.parse_query_parameters(query)
+              end
+            end
+          end
+        end
+
+        # :call-seq:
+        #   response.should redirect_to(url)
+        #   response.should redirect_to(:action => action_name)
+        #   response.should redirect_to(:controller => controller_name, :action => action_name)
+        #   response.should_not redirect_to(url)
+        #   response.should_not redirect_to(:action => action_name)
+        #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
+        #
+        # Passes if the response is a redirect to the url, action or controller/action.
+        # Useful in controller specs (integration or isolation mode).
+        #
+        # == Examples
+        #
+        #   response.should redirect_to("path/to/action")
+        #   response.should redirect_to("http://test.host/path/to/action")
+        #   response.should redirect_to(:action => 'list')
+        def redirect_to(opts)
+          RedirectTo.new(request, opts)
+        end
+
+      end
+    end
+  end
+end

data/lib/micronaut/rails/matchers/controllers/render_template.rb

@@ -0,0 +1,116 @@
+module Micronaut
+  module Rails
+    module Matchers
+      module Controllers
+
+        class RenderTemplate #:nodoc:
+
+          def initialize(expected, controller)
+            @controller = controller
+            @expected = expected
+          end
+
+          def matches?(response_or_controller)
+            response = response_or_controller.respond_to?(:response) ?
+                       response_or_controller.response :
+                       response_or_controller
+   
+            if response.respond_to?(:rendered_file)
+              @actual = response.rendered_file
+            elsif response.respond_to?(:rendered)
+              case template = response.rendered[:template]
+              when nil
+                unless response.rendered[:partials].empty?
+                  @actual = path_and_file(response.rendered[:partials].keys.first).join("/_")
+                end
+              when ActionView::Template
+                @actual = template.path
+              when String
+                @actual = template
+              end
+            else
+              @actual = response.rendered_template.to_s
+            end
+            return false if @actual.blank?
+            given_controller_path, given_file = path_and_file(@actual)
+            expected_controller_path, expected_file = path_and_file(@expected)
+            given_controller_path == expected_controller_path && given_file.match(expected_file)
+          end
+
+          def failure_message
+            "expected #{@expected.inspect}, got #{@actual.inspect}"
+          end
+
+          def negative_failure_message
+            "expected not to render #{@expected.inspect}, but did"
+          end
+
+          def description
+            "render template #{@expected.inspect}"
+          end
+
+          private
+          def path_and_file(path)
+            parts = path.split('/')
+            file = parts.pop
+            controller = parts.empty? ? current_controller_path : parts.join('/')
+            return controller, file
+          end
+
+          def controller_path_from(path)
+            parts = path.split('/')
+            parts.pop
+            parts.join('/')
+          end
+
+          def current_controller_path
+            @controller.class.to_s.underscore.gsub(/_controller$/,'')
+          end
+
+        end
+
+        # :call-seq:
+        #   response.should render_template(template)
+        #   response.should_not render_template(template)
+        #
+        # For use in controller code examples (integration or isolation mode).
+        #
+        # Passes if the specified template (view file) is rendered by the
+        # response. This file can be any view file, including a partial. However
+        # if it is a partial it must be rendered directly i.e. you can't detect
+        # that a partial has been rendered as part of a view using
+        # render_template. For that you should use a message expectation
+        # (mock) instead:
+        #
+        #   controller.should_receive(:render).with(:partial => 'path/to/partial')
+        #
+        # <code>template</code> can include the controller path. It can also
+        # include an optional extension, which you only need to use when there
+        # is ambiguity.
+        #
+        # Note that partials must be spelled with the preceding underscore.
+        #
+        # == Examples
+        #
+        #   response.should render_template('list')
+        #   response.should render_template('same_controller/list')
+        #   response.should render_template('other_controller/list')
+        #
+        #   # with extensions
+        #   response.should render_template('list.rjs')
+        #   response.should render_template('list.haml')
+        #   response.should render_template('same_controller/list.rjs')
+        #   response.should render_template('other_controller/list.rjs')
+        #
+        #   # partials
+        #   response.should render_template('_a_partial')
+        #   response.should render_template('same_controller/_a_partial')
+        #   response.should render_template('other_controller/_a_partial')
+        def render_template(path)
+          RenderTemplate.new(path.to_s, @controller)
+        end
+
+      end
+    end
+  end
+end

data/lib/micronaut/rails/mocking/model_stubber.rb

@@ -0,0 +1,24 @@
+module Micronaut
+  module Rails
+    module Mocking
+
+      module ModelStubber
+
+        def connection
+          raise ::Micronaut::Rails::IllegalDataAccessException.new("stubbed/mocked models are not allowed to access the database")
+        end
+
+        def new_record?
+          id.nil?
+        end
+
+        def as_new_record
+          self.id = nil
+          self
+        end
+
+      end
+
+    end
+  end
+end

data/lib/micronaut/rails/mocking/with_mocha.rb

@@ -0,0 +1,72 @@
+module Micronaut
+  module Rails
+    module Mocking
+      module WithMocha
+
+        def stub_model(model_class, params = {})
+          params = params.dup
+          model = model_class.new
+          model.id = params.delete(:id) || next_id
+          model.extend ::Micronaut::Rails::Mocking::ModelStubber
+          
+          params.keys.each do |prop|
+            model[prop] = params.delete(prop) if model.has_attribute?(prop)
+          end
+          add_stubs(model, params)
+
+          yield model if block_given?
+          model
+        end
+
+        # Stubs methods on +object+ (if +object+ is a symbol or string a new mock
+        # with that name will be created). +stubs+ is a Hash of +method=>value+
+        def add_stubs(object, params) # :nodoc:
+          m = [String, Symbol].include?(object.class) ? mock(object.to_s) : object
+          params.each { |prop, value| m.stubs(prop).returns(value) }
+          m
+        end
+
+        def mock_model(model_class, params = {})
+          id = params[:id] || next_id
+          model = stub("#{model_class.name}_#{id}", {
+            :id => id,
+            :to_param => id.to_s,
+            :new_record? => false,
+            :errors => stub("errors", :count => 0)
+            }.update(params))
+
+            model.instance_eval <<-CODE
+            def as_new_record
+              self.stubs(:id).returns(nil)
+              self.stubs(:to_param).returns(nil)
+              self.stubs(:new_record?).returns(true)
+              self
+            end
+            def is_a?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def kind_of?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def instance_of?(other)
+              other == #{model_class}
+            end
+            def class
+              #{model_class}
+            end
+            CODE
+
+            yield model if block_given?
+            return model
+          end
+
+          private
+          @@model_id = 1000
+          def next_id
+            @@model_id += 1
+          end
+
+      end
+    end
+  end
+end

data/lib/micronaut/rails/mocking/with_rr.rb

@@ -0,0 +1,44 @@
+module Micronaut
+  module Rails
+    module Mocking
+      
+      module WithRR
+        # Creates a mock object instance for a +model_class+ with common
+        # methods stubbed out. Additional methods may be easily stubbed (via
+        # add_stubs) if +stubs+ is passed.
+        def mock_or_stub_model(model_class, mock_or_stub, options = {})
+          model = model_class.new
+          model.extend ::Micronaut::Rails::Mocking::ModelStubber
+          model_id = next_id
+
+          stub(errors_stub = Object.new).count.returns(0)
+          full_params = { :id => model_id, :new_record? => false, :errors => errors_stub }.update(options)
+          
+          full_params.each do |method, value|
+            eval "#{mock_or_stub}(model).#{method}.returns(value)", binding, __FILE__, __LINE__
+          end
+          
+          yield model if block_given?
+          model
+        end
+        
+        def mock_model(model_class, options = {})
+          mock_or_stub_model(model_class, 'mock', options)
+        end
+
+        def stub_model(model_class, options = {})
+          mock_or_stub_model(model_class, 'stub', options)
+        end
+        
+        private
+        
+        @@model_id = 1000
+        def next_id
+          @@model_id += 1
+        end
+        
+      end
+
+    end
+  end
+end

data/lib/micronaut/rails/transactional_database_support.rb

@@ -0,0 +1,39 @@
+module Micronaut
+  module Rails
+    module TransactionalDatabaseSupport
+
+      module InstanceMethods
+
+        def active_record_configured?
+          defined?(::ActiveRecord) && !::ActiveRecord::Base.configurations.blank?
+        end
+
+        def transactional_protection_start
+          return unless active_record_configured?
+
+          ::ActiveRecord::Base.connection.increment_open_transactions
+          ::ActiveRecord::Base.connection.begin_db_transaction
+        end
+
+        def transactional_protection_cleanup
+          return unless active_record_configured?
+
+          if ::ActiveRecord::Base.connection.open_transactions != 0
+            ::ActiveRecord::Base.connection.rollback_db_transaction
+            ::ActiveRecord::Base.connection.decrement_open_transactions
+          end
+
+          ::ActiveRecord::Base.clear_active_connections!
+        end
+
+      end
+
+      def self.extended(kls)
+        kls.send(:include, InstanceMethods)
+        kls.before { transactional_protection_start }
+        kls.after { transactional_protection_cleanup }
+      end
+
+    end
+  end
+end

data/lib/micronaut-rails.rb

@@ -0,0 +1,16 @@
+require 'micronaut/rails/configuration'
+require 'micronaut/rails/matchers/controllers/redirect_to'
+require 'micronaut/rails/matchers/controllers/render_template'
+require 'micronaut/rails/transactional_database_support'
+require 'micronaut/rails/controllers'
+require 'micronaut/rails/helpers'
+require 'micronaut/rails/extensions/active_record'
+require 'micronaut/rails/mocking/model_stubber'
+
+module Micronaut
+  module Rails
+    class IllegalDataAccessException < StandardError; end
+
+  end
+
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: micronaut-rails
+version: !ruby/object:Gem::Version 
+  version: 0.3.3
+platform: ruby
+authors: 
+- Chad Humphries
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: micronaut
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+description: An excellent replacement for the wheel on rails...
+email: chad@spicycode.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- LICENSE
+- README
+- RSPEC-LICENSE
+- Rakefile
+- VERSION.yml
+- examples/example_helper.rb
+- examples/lib/micronaut-rails_example.rb
+- examples/lib/micronaut/rails/configuration_example.rb
+- lib/micronaut-rails.rb
+- lib/micronaut/rails/configuration.rb
+- lib/micronaut/rails/controllers.rb
+- lib/micronaut/rails/extensions/active_record.rb
+- lib/micronaut/rails/helpers.rb
+- lib/micronaut/rails/matchers/controllers/redirect_to.rb
+- lib/micronaut/rails/matchers/controllers/render_template.rb
+- lib/micronaut/rails/mocking/model_stubber.rb
+- lib/micronaut/rails/mocking/with_mocha.rb
+- lib/micronaut/rails/mocking/with_rr.rb
+- lib/micronaut/rails/transactional_database_support.rb
+has_rdoc: true
+homepage: http://github.com/spicycode/micronaut-rails
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An excellent replacement for the wheel on rails...
+test_files: 
+- examples/example_helper.rb
+- examples/lib/micronaut/rails/configuration_example.rb
+- examples/lib/micronaut-rails_example.rb