mocked_fixtures 0.1.0

data/lib/mocked_fixtures/schema_parser.rb

@@ -0,0 +1,30 @@
+module MockedFixtures
+  class SchemaParser
+    cattr_accessor :schema_path
+    
+    # Parses schema.rb file and pulls out all the columns names and types into
+    # an array, with each row being an array of the column name and type
+    # respectively.
+    def self.load_schema
+      schema = {}
+      table_name = ""
+      open(schema_path, 'r').each do |line|
+        if /create_table "(\w+)".*? do \|t\|/ =~ line
+          table_name = $1
+          schema[table_name] = {:columns => [], :primary_key => nil}
+          schema[table_name][:columns] 
+          if line =~ /:primary_key => "(.*?)"/
+            schema[table_name][:columns] << [$1, 'integer']
+            schema[table_name][:primary_key] = $1
+          elsif line !~ /:id => false/
+            schema[table_name][:columns] << ['id', 'integer']
+            schema[table_name][:primary_key] = 'id'
+          end
+        elsif /t\.(\w+)\s+"(\w+)"/ =~ line
+          schema[table_name][:columns] << [$2, $1]
+        end
+      end
+      schema
+    end
+  end
+end

data/lib/mocked_fixtures/spec/configuration.rb

@@ -0,0 +1,19 @@
+module MockedFixtures
+  module Spec
+    module Configuration
+      def global_mock_fixtures
+        Test::Unit::TestCase.mock_fixture_table_names
+      end
+      
+      def global_mock_fixtures=(fixtures)
+        Test::Unit::TestCase.mock_fixtures(*fixtures)
+      end
+      
+      def mock_fixtures_with(mock_framework)
+        Test::Unit::TestCase.mock_fixtures_with mock_framework
+      end
+    end
+  end
+end
+
+Spec::Example::Configuration.send(:include, MockedFixtures::Spec::Configuration)

data/lib/mocked_fixtures/testcase.rb

@@ -0,0 +1,122 @@
+# Many of these methods are renamed and modified from the Rails Fixtures
+# TestCase class extensions.
+module Test
+  module Unit
+    class TestCase
+      
+      superclass_delegating_accessor :mock_fixture_table_names      
+      superclass_delegating_accessor :loaded_mock_fixtures
+      superclass_delegating_accessor :mock_fixtures_loaded
+      superclass_delegating_accessor :global_mock_fixtures
+      superclass_delegating_accessor :mocked_fixtures_mock_framework
+
+      self.mock_fixture_table_names = []
+      self.loaded_mock_fixtures = {}
+      self.mock_fixtures_loaded = false
+     
+      def self.global_mock_fixtures=(*table_names)
+        table_names = self.all_fixture_table_names if table_names.first == :all
+        self.mock_fixtures table_names.flatten.map { |n| n.to_s }
+      end
+      
+      def self.mock_fixtures_with(mock_framework)
+        require "mocked_fixtures/mocks/#{mock_framework}"
+        self.mocked_fixtures_mock_framework = mock_framework
+        unless mock_framework == :rspec
+          self.send(:alias_method, :mock_model, "mock_model_with_#{mock_framework}".to_sym) 
+        end
+      end
+      
+      def self.mock_fixtures(*table_names)
+        table_names = self.all_fixture_table_names if table_names.first == :all
+
+        table_names = table_names.flatten.map { |n| n.to_s }
+
+        self.mock_fixture_table_names |= table_names
+        
+        require_fixture_classes(table_names)
+        setup_mock_fixture_accessors(table_names)
+      end
+      
+      def self.all_fixture_table_names
+        table_names = Dir["#{fixture_path}/*.yml"] + Dir["#{fixture_path}/*.csv"]
+        table_names.map { |f| File.basename(f).split('.')[0..-2].join('.') }
+      end
+      
+      # Adds test case setup method to run before each test to load fixture
+      # files and setup mock fixture accessors for test class. This runs before
+      # each test as the test class is recreated each time.
+      def self.method_added_with_mock_fixtures(method)
+        return if @__disable_method_added__
+        @__disable_method_added__ = true
+
+        if method.to_s == 'setup'
+          unless method_defined?(:setup_without_mock_fixtures)
+            alias_method :setup_without_mock_fixtures, :setup
+            define_method(:mock_fixture_setup) do
+              setup_with_mock_fixtures
+              setup_without_mock_fixtures
+            end
+          end
+          alias_method :setup, :mock_fixture_setup
+        end
+        
+        @__disable_method_added__ = false
+        method_added_without_mock_fixtures(method)
+      end
+     
+      class << self
+        alias_method_chain :method_added, :mock_fixtures        
+      end
+     
+      # This creates the fixture accessors and retrieves the fixture and creates
+      # mock object from it. Mock fixture is then cached.
+      def self.setup_mock_fixture_accessors(table_names = nil)
+        (table_names || mock_fixture_table_names).each do |table_name|
+          table_name = table_name.to_s.tr('.', '_')
+    
+          define_method('mock_' + table_name) do |*fixtures|
+            @mock_fixture_cache ||= {}
+            @mock_fixture_cache[table_name] ||= {}
+            if fixtures.first == :all
+              fixtures = self.class.loaded_mock_fixtures[table_name].keys
+            end           
+            
+            mock_type = self.class.mocked_fixtures_mock_framework
+            
+            instances = fixtures.map do |fixture_name|
+              if fixture = self.class.loaded_mock_fixtures[table_name][fixture_name.to_s]
+                unless model_class = self.class.loaded_mock_fixtures[table_name].send(:model_class)
+                  raise StandardError, "No model class found for table name '#{table_name}'. Specify it explicitly 'set_fixture_class :table_name => 'ClassName'."
+                end
+                
+                @mock_fixture_cache[table_name][fixture_name] ||= MockedFixtures::MockFactory.create_mock(mock_type, model_class, fixture, self)
+              else
+                raise StandardError, "No fixture named '#{fixture_name}' was found for table '#{table_name}'"
+              end
+            end
+
+            instances.size == 1 ? instances.first : instances
+          end
+          
+        end
+      end
+      
+      def setup_with_mock_fixtures
+        fixtures_to_load = self.class.mock_fixture_table_names - self.class.loaded_mock_fixtures.keys
+        return if fixtures_to_load.empty?
+        load_mock_fixtures(fixtures_to_load)
+      end
+      alias_method :setup, :setup_with_mock_fixtures
+
+      # Loads fixtures to be mocked and cache them in class variable
+      def load_mock_fixtures(fixtures_to_load)
+        fixtures = MockedFixtures::MockFixtures.create_fixtures(fixture_path, fixtures_to_load, fixture_class_names)
+        unless fixtures.nil?
+          fixtures.each { |f| self.class.loaded_mock_fixtures[f.table_name] = f }
+        end
+      end
+    
+    end
+  end
+end

data/lib/mocked_fixtures/version.rb

@@ -0,0 +1,9 @@
+module MockedFixtures
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/mocked_fixtures.rb

@@ -0,0 +1,15 @@
+require 'active_record/fixtures'
+
+require 'mocked_fixtures/testcase'
+require 'mocked_fixtures/schema_parser'
+require 'mocked_fixtures/mock_fixtures'
+require 'mocked_fixtures/mock_factory'
+require 'mocked_fixtures/mock_connection'
+require 'mocked_fixtures/version'
+
+if defined?(Spec::Example)
+  require 'mocked_fixtures/spec/configuration'
+  Test::Unit::TestCase.mocked_fixtures_mock_framework = :rspec
+end
+
+MockedFixtures::SchemaParser.schema_path = RAILS_ROOT + '/db/schema.rb'

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/mocked_fixtures.rb'}"
+puts "Loading mocked_fixtures gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/txt2html

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+GEM_NAME = 'mocked_fixtures' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'mocked_fixtures'
+
+require 'rubygems'
+begin
+  require 'newgem'
+  require 'rubyforge'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + "/../lib/#{GEM_NAME}/version.rb"
+
+version  = MockedFixtures::VERSION::STRING
+download = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+def rubyforge_project_id
+  RubyForge.new.autoconfig["group_ids"][RUBYFORGE_PROJECT]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/spec/connection_adapters/sqlserver_adapter_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+begin
+  gem 'activerecord-sqlserver-adapter'
+  require 'mocked_fixtures/connection_adapters/sqlserver_adapter'
+rescue LoadError
+  puts 'Testing ActiveRecord SQLServer Adapter skipped'
+end
+
+if defined?(MockedFixtures::ConnectionAdapters::SQLServerAdapter)
+  conn = {
+    :adapter  => 'sqlserver',
+    :host     => 'localhost',
+    :mode     => 'odbc', 
+    :dsn      => 'activerecord_unittest',
+    :database => 'activerecord_unittest',
+    :username => 'rails',
+    :password => nil
+  }
+
+  ActiveRecord::Base.establish_connection(conn)
+
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.send(:include, MockedFixtures::ConnectionAdapters::SQLServerAdapter)
+
+  require 'resources/schema.rb'
+
+  describe MockedFixtures::ConnectionAdapters::SQLServerAdapter do
+    
+    before do
+      ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active?
+    end
+    
+    it "should allow SchemDumper to dump primary key option for pk other than 'id'" do
+      schema = StringIO.new
+      dumper = ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, schema)
+      schema.rewind
+      schema.read.should match(/create_table "companies", :primary_key => "cid"/)
+    end
+    
+    it "should return primary key and sequence" do
+      ActiveRecord::Base.connection.pk_and_sequence_for('companies').should == ['cid', nil]
+    end
+  end
+end

data/spec/mock_connection_spec.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe MockedFixtures::MockConnection do
+
+
+end

data/spec/mock_factory_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe MockedFixtures::MockFactory do
+  before do
+    @fixture = {:id => 6, :cid => 6, :name => 'Hot Mocks'}
+  end
+
+  [:rspec, :flexmock, :mocha].each do |type|
+    require "mocked_fixtures/mocks/#{type}"
+    
+    describe " with #{type.to_s.titleize} integration" do
+      attr_accessor :a_mock
+      
+      before do
+        @a_mock = MockedFixtures::MockFactory.create_mock(type, Company, @fixture, self)
+      end
+      
+      it "should create mock fixture object" do        
+        a_mock.should_not be_nil
+      end
+      
+      it "should create mock object with all attributes" do        
+        a_mock.should respond_to(:cid, :name, :address, :created_at, :updated_at)
+      end
+      
+      it "should create mock object with attributes value from fixture" do
+        a_mock.cid.should == 6
+        a_mock.name.should == 'Hot Mocks'
+      end
+      
+      it "should create mock with id stubbed to fixture" do
+        a_mock.id.should == 6
+      end
+      
+      it "should create mock with new_record? stubbed to false" do
+        a_mock.new_record?.should be_false
+      end
+      
+      it "should create mock with to_param stubbed to id as string" do
+        a_mock.to_param.should == "6"
+      end
+      
+      it "should create mock with errors stubbed" do
+        a_mock.should respond_to(:errors)
+      end
+      
+      describe "mock object errors stub" do
+        it "should return 0 for count" do
+          a_mock.errors.count.should == 0
+        end
+        
+        it "should return nil for on(:attribute)" do
+          a_mock.errors.on(:name).should be_nil
+        end
+      end
+    end  
+  end  
+
+end

data/spec/mock_fixtures_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe MockedFixtures::MockFixtures do
+  
+  before(:all) do
+    # just making sure we don't hit the database at all
+    ActiveRecord::Base.connection.disconnect! rescue nil
+  end
+  
+  before(:each) do
+    @fixture_path = Test::Unit::TestCase.fixture_path
+  end  
+
+  it "should return primary key for fixture table" do
+    fixtures = MockedFixtures::MockFixtures.create_fixtures(@fixture_path, [:companies])
+    fixtures[0].primary_key_name.should == 'cid'
+  end  
+  
+  it "should create fixtures" do
+    fixtures = MockedFixtures::MockFixtures.create_fixtures(@fixture_path, [:companies])
+    fixtures.should have(1).instance_of(Fixture)
+    fixtures.first['mega_corp'][:name].should == 'Mega Corporation'
+  end
+
+  it "should create fixtures with association values inserted" do
+    fixtures = MockedFixtures::MockFixtures.create_fixtures(@fixture_path, [:employees])
+    fixtures.first['adam'][:company_id].should == Fixtures.identify('mega_corp')
+  end
+  
+end

data/spec/resources/companies.yml

@@ -0,0 +1,3 @@
+mega_corp:
+  cid: 1
+  name: Mega Corporation

data/spec/resources/company.rb

@@ -0,0 +1,5 @@
+class Company < ActiveRecord::Base
+  set_primary_key 'cid'
+  
+  has_many :employees  
+end

data/spec/resources/employee.rb

@@ -0,0 +1,3 @@
+class Employee < ActiveRecord::Base
+  belongs_to :company  
+end

data/spec/resources/employees.yml

@@ -0,0 +1,8 @@
+adam:
+  company: mega_corp
+  first_name: Adam
+  last_name: Meehan
+jane:
+  company: mega_corp
+  first_name: Jane
+  last_name: Doe

data/spec/resources/schema.rb

@@ -0,0 +1,18 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "companies", :primary_key => "cid", :force => true do |t|    
+    t.string   "name",       :null => false,  :unique => true
+    t.string   "address"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "employees", :force => true do |t|
+    t.integer  "company_id", :null => false
+    t.string   "first_name", :null => false,  :limit => 25
+    t.string   "last_name",  :null => false,  :limit => 25
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+  
+end

data/spec/rspec-rails/MIT-LICENSE

@@ -0,0 +1,31 @@
+====================================================================
+== RSpec
+Copyright (c) 2005-2007 The RSpec Development Team
+====================================================================
+== ARTS
+Copyright (c) 2006 Kevin Clark, Jake Howerton
+====================================================================
+== ZenTest
+Copyright (c) 2001-2006 Ryan Davis, Eric Hodel, Zen Spider Software
+====================================================================
+== AssertSelect
+Copyright (c) 2006 Assaf Arkin
+====================================================================
+
+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/spec/rspec-rails/mocks.rb

@@ -0,0 +1,115 @@
+module Spec
+  module Rails
+
+    class IllegalDataAccessException < StandardError; end
+
+    module Mocks
+      
+      # 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_model(model_class, options_and_stubs = {})
+        id = options_and_stubs[:id] || next_id
+        options_and_stubs.reverse_merge!({
+          :id => id,
+          :to_param => id.to_s,
+          :new_record? => false,
+          :errors => stub("errors", :count => 0)
+        })
+        m = mock("#{model_class.name}_#{options_and_stubs[:id]}", options_and_stubs)
+        m.send(:__mock_proxy).instance_eval <<-CODE
+          def @target.is_a?(other)
+            #{model_class}.ancestors.include?(other)
+          end
+          def @target.kind_of?(other)
+            #{model_class}.ancestors.include?(other)
+          end
+          def @target.instance_of?(other)
+            other == #{model_class}
+          end
+          def @target.class
+            #{model_class}
+          end
+        CODE
+        yield m if block_given?
+        m
+      end
+
+      # :call-seq:
+      #   stub_model(Model)
+      #   stub_model(Model).as_new_record
+      #   stub_model(Model, hash_of_stubs)
+      #
+      # Creates an instance of +Model+ that is prohibited from accessing the
+      # database. For each key in +hash_of_stubs+, if the model has a
+      # matching attribute (determined by asking it, which it answers based
+      # on schema.rb) are simply assigned the submitted values. If the model
+      # does not have a matching attribute, the key/value pair is assigned
+      # as a stub return value using RSpec's mocking/stubbing framework.
+      #
+      # new_record? is overridden to return the result of id.nil? This means
+      # that by default new_record? will return false. If  you want the
+      # object to behave as a new record, sending it +as_new_record+ will
+      # set the id to nil. You can also explicitly set :id => nil, in which
+      # case new_record? will return true, but using +as_new_record+ makes
+      # the example a bit more descriptive.
+      #
+      # While you can use stub_model in any example (model, view,
+      # controller, helper), it is especially useful in view examples,
+      # which are inherently more state-based than interaction-based.
+      #
+      # == Examples
+      #
+      #   stub_model(Person)
+      #   stub_model(Person).as_new_record
+      #   stub_model(Person, :id => 37)
+      #   stub_model(Person) do |person|
+      #     model.first_name = "David"
+      #   end
+      def stub_model(model_class, stubs = {})
+        stubs = {:id => next_id}.merge(stubs)
+        returning model_class.new do |model|
+          model.id = stubs.delete(:id)
+          (class << model; self; end).class_eval do
+            def connection
+              raise Spec::Rails::IllegalDataAccessException.new("stubbed 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
+          stubs.each do |k,v|
+            if model.has_attribute?(k)
+              model[k] = stubs.delete(k)
+            end
+          end
+          add_stubs(model, stubs)
+          yield model if block_given?
+        end
+      end
+      
+      #--
+      # TODO - Shouldn't this just be an extension of stub! ??
+      # - object.stub!(:method => return_value, :method2 => return_value2, :etc => etc)
+      #++
+      # 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 <tt>method=>value</tt>
+      def add_stubs(object, stubs = {}) #:nodoc:
+        m = [String, Symbol].index(object.class) ? mock(object.to_s) : object
+        stubs.each {|k,v| m.stub!(k).and_return(v)}
+        m
+      end
+
+      private
+        @@model_id = 1000
+        def next_id
+          @@model_id += 1
+        end
+
+    end
+  end
+end

data/spec/rspec-rails/rails_example_group.rb

@@ -0,0 +1,27 @@
+require 'spec/interop/test'
+
+ActionView::Base.cache_template_extensions = false
+
+module Spec
+  module Rails
+
+    module Example
+      class RailsExampleGroup < Test::Unit::TestCase
+        
+        # Rails >= r8570 uses setup/teardown_fixtures explicitly
+        before(:each) do
+          setup_fixtures if self.respond_to?(:setup_fixtures)
+        end
+        after(:each) do
+          teardown_fixtures if self.respond_to?(:teardown_fixtures)
+        end
+        
+        include Spec::Rails::Matchers
+        include Spec::Rails::Mocks
+        
+        Spec::Example::ExampleGroupFactory.default(self)
+        
+      end
+    end
+  end
+end

data/spec/rspec-rails/rspec-rails.rb

@@ -0,0 +1,15 @@
+module Spec
+  module Rails
+    module Matchers; end
+  end
+end
+
+module ActionView
+  class Base
+    def self.cache_template_extensions=(arg)
+    end
+  end
+end
+
+require 'rspec-rails/mocks'
+require 'rspec-rails/rails_example_group'