active_mocker 0.1.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a57ab19178452d40493f706844efc26d8381d0b1
-  data.tar.gz: 360196e9eccecb12fef06ca111e002bfdd1cb5a7
+  metadata.gz: 088dc755f7c69b012b24059d5dde2327b51c2ac5
+  data.tar.gz: 056cc0f1af0680b37db122ba36a5c6406550d597
 SHA512:
-  metadata.gz: ff22e9d0e5bef978329f85385e6865dcce9803a10a703de790ce2682f7715efda58b017007a05b4ab4e0d3ac7d24a2fb9c6255d078d9a9e974ca04f0f3029f16
-  data.tar.gz: 6b94c9d8b9025619a45f8991cb7592a5c43dd44258822405726cbfcdffc4730eaddbd94687e02842cb5ed219c7f08d8136ad501dd771820c30748f6aa5e61c7e
+  metadata.gz: 16e53701559ce5c97bee5cdef1a2d438bdc4b2dfe0e37fd8008046ec34d5527a224f651ef953adf098dc492d744b6467794fc2695dfc4f0c9599e41828567578
+  data.tar.gz: e2c885e9ab6358deb98b6ae3f25ffbec50e7b189c2b05dfda687e5c97e657d4655fe45cd4209fcec83120a67e9994905e3b68c7279098afdcd97501983c49839

data/README.md

@@ -1,6 +1,8 @@
 # ActiveMocker
 [![Build Status](https://travis-ci.org/zeisler/active_mocker.png?branch=master)](https://travis-ci.org/zeisler/active_mocker)
-Create mocks from active record models without loading rails or running a datebase
+
+Create mocks from active record models without loading rails or running a database.
+
 
 ## Installation
 
@@ -18,7 +20,119 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+
+    #db/schema.rb
+
+    ActiveRecord::Schema.define(version: 20140327205359) do
+
+      create_table "people", force: true do |t|
+        t.integer  "account_id"
+        t.string   "first_name",        limit: 128
+        t.string   "last_name",         limit: 128
+        t.string   "address",           limit: 200
+        t.string   "city",              limit: 100
+      end
+
+    end
+
+    #app/models/person.rb
+
+    class Person < ActiveRecord::Base
+      belongs_to :account
+
+      def bar(name, type=nil)
+        puts bar
+      end
+
+    end
+
+    require 'active_mocker'
+
+    ActiveMocker::Base.configure do |config|
+      config.schema_file = 'file is being inject as string'
+      config.model_dir   = 'file is being inject as string'
+    # Dependency injection
+      config.schema_file_reader = schema_file
+      config.model_file_reader  = model_file
+    # Additional Options
+      config.active_hash_as_base = false #default
+      config.schema_attributes   = true  #default
+      config.model_relationships = true  #default
+      config.model_methods       = true  #default
+      config.mass_assignment     = true  #default
+    end
+
+    mocker = ActiveMocker::Base.new({schema: {path: [path to schema.rb file]},
+                                     model:  {path: [dir of rails models]}}
+
+    mocker.mock('Person')
+        => PersonMock
+
+    PersonMock.column_names
+        => ["account_id", "first_name", "last_name", "address", "city"]
+
+    person_mock = PersonMock.new(first_name: "Dustin", last_name: "Zeisler", account: mocker.mock('Account').new)
+        => #<PersonMock @first_name="Dustin", @last_name="Zeisler">
+
+     person_mock.first_name
+        => "Dustin"
+
+### When schema.rb changes the mock fails
+
+     #db/schema.rb
+
+     ActiveRecord::Schema.define(version: 20140327205359) do
+
+       create_table "people", force: true do |t|
+         t.integer  "account_id"
+         t.string   "f_name",        limit: 128
+         t.string   "l_name",        limit: 128
+         t.string   "address",       limit: 200
+         t.string   "city",          limit: 100
+       end
+
+     end
+
+     person_mock = PersonMock.new(first_name: "Dustin", last_name: "Zeisler", account: AccountMock.new)
+             => NoMethodError: undefined method `first_name=' for #<PersonMock:0x007f860abf6b10>
+
+
+### Mocking instance methods
+
+     person_mock.bar
+        => ArgumentError: wrong number of arguments (0 for 1..2)
+
+     person_mock.bar('baz')
+        => RuntimeError: #bar is not Implemented for Class: PersonMock
+
+
+     mock_class.mock_instance_method(:bar) do  |name, type=nil|
+        "Now implemented with #{name} and #{type}"
+     end
+
+     mock_class.new.bar('foo', 'type')
+        => "Now implemented with foo and type"
+
+### When the model changes the mock fails
+
+    #app/models/person.rb
+
+    class Person < ActiveRecord::Base
+      belongs_to :account
+
+      def bar(name)
+        puts bar
+      end
+
+    end
+
+     mock_class.new.bar('foo', 'type')
+        => ArgumentError: wrong number of arguments (2 for 1)
+
+
+
+### When the schema changes
+
 
 ## Contributing
 

data/active_mocker.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~>2.14"
   spec.add_development_dependency "i18n", "~>0.6"
   spec.add_development_dependency "activesupport", "~>4.0"
+  spec.add_development_dependency "active_hash", "~>1.3"
 
   #spec.add_development_dependency "debase", "~>0.0"
   #spec.add_development_dependency "ruby-debug-ide", "~>0.4"

data/lib/active_mocker.rb

@@ -1,5 +1,16 @@
 require "active_mocker/version"
-
+$:.unshift File.expand_path('../../', __FILE__)
+require 'string_reader'
+require 'active_mocker/table'
+require 'active_mocker/config'
+require 'active_mocker/reparameterize'
+require 'active_mocker/field'
+require 'active_mocker/active_record'
+require 'active_mocker/model_reader'
+require 'active_mocker/schema_reader'
+require 'active_mocker/active_record/schema'
+require 'active_mocker/base'
+require 'active_support/all'
 module ActiveMocker
-  # Your code goes here...
+
 end

data/lib/active_mocker/base.rb

@@ -1,38 +1,39 @@
 module ActiveMocker
 
-  #TODO DRY up method creation
-  #TODO have instance variable array for instance method
-  #TODO have class variable array for class method
-  #TODO enable support for active_hash as base class
-  #TODO work on options interface
-
   class Base
+    extend Config
+    extend Forwardable
+    @@_self = self
+    def_delegators :@@_self,
+                   :mass_assignment,
+                   :model_relationships,
+                   :schema_attributes,
+                   :model_methods,
+                   :active_hash_as_base,
+                   :model_dir,
+                   :schema_file,
+                   :model_file_reader,
+                   :schema_file_reader
+
+    attr_reader :model_name, :klass
+
+    def initialize(model_name)
+      @model_name = model_name
+      plain_mock_class       unless active_hash_as_base
+      active_hash_mock_class if active_hash_as_base
+    end
 
-    attr_reader :model_name,
-                :model_options,
-                :options_schema,
-                :mass_assignment,
-                :model_relationships,
-                :schema_attributes,
-                :model_methods
-
-    def initialize(options={})
-      @schema_attributes   = options.fetch(:schema_attributes,   true)
-      @model_relationships = options.fetch(:model_relationships, true)
-      @model_methods       = options.fetch(:model_methods,       true)
-      @mass_assignment     = options.fetch(:mass_assignment,     true)
-      @model_options       = options[:model]
-      @options_schema      = options[:schema]
+    def self.configure(&block)
+      config(&block)
     end
 
-    def mock(model_name)
-      @model_name = model_name
-      mock_class
+    def self.mock(model_name)
+      self.new(model_name).klass
     end
 
     def model_definition
       return @model_definition unless @model_definition.nil?
-      @model_definition = ModelReader.new(model_options).parse(model_file_name)
+      @model_definition = ModelReader.new({model_dir: model_dir, file_reader: model_file_reader}).parse(model_file_name)
     end
 
     def model_file_name
@@ -41,21 +42,42 @@ module ActiveMocker
 
     def table_definition
       table_name = model_name.tableize
-      table = SchemaReader.new(options_schema).search(table_name)
+      table = SchemaReader.new({schema_file: schema_file, file_reader: schema_file_reader}).search(table_name)
       raise "#{table_name} table not found." if table.nil?
       return table
     end
 
-    def mock_class
+    def active_hash_mock_class
+
+      add_column_names_method
+      klass  = create_klass
+      fields = table_definition.column_names + model_definition.relationships
+      klass.class_eval do
+        klass.fields(*fields)
+      end
+
       add_method_mock_of
-      add_instance_methods     if model_methods
-      add_mock_instance_method if model_methods
+      if model_methods
+        add_instance_methods
+        add_mock_instance_method
+        add_mock_class_method
+        add_class_methods
+      end
+
+    end
+
+    def plain_mock_class
+      add_method_mock_of
+      if model_methods
+        add_instance_methods
+        add_mock_instance_method
+        add_mock_class_method
+        add_class_methods
+      end
       add_relationships        if model_relationships
-      add_class_methods        if model_methods
       add_column_names_method  if schema_attributes
       add_table_attributes     if schema_attributes
       create_initializer       if mass_assignment
-      return @klass
     end
 
     def create_initializer
@@ -95,16 +117,30 @@ module ActiveMocker
       klass = create_klass
       model_definition.instance_methods_with_arguments.each do |method|
         m = method.keys.first
-        params = Reparameterize.call(method.values.first)
+        params      = Reparameterize.call(method.values.first)
         params_pass = Reparameterize.call(method.values.first, true)
-        klass.instance_variable_set("@#{m}", eval_lambda(params, %Q[raise "##{m} is not Implemented for Class: #{klass.name}"]))
-        block = eval_lambda(params, %Q[ self.class.instance_variable_get("@#{m}").call(#{params_pass})])
+        klass.instance_variable_set("@instance_#{m}", eval_lambda(params, %Q[raise "##{m} is not Implemented for Class: #{klass.name}"]))
+        block = eval_lambda(params, %Q[ self.class.instance_variable_get("@instance_#{m}").call(#{params_pass})])
         klass.instance_eval do
           define_method(m, block)
         end
       end
     end
 
+    def add_class_methods
+      klass = create_klass
+      model_definition.class_methods_with_arguments.each do |method|
+        m = method.keys.first
+        params = Reparameterize.call(method.values.first)
+        params_pass = Reparameterize.call(method.values.first, true)
+        klass.class_variable_set("@@klass_#{m}", eval_lambda(params, %Q[raise "::#{m} is not Implemented for Class: #{klass.name}"]))
+        block = eval_lambda(params, %Q[ class_variable_get("@@klass_#{m}").call(#{params_pass})])
+        klass.singleton_class.class_eval do
+          define_method(m, block)
+        end
+      end
+    end
+
     def eval_lambda(arguments, block)
       eval(%Q[ ->(#{arguments}){ #{block} }])
     end
@@ -113,18 +149,21 @@ module ActiveMocker
       klass = create_klass
       klass.singleton_class.class_eval do
         define_method(:mock_instance_method) do |method, &block|
-          klass.instance_variable_set("@#{method.to_s}", block)
+          klass.instance_variable_set("@instance_#{method.to_s}", block)
+        end
+      end
+      klass.instance_eval do
+        define_method(:mock_instance_method) do |method, &block|
+          klass.instance_variable_set("@instance_#{method.to_s}", block)
         end
       end
     end
 
-    def add_class_methods
+    def add_mock_class_method
       klass = create_klass
-      model_definition.class_methods.each do |m|
-        klass.singleton_class.class_eval do
-          define_method(m) do
-            raise "::#{m} is not Implemented for Class: #{klass.name}"
-          end
+      klass.singleton_class.class_eval do
+        define_method(:mock_class_method) do |method, &block|
+          class_variable_set("@@klass_#{method.to_s}", block)
         end
       end
     end
@@ -145,8 +184,8 @@ module ActiveMocker
 
     def const_class
       remove_const(mock_class_name) if class_exists? mock_class_name
-      return Object.const_set(mock_class_name, Class.new) unless Object.const_defined?(mock_class_name)
-      return Object.const_get(mock_class_name, false)
+      return Object.const_set(mock_class_name ,Class.new(ActiveHash::Base)) if active_hash_as_base
+      return Object.const_set(mock_class_name ,Class.new()) unless active_hash_as_base
     end
 
     def remove_const(class_name)

data/lib/active_mocker/config.rb

@@ -0,0 +1,34 @@
+module ActiveMocker
+
+  module Config
+    extend self
+
+    attr_accessor :schema_file,
+                  :model_dir,
+                  :active_hash_as_base,
+                  :schema_attributes,
+                  :model_relationships,
+                  :model_methods,
+                  :mass_assignment,
+                  :schema_file_reader,
+                  :model_file_reader
+
+    def config
+      default
+      yield self
+    end
+
+    def default
+      schema_file         = nil
+      model_dir           = nil
+      active_hash_as_base = false
+      schema_attributes   = true
+      model_relationships = true
+      model_methods       = true
+      mass_assignment     = true
+    end
+
+  end
+
+end
+

data/lib/active_mocker/model_reader.rb

@@ -2,11 +2,11 @@ module ActiveMocker
 
   class ModelReader
 
-    attr_reader :model_name, :relative_path, :file_reader
+    attr_reader :model_name, :model_dir, :file_reader
 
     def initialize(options={})
       @file_reader = options[:file_reader] ||= FileReader
-      @relative_path = options[:path]
+      @model_dir   = options[:model_dir]
     end
 
     def parse(model_name)
@@ -26,11 +26,11 @@ module ActiveMocker
     end
 
     def read_file
-      file_reader.read("#{relative_path}/#{model_name}.rb")
+      file_reader.read("#{model_dir}/#{model_name}.rb")
     end
 
     def class_methods
-      (klass.methods - Object.methods - instance_methods - ActiveRecord::Base.methods)
+      klass.methods(false)
     end
 
     def class_methods_with_arguments

data/lib/active_mocker/schema_reader.rb

@@ -2,11 +2,11 @@ module ActiveMocker
 
   class SchemaReader
 
-    attr_reader :model_name, :relative_path, :file_reader, :table
+    attr_reader :model_name, :schema_file, :file_reader, :table
 
     def initialize(options={})
       @file_reader = options[:file_reader] ||= FileReader
-      @relative_path = options[:path]
+      @schema_file = options[:schema_file]
     end
 
     def search(model_name)
@@ -37,7 +37,7 @@ module ActiveMocker
     end
 
     def read_file
-      file_reader.read("#{relative_path}/schema.rb")
+      file_reader.read(schema_file)
     end
 
   end

data/lib/active_mocker/version.rb

@@ -1,3 +1,3 @@
 module ActiveMocker
-  VERSION = "0.1.1"
+  VERSION = "0.3.1"
 end

data/spec/lib/active_mocker/base_spec.rb

@@ -2,6 +2,7 @@ require 'rspec'
 $:.unshift File.expand_path('../../', __FILE__)
 require 'string_reader'
 require 'active_mocker/table'
+require 'active_mocker/config'
 require 'active_mocker/reparameterize'
 require 'active_mocker/field'
 require 'active_mocker/active_record'
@@ -13,13 +14,25 @@ require 'active_support/all'
 
 describe ActiveMocker::Base do
 
-  let(:base_options){{}}
-  let(:sub_options){{schema: {path: File.expand_path('../../', __FILE__), file_reader: schema_file},
-                     model:  {path:  File.expand_path('../../', __FILE__), file_reader: model_file}}}
-
-  let(:subject){ described_class.new(base_options.merge(sub_options))}
+  let(:mock_class){described_class.mock('Person')}
+
+  before(:each) do
+
+    ActiveMocker::Base.configure do |config|
+      config.schema_file = 'file is being inject as string'
+      config.model_dir   = 'file is being inject as string'
+      # Dependency injection
+      config.schema_file_reader = schema_file
+      config.model_file_reader  = model_file
+      # Additional Options
+      config.active_hash_as_base = false #default
+      config.schema_attributes   = true  #default
+      config.model_relationships = true  #default
+      config.model_methods       = true  #default
+      config.mass_assignment     = true  #default
+    end
 
-  let(:mock_class){subject.mock('Person')}
+  end
 
     let(:model_file){
       StringReader.new <<-eos
@@ -32,22 +45,49 @@ describe ActiveMocker::Base do
       StringReader.new <<-eos
         ActiveRecord::Schema.define(version: 20140327205359) do
 
-              create_table "people", force: true do |t|
-                t.integer  "company_id"
-                t.string   "first_name",        limit: 128
-                t.string   "middle_name",       limit: 128
-                t.string   "last_name",         limit: 128
-                t.string   "address_1",         limit: 200
-                t.string   "address_2",         limit: 100
-                t.string   "city",              limit: 100
-                t.integer  "state_id"
-                t.integer  "zip_code_id"
-              end
-
+            create_table "people", force: true do |t|
+              t.integer  "account_id"
+              t.string   "first_name",        limit: 128
+              t.string   "last_name",         limit: 128
+              t.string   "address",         limit: 200
+              t.string   "city",              limit: 100
             end
+
+          end
       eos
     }
 
+  describe '::column_names' do
+
+    it 'returns an array of column names found from the schema.rb file' do
+      expect(mock_class.column_names).to eq(["account_id", "first_name", "last_name", "address", "city"])
+    end
+
+  end
+
+  describe 'mass_assignment' do
+
+    it "can pass any or all attributes from schema in initializer" do
+      result = mock_class.new(first_name: "Sam", last_name: 'Walton')
+      expect(result.first_name).to eq 'Sam'
+      expect(result.last_name).to eq 'Walton'
+
+    end
+
+    context 'set to false' do
+
+      it 'will fail' do
+        described_class.mass_assignment = false
+        person = described_class.mock("Person")
+        expect{
+          person.new(first_name: "Sam", last_name: 'Walton')
+        }.to raise_error ArgumentError
+      end
+
+    end
+
+  end
+
   describe '#mock_class' do
 
     it 'create a mock object after the active record' do
@@ -99,6 +139,38 @@ describe ActiveMocker::Base do
 
     end
 
+    describe 'conflict of instance mocks and class mocks' do
+
+      let(:model_file){
+        StringReader.new <<-eos
+        class Person < ActiveRecord::Base
+          def bar(name, type=nil)
+          end
+
+          def self.bar
+          end
+        end
+        eos
+      }
+
+      it 'can mock instance method and class method of the same name' do
+        result = mock_class.new
+        result.mock_instance_method(:bar) do  |name, type=nil|
+          "Now implemented with #{name} and #{type}"
+        end
+        result = result.bar('foo', 'type')
+        expect(result).to eq "Now implemented with foo and type"
+        expect{mock_class.bar}.to raise_error('::bar is not Implemented for Class: PersonMock')
+
+        mock_class.mock_class_method(:bar) do
+          "Now implemented"
+        end
+        expect{mock_class.bar}.to_not raise_error
+        expect(mock_class.bar).to eq("Now implemented")
+      end
+
+    end
+
     describe 'instance methods' do
 
       let(:model_file){
@@ -116,15 +188,6 @@ describe ActiveMocker::Base do
         expect{mock_class.new.bar('foo', 'type')}.to raise_error('#bar is not Implemented for Class: PersonMock')
       end
 
-      it 'can be implemented dynamically' do
-
-        mock_class.instance_variable_set(:@bar, ->(name, type=nil){ "Now implemented with #{name} and #{type}" })
-        result = mock_class.new
-        result = result.bar('foo', 'type')
-        expect(result).to eq "Now implemented with foo and type"
-
-      end
-
       it 'can be implemented dynamically' do
 
         mock_class.mock_instance_method(:bar) do  |name, type=nil|
@@ -156,10 +219,13 @@ describe ActiveMocker::Base do
         expect{mock_class.class_method}.to raise_error('::class_method is not Implemented for Class: PersonMock')
       end
 
-      xit 'can be implemented as follows' do
-
+      it 'can be implemented as follows' do
 
-        expect(mock_class.named).to eq "Now implemented"
+        mock_class.mock_class_method(:class_method) do
+          "Now implemented"
+        end
+        expect{mock_class.class_method}.to_not raise_error
+        expect(mock_class.class_method).to eq("Now implemented")
 
       end
 
@@ -171,50 +237,92 @@ describe ActiveMocker::Base do
 
   end
 
-  describe '::column_names' do
+  context 'option active_hash_as_base' do
 
+    describe 'true' do
 
-    it 'returns an array of column names found from the schema.rb file' do
-      expect(mock_class.column_names).to eq(["company_id", "first_name", "middle_name", "last_name", "address_1", "address_2", "city", "state_id", "zip_code_id"])
-    end
+      before(:each) do
 
-  end
+        ActiveMocker::Base.configure do |config|
+          config.schema_file = 'file is being inject as string'
+          config.model_dir   = 'file is being inject as string'
+          # Depenency injection
+          config.schema_file_reader = schema_file
+          config.model_file_reader  = model_file
+          # Additional Options
+          config.active_hash_as_base = true
+          config.schema_attributes   = false
+          config.model_relationships = false
+          config.model_methods       = true
+          config.mass_assignment     = false
+        end
 
+      end
+      require 'active_hash'
 
-  describe 'have attributes from schema' do
+      let(:model_file){
+        StringReader.new <<-eos
+        class Person < ActiveRecord::Base
+          belongs_to :account
 
-    xit 'uses ActiveHash'
+          def bar
+          end
 
-    xit 'makes plain ruby class' do
+        end
+        eos
+      }
 
-    end
+      it 'uses active_hase::base as superclass' do
+        expect(mock_class.superclass.name).to eq 'ActiveHash::Base'
+      end
 
-  end
+      it 'can mass assign attributes to constructor' do
+        result = mock_class.new(first_name: "Sam", last_name: 'Walton', account: 0)
+        expect(result.first_name).to eq 'Sam'
+        expect(result.last_name).to eq 'Walton'
+        expect(result.account).to eq 0
+      end
 
-  describe 'mass_assignment' do
+      it 'can save to class and then find instance by attribute' do
 
+        record = mock_class.create(first_name: "Sam", last_name: 'Walton')
+        expect(mock_class.find_by_first_name("Sam")).to eq record
 
+      end
 
-    it "can pass any or all attributes from schema in initializer" do
-      result = mock_class.new(first_name: "Sam", last_name: 'Walton')
-      expect(result.first_name).to eq 'Sam'
-      expect(result.last_name).to eq 'Walton'
+      it '::column_names' do
+        expect(mock_class.column_names).to eq(["account_id", "first_name", "last_name", "address", "city"])
+      end
+
+      it '#mock_of' do
+        expect(mock_class.new.mock_of).to eq 'Person'
+      end
+
+      it 'instance methods from model' do
+        expect{mock_class.new.bar}.to raise_error '#bar is not Implemented for Class: PersonMock'
+      end
+
+      it 'instance method can be mocked' do
+
+        mock_class.instance_variable_set(:@instance_bar, ->(){ "Now implemented" })
+        result = mock_class.new
+        result = result.bar
+        expect(result).to eq "Now implemented"
+
+      end
 
     end
 
-    context 'set to false' do
+    describe 'false' do
+      let(:base_options){{active_hash_as_base: false}}
+
+      it 'has object as supper class' do
+        expect(mock_class.superclass.name).to eq 'Object'
 
-      it 'will fail' do
-        mock = described_class.new(sub_options.merge({mass_assignment: false}))
-        person = mock.mock("Person")
-        expect{
-          person.new(first_name: "Sam", last_name: 'Walton')
-        }.to raise_error ArgumentError
       end
 
     end
 
   end
 
-
 end

data/spec/lib/active_mocker/model_reader_spec.rb

@@ -8,11 +8,11 @@ require 'active_mocker/reparameterize'
 
 describe ActiveMocker::ModelReader do
 
-  let(:subject){ described_class.new({path: File.expand_path('../../', __FILE__)}).parse('Model') }
+  let(:subject){ described_class.new({model_dir: File.expand_path('../../', __FILE__)}).parse('Model') }
 
   describe '#parse' do
 
-    let(:subject){ described_class.new({path: File.expand_path('../../', __FILE__)}) }
+    let(:subject){ described_class.new({model_dir: File.expand_path('../../', __FILE__)}) }
 
     it 'takes a model name to the active_record model class' do
       subject.parse('Model')
@@ -22,9 +22,8 @@ describe ActiveMocker::ModelReader do
 
   describe '#class_methods' do
 
-
     it 'returns all public class methods' do
-      expect(subject.class_methods).to eq([:duper, :named])
+      expect(subject.class_methods).to eq([:duper, :named, :foo])
     end
 
   end
@@ -48,7 +47,7 @@ describe ActiveMocker::ModelReader do
   describe '#class_methods_with_arguments' do
 
     it 'returns all public instance methods' do
-      expect(subject.class_methods_with_arguments).to eq([{:duper=>[[:req, :value], [:rest, :args]]}, {:named=>[[:req, :name], [:opt, :value], [:opt, :options]]}])
+      expect(subject.class_methods_with_arguments).to eq( [{:duper=>[[:req, :value], [:rest, :args]]}, {:named=>[[:req, :name], [:opt, :value], [:opt, :options]]}, {:foo=>[]}] )
     end
 
   end
@@ -110,7 +109,7 @@ describe ActiveMocker::ModelReader do
       )
     }
 
-    let(:subject){described_class.new({path: File.expand_path('../../', __FILE__), file_reader: example_model})}
+    let(:subject){described_class.new({model_dir: File.expand_path('../../', __FILE__), file_reader: example_model})}
 
     let(:search){subject.parse('Person')}
 

data/spec/lib/active_mocker/schema_reader_spec.rb

@@ -10,6 +10,8 @@ require 'active_support/all'
 
 describe ActiveMocker::SchemaReader do
 
+  let(:schema_file){ File.join(File.expand_path('../../', __FILE__), 'schema.rb') }
+
   let(:example_schema){
     StringReader.new(
         <<-eos
@@ -55,7 +57,7 @@ describe ActiveMocker::SchemaReader do
 
   context 'inject string_reader as file_reader' do
 
-    let(:subject){described_class.new({path: File.expand_path('../../', __FILE__), file_reader: example_schema})}
+    let(:subject){described_class.new({schema_file:nil, file_reader: example_schema})}
 
     let(:search){subject.search('people')}
 
@@ -70,13 +72,13 @@ describe ActiveMocker::SchemaReader do
 
   context 'reads from file' do
 
-    let(:subject){described_class.new({path: File.expand_path('../../', __FILE__)})}
+    let(:subject){described_class.new({schema_file: schema_file})}
 
 
     describe '#search' do
 
       it 'takes a table name and will return its attributes' do
-        described_class.new({path: File.expand_path('../../', __FILE__)}).search("people")
+        described_class.new({schema_file: schema_file}).search("people")
       end
 
     end
@@ -112,13 +114,11 @@ describe ActiveMocker::SchemaReader do
     it 'returns an exception if table not found in schema.rb' do
       expect{
         described_class.new(
-            {path: File.expand_path('../../', __FILE__)}
+            {schema_file: schema_file}
         ).search("disclosures")
       }.to raise_error 'disclosures table not found.'
     end
 
-
   end
 
-
 end

data/spec/lib/model.rb

@@ -15,6 +15,10 @@ class Model < ActiveRecord::Base
 
   end
 
+  def self.foo
+
+  end
+
   def super
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_mocker
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-01 00:00:00.000000000 Z
+date: 2014-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: active_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: Create mocks from active record models without loading rails or running
   a database. The Mocks methods have the same arguments as the AR model and if they
   change you get a error in your test.
@@ -102,6 +116,7 @@ files:
 - lib/active_mocker/active_record/schema.rb
 - lib/active_mocker/active_record/scope.rb
 - lib/active_mocker/base.rb
+- lib/active_mocker/config.rb
 - lib/active_mocker/field.rb
 - lib/active_mocker/model_reader.rb
 - lib/active_mocker/reparameterize.rb