mocked_fixtures 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 2008-09-03
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Adam Meehan
+
+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/Manifest.txt

@@ -0,0 +1,49 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+TODO.txt
+config/hoe.rb
+config/requirements.rb
+init.rb
+lib/mocked_fixtures.rb
+lib/mocked_fixtures/connection_adapters/sqlserver_adapter.rb
+lib/mocked_fixtures/mock_connection.rb
+lib/mocked_fixtures/mock_factory.rb
+lib/mocked_fixtures/mock_fixtures.rb
+lib/mocked_fixtures/mocks/flexmock.rb
+lib/mocked_fixtures/mocks/mocha.rb
+lib/mocked_fixtures/mocks/rspec.rb
+lib/mocked_fixtures/schema_parser.rb
+lib/mocked_fixtures/spec/configuration.rb
+lib/mocked_fixtures/testcase.rb
+lib/mocked_fixtures/version.rb
+script/console
+script/txt2html
+spec/connection_adapters/sqlserver_adapter_spec.rb
+spec/mock_connection_spec.rb
+spec/mock_factory_spec.rb
+spec/mock_fixtures_spec.rb
+spec/resources/companies.yml
+spec/resources/company.rb
+spec/resources/employee.rb
+spec/resources/employees.yml
+spec/resources/schema.rb
+spec/rspec-rails/MIT-LICENSE
+spec/rspec-rails/mocks.rb
+spec/rspec-rails/rails_example_group.rb
+spec/rspec-rails/rspec-rails.rb
+spec/schema_parser_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/testcase_spec.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/rspec.rake
+tasks/website.rake
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb

data/README.txt

@@ -0,0 +1,206 @@
+= mocked_fixtures
+
+* Project page: http://mockedfixtures.rubyforge.org/
+* Tickets:      http://adzap.lighthouseapp.com/projects/16416-mocked_fixtures
+* Contribute:   http://github.com/adzap/mocked_fixtures
+* Discuss:      http://groups.google.com/group/mocked_fixtures
+* Blog:         http://duckpunching.com/mocked_fixtures
+
+
+== DESCRIPTION:
+
+Yes, lets laugh at those silly fixtures with their silly yaml or comma 
+separated values! Ha ha ha! Don't they know how passe they are. All the cool kids
+are mocking and stubbing. Get with the times fixtures!
+
+Well actually fixtures still have their place. Especially with the foxy fixtures
+extensions added to Rails 2.0, they are now much easier to use. Problem is the 
+undesirable database overhead that comes with reloading your fixtures for every 
+test. Also, in controller and view tests, the database layer is unnecessary and 
+using mock objects for test isolation is often preferred.
+
+This poses another challenge of the often tedious creation those mocks to return
+the values you need for tests much like you did for your fixtures. But what if 
+you could reuse those fixtures as mocks where you don't need real ActiveRecord 
+objects. Well thats where mocked_fixtures comes in.
+
+This plugin helps by allowing you use your fixtures as disconnected mock objects
+which never touch the database when loaded or used. So you can now keep using 
+those thoughtfully crafted fixtures in your controller and view tests but minus
+the database overhead.
+
+A mocked fixture is a mock model object with all the model attributes stubbed
+out to return the values from the fixture if defined. If no fixture value was 
+defined then a nil is returned for the attribute method as you would expect.
+There are no attribute setters defined on the object as they are left for you 
+to do as necessary.
+
+The attributes for each model are read from the schema.rb file to avoid any 
+database access at all!
+
+== FEATURES/PROBLEMS:
+
+ * Reuse your fixtures as mock model objects without database overhead
+ * Adds feature to supported mocking libraries to quickly create empty mocked
+   model with all attributes methods stubbed out. Supported are Rspec, flexmock
+   and mocha.
+ * Same familiar style of using regular fixtures
+ * Works with popular testing frameworks such as Rspec (with rspec-rails),
+   shoulda and any testing library which uses good old test/unit as its base.
+
+What it doesn't do:
+
+ * Touch the database. This means that the fixtures are not inserted in the 
+   tables, thats not what the plugin is for.
+ * Create mock objects with the attribute setters. Only reader methods.
+
+
+Disclaimer:
+It is worth noting that the plugin is highly coupled to the Rails fixtures 
+implementation and so would likely break with future changes to the fixtures API.
+
+== SYNOPSIS:
+
+To get going you installed as a gem you need to require the plugin at the top
+of your test_helper or spec_helper file. If you installed as a Rails plugin then
+you can skip that step.
+
+If you are using test/unit then you need specify which mocking library you 
+are using in your test_helper like so:
+
+  class Test::Unit::TestCase
+    
+    # can be one of :flexmock or :mocha
+    self.mock_fixtures_with :flexmock  
+  end
+  
+If you are using Rspec you need to set it in the configure block:
+
+  Spec::Runner.configure do |config|
+    
+    # can be one of :rspec, :flexmock or :mocha
+    config.mock_fixtures_with :rspec
+  end
+
+If you are using something other than the supported libraries then you get an 
+error alerting the plugin can't be used with that library. You can then write you own
+interface to the plugin for that library if you want. See the files in 
+lib/mocked_fixtures/mocks and the spec for mock fixture objects in spec/mock_factory_spec.rb.
+  
+On to the good stuff. Now if you have a Company model and fixture for the model
+like this
+
+  megacorp:
+    name: Mega Corporation
+    moto: Do Evil
+
+Just like normal fixtures you declare which ones you want to use in your test
+or spec at the top
+
+  class MyTest < Test::Unit:TestCase
+	  mock_fixtures :companies
+
+	  def setup
+		  @company = mock_companies(:megacorp)		  
+	  end
+	  
+	  def test_does_something
+	    assert_equal @company.moto, 'Do Evil'
+	  end
+  end
+  
+All the attributes will be stubbed to return the values from the fixture. The 
+fixture is generated using the internal Rails fixtures class, so any of fixture
+tricks, such as association labels and automatically generated ids, will work.
+
+If you want more than one fixture, then like normal fixtures you list the 
+fixture keys to get back an array of the objects.
+
+  @companies = mock_companies(:megacorp, :bigstuff)
+
+
+To quickly grab all of the fixtures you call use the :all option
+
+  @companies = mock_companies(:all)
+
+
+Like regular fixtures you can also declare global mock fixtures to pre-load for all
+your tests. Because the mock fixtures don't access the database it doesn't slow down
+the running of tests like global fixtures can.
+
+To setup global mock fixtures, in your test_helper put:
+
+  class Test::Unit::TestCase
+    
+    self.global_mock_fixtures = :companies
+  end
+  
+If you are using Rspec you need to set it in the configure block:
+
+  Spec::Runner.configure do |config|
+    
+    config.global_mock_fixtures = :companies
+  end
+
+You can also set the global to :all and all fixtures will be loaded as mocks. This
+can add some test startup time if you have a lot of fixtures but shouldn't slow 
+down your tests when running at all. Might use a bit of memory though.
+
+Thats all for now, so mock on!
+
+
+NOTE:
+If you use MS SQL Server then you need to apply a fix for this adapter to 
+correctly dump primary keys when not named 'id'. Just drop this line in an 
+initializer file
+
+  require 'mocked_fixtures/connection_adapters/sqlserver_adapter'
+
+You then need to do a dump. Um, keep your pants on, I mean a database dump with
+  
+  rake db:schema:dump
+
+Now the schema.rb file should be complete.
+
+== REQUIREMENTS:
+
+Rails 2.x
+
+At least one of:
+
+* Spec::Mock (included with Rspec)
+* flexmock
+* mocha
+
+== INSTALL:
+
+* sudo gem install mocked_fixtures
+
+Or as a plugin
+
+* ./script/plugin install git://github.com/adzap/mocked_fixtures.git
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Adam Meehan
+
+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,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/TODO.txt

@@ -0,0 +1,5 @@
+Todo
+====
+- Blocks for mock fixture accessor to set custom values
+- Stub out associations methods and return mocked association fixtures
+- Cache schema

data/config/hoe.rb

@@ -0,0 +1,73 @@
+require 'mocked_fixtures/version'
+
+AUTHOR = 'Adam Meehan'  # can also be an array of Authors
+EMAIL = "adam.meehan@gmail.com"
+DESCRIPTION = "Use Rails fixtures as mocked model objects without database access"
+GEM_NAME = 'mocked_fixtures' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'mockedfixtures' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+#  ['activesupport', '>= 1.3.1']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "adzap"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = MockedFixtures::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'mocked_fixtures documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/init.rb

@@ -0,0 +1,2 @@
+require 'mocked_fixtures' if ENV['RAILS_ENV'] == 'test'
+

data/lib/mocked_fixtures/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1,25 @@
+# This adds the method to find the primary key for the schema dumper so that
+# the schema will correctly define the primary key. Need to get this into the
+# real adapter obviously, though the project seems almost dead.
+module MockedFixtures
+  module ConnectionAdapters
+    module SQLServerAdapter
+      
+      # Returns a table's primary key and belonging sequence (not applicable to SQL server).
+      def pk_and_sequence_for(table_name)
+        @connection["AutoCommit"] = false
+        keys = []
+        execute("EXEC sp_helpindex '#{table_name}'") do |handle|
+          if handle.column_info.any?
+            pk_index = handle.detect {|index| index[1] =~ /primary key/ }
+            keys << pk_index[2] if pk_index
+          end
+        end
+        keys.length == 1 ? [keys.first, nil] : nil
+      ensure
+        @connection["AutoCommit"] = true
+      end
+      
+    end
+  end
+end

data/lib/mocked_fixtures/mock_connection.rb

@@ -0,0 +1,61 @@
+module MockedFixtures
+  class MockConnection
+    attr_accessor :schema, :loaded_fixtures, :current_fixture_label
+    
+    # mock column class which is used in Fixtures class insert_fixtures method
+    class Column
+      attr_accessor :name, :type
+      def initialize(name, type)
+        @name, @type = name, type
+      end
+    end
+    
+    def initialize
+      @schema  = @@schema ||= MockedFixtures::SchemaParser.load_schema
+      @columns = {}
+      @loaded_fixtures = {}
+    end
+     
+    # stores full fixture after association values loaded and type casting
+    def insert_fixture(fixture, table_name)
+      loaded_fixtures[table_name] ||= {}
+      loaded_fixtures[table_name][@current_fixture_label] = type_cast_fixture(fixture, table_name)
+    end
+    
+    def type_cast_fixture(fixture, table_name)
+      fixture.to_hash.inject({}) do |new_hash, row|
+        begin
+          type = @schema[table_name.to_s][:columns].assoc(row[0])[1]
+          new_hash[row[0].to_sym] = type_cast_value(type, row[1])
+          new_hash
+        rescue
+          raise "Mock fixture key '#{row[0]}' not found in schema '#{table_name}'"
+        end
+      end
+    end
+    
+    # Modified from ActiveRecord::Column class.
+    def type_cast_value(type, value)
+      return nil if value.nil?
+      column = ActiveRecord::ConnectionAdapters::Column
+      case type.to_sym
+        when :string    then value
+        when :text      then value
+        when :integer   then value.to_i rescue value ? 1 : 0
+        when :float     then value.to_f
+        when :decimal   then column.value_to_decimal(value)
+        when :datetime  then column.string_to_time(value)
+        when :timestamp then column.string_to_time(value)
+        when :time      then column.string_to_dummy_time(value)
+        when :date      then column.string_to_date(value)
+        when :binary    then column.binary_to_string(value)
+        when :boolean   then column.value_to_boolean(value)
+        else value
+      end
+    end    
+    
+    def columns(table_name)
+      @columns[table_name] ||= @schema[table_name.to_s][:columns].collect {|c| Column.new(c[0], c[1]) }
+    end
+  end
+end

data/lib/mocked_fixtures/mock_factory.rb

@@ -0,0 +1,12 @@
+module MockedFixtures
+  class MockFactory
+    class << self
+      
+      # Create mock object from fixture
+      def create_mock(type, model_class, fixture, testcase)
+        testcase.send("mock_model_with_#{type}", model_class, { :all_attributes => true, :add_errors => true }.merge(fixture) )
+      end
+
+    end
+  end
+end

data/lib/mocked_fixtures/mock_fixtures.rb

@@ -0,0 +1,58 @@
+module MockedFixtures
+  class MockFixtures < Fixtures
+    attr_reader :connection
+    
+    # Gets loaded fixture files for each table and type casts the values and
+    # returns the array of MockFixtures instances. The insert_fixtures method
+    # is in the superclass and does all the foxy fixtures work.
+    def self.create_fixtures(fixtures_directory, table_names, class_names = {})
+      table_names = Array(table_names).flatten.map { |n| n.to_s }
+      fixtures = table_names.map do |table_name|
+        fixture = MockedFixtures::MockFixtures.new(File.split(table_name.to_s).last, class_names[table_name.to_sym], File.join(fixtures_directory, table_name.to_s))
+        fixture.insert_fixtures
+        fixture.each {|label, f| fixture[label] = fixture.connection.loaded_fixtures[fixture.table_name][label] }
+      end
+    end
+    
+    def initialize(table_name, class_name, fixture_path, file_filter = DEFAULT_FILTER_RE)
+      @table_name, @fixture_path, @file_filter = table_name, fixture_path, file_filter
+      @class_name = class_name || (ActiveRecord::Base.pluralize_table_names ? @table_name.singularize.camelize : @table_name.camelize)
+      @table_name = ActiveRecord::Base.table_name_prefix + @table_name + ActiveRecord::Base.table_name_suffix
+      @table_name = class_name.table_name if class_name.respond_to?(:table_name)
+      @connection = MockedFixtures::MockConnection.new
+      read_fixture_files
+    end
+    
+    # overrides method to prevent database hit 
+    def has_primary_key_column?
+      @has_primary_key_column ||= !primary_key_name.nil?
+    end  
+    
+    # overrides method to prevent database hit and uses dummy connection
+    # which gets primary key from schema.rb
+    def primary_key_name
+      @primary_key_name ||= @connection.schema[@table_name.to_s][:primary_key]
+    end  
+    
+    def column_names
+      @column_name ||= @connection.columns(@table_name).collect(&:name)
+    end
+    
+    def delete_existing_fixtures
+      # override to do nothing (NOP) as we are not using the database, so nothing needs deleting
+    end  
+    
+    # The each method is aliased to allow the fixture label to be captured during 
+    # iteration in superclass methods, particularly the insert_fixtures method. 
+    # The label is required for the insert_fixture connection method to be able 
+    # store the final fixture hash and reference it by its label for later.
+    alias :original_each :each  
+    def each
+      original_each do |label, fixture|
+        connection.current_fixture_label = label
+        yield label, fixture
+        connection.current_fixture_label = nil
+      end    
+    end
+  end
+end

data/lib/mocked_fixtures/mocks/flexmock.rb

@@ -0,0 +1,35 @@
+require 'flexmock/test_unit'
+module MockedFixtures
+  module Mocks
+    module Flexmock
+    
+      def mock_model_with_flexmock(model_class, options_and_stubs={})
+        all_attributes = options_and_stubs.delete(:all_attributes)
+        add_errors     = options_and_stubs.delete(:add_errors)
+
+        if all_attributes
+          schema = MockedFixtures::SchemaParser.load_schema
+          table  = model_class.table_name
+          schema[table][:columns].each { |column| options_and_stubs[column[0].to_sym] = nil unless options_and_stubs.has_key?(column[0].to_sym) }
+        end
+        if add_errors
+          errors = flexmock(Array.new, :count => 0, :on => nil)
+          options_and_stubs.reverse_merge!(:errors => errors)
+        end
+        mock_helper = FlexMock::MockContainerHelper.new
+        id = options_and_stubs[:id] || mock_helper.next_id
+        options_and_stubs.reverse_merge!({        
+          :id => id,
+          :to_param => id.to_s,
+        })
+        
+        mock = flexmock("#{model_class}_#{id}", options_and_stubs)
+        mock_helper.add_model_methods(mock, model_class, id)
+        mock
+      end
+      
+    end
+  end
+end
+
+Test::Unit::TestCase.send(:include, MockedFixtures::Mocks::Flexmock)

data/lib/mocked_fixtures/mocks/mocha.rb

@@ -0,0 +1,47 @@
+require 'mocha'
+module MockedFixtures
+  module Mocks
+    module Mocha
+    
+      def mock_model_with_mocha(model_class, options_and_stubs={})
+        all_attributes = options_and_stubs.delete(:all_attributes)
+        add_errors     = options_and_stubs.delete(:add_errors)
+        if all_attributes
+          schema = MockedFixtures::SchemaParser.load_schema
+          table  = model_class.table_name
+          schema[table][:columns].each { |column| options_and_stubs[column[0].to_sym] = nil unless options_and_stubs.has_key?(column[0].to_sym) }
+        end
+        if add_errors
+          errors = []
+          errors.stubs(:count).returns(0)
+          errors.stubs(:on).returns(nil)
+          options_and_stubs.reverse_merge!(:errors => errors)
+        end
+        options_and_stubs.reverse_merge!(
+          :id => options_and_stubs[:id],
+          :to_param => options_and_stubs[:id].to_s,
+          :new_record? => false
+        )
+        obj = stub("#{model_class}_#{options_and_stubs[:id]}", options_and_stubs)
+        obj.instance_eval <<-CODE
+          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
+        obj
+      end
+
+    end
+  end
+end
+
+Test::Unit::TestCase.send(:include, MockedFixtures::Mocks::Mocha)

data/lib/mocked_fixtures/mocks/rspec.rb

@@ -0,0 +1,40 @@
+# rspec-rails mock_model extensions to add the stubs
+# for all attributes and the errors method
+module MockedFixtures
+  module Mocks
+    module Rspec
+    
+      def self.included(base)
+        base.class_eval do
+          include InstanceMethods
+          alias_method_chain :mock_model, :attributes
+          alias_method :mock_model_with_rspec, :mock_model_with_attributes
+        end
+      end
+      
+      module InstanceMethods
+        def mock_model_with_attributes(model_class, options_and_stubs = {})
+          if options_and_stubs.delete(:all_attributes)
+            schema = MockedFixtures::SchemaParser.load_schema
+            table  = model_class.table_name
+            schema[table][:columns].each { |column| 
+              unless options_and_stubs.has_key?(column[0].to_sym) || column[0] == model_class.primary_key
+                options_and_stubs[column[0].to_sym] = nil  
+              end
+            }
+          end
+          if options_and_stubs.delete(:add_errors)
+            errors = []
+            errors.stub!(:count).and_return(0)
+            errors.stub!(:on).and_return(nil)
+            options_and_stubs.reverse_merge!(:errors => errors)
+          end
+          mock_model_without_attributes(model_class, options_and_stubs)
+        end
+      end
+      
+    end
+  end
+end
+
+Spec::Rails::Example::RailsExampleGroup.send(:include, MockedFixtures::Mocks::Rspec)