active_mocker 0.1.1

data/spec/lib/active_mocker/base_spec.rb

@@ -0,0 +1,220 @@
+require 'rspec'
+$:.unshift File.expand_path('../../', __FILE__)
+require 'string_reader'
+require 'active_mocker/table'
+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'
+
+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){subject.mock('Person')}
+
+    let(:model_file){
+      StringReader.new <<-eos
+        class Person < ActiveRecord::Base
+        end
+      eos
+    }
+
+    let(:schema_file){
+      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
+
+            end
+      eos
+    }
+
+  describe '#mock_class' do
+
+    it 'create a mock object after the active record' do
+      expect(mock_class).to eq(PersonMock)
+    end
+
+    context 'private methods' do
+
+      let(:model_file){
+        StringReader.new <<-eos
+        class Person < ActiveRecord::Base
+          private
+
+          def bar
+          end
+
+        end
+        eos
+      }
+
+      it 'will not have private methods' do
+        expect{mock_class.bar}.to raise_error(NoMethodError)
+      end
+
+    end
+
+    describe '#mock_of' do
+
+      it 'return the name of the class that is being mocked' do
+        expect(mock_class.new.mock_of).to eq 'Person'
+      end
+
+    end
+
+    describe 'relationships' do
+
+      let(:model_file){
+        StringReader.new <<-eos
+        class Person < ActiveRecord::Base
+          belongs_to :account
+        end
+        eos
+      }
+
+      it 'add instance methods from model relationships' do
+        result = mock_class.new(account: 'Account')
+        expect(result.account).to eq 'Account'
+      end
+
+    end
+
+    describe 'instance methods' do
+
+      let(:model_file){
+        StringReader.new <<-eos
+        class Person < ActiveRecord::Base
+          def bar(name, type=nil)
+          end
+        end
+        eos
+      }
+
+      it 'will raise exception for unimplemented methods' do
+        expect(mock_class.new.method(:bar).parameters).to eq  [[:req, :name], [:opt, :type]]
+        expect{mock_class.new.bar}.to raise_error ArgumentError
+        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|
+          "Now implemented with #{name} and #{type}"
+        end
+
+        result = mock_class.new
+        result = result.bar('foo', 'type')
+        expect(result).to eq "Now implemented with foo and type"
+
+      end
+
+    end
+
+    describe 'class methods' do
+
+      let(:model_file){
+        StringReader.new <<-eos
+        class Person < ActiveRecord::Base
+          scope :named, -> { }
+
+          def self.class_method
+          end
+        end
+        eos
+      }
+
+      it 'will raise exception for unimplemented methods' 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
+
+
+        expect(mock_class.named).to eq "Now implemented"
+
+      end
+
+      it 'loads named scopes as class method' do
+        expect{mock_class.named}.to raise_error('::named is not Implemented for Class: PersonMock')
+      end
+
+    end
+
+  end
+
+  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(["company_id", "first_name", "middle_name", "last_name", "address_1", "address_2", "city", "state_id", "zip_code_id"])
+    end
+
+  end
+
+
+  describe 'have attributes from schema' do
+
+    xit 'uses ActiveHash'
+
+    xit 'makes plain ruby class' do
+
+    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
+        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

@@ -0,0 +1,126 @@
+require 'rspec'
+$:.unshift File.expand_path('../../', __FILE__)
+require 'string_reader'
+require 'file_reader'
+require 'active_mocker/active_record'
+require 'active_mocker/model_reader'
+require 'active_mocker/reparameterize'
+
+describe ActiveMocker::ModelReader do
+
+  let(:subject){ described_class.new({path: File.expand_path('../../', __FILE__)}).parse('Model') }
+
+  describe '#parse' do
+
+    let(:subject){ described_class.new({path: File.expand_path('../../', __FILE__)}) }
+
+    it 'takes a model name to the active_record model class' do
+      subject.parse('Model')
+    end
+
+  end
+
+  describe '#class_methods' do
+
+
+    it 'returns all public class methods' do
+      expect(subject.class_methods).to eq([:duper, :named])
+    end
+
+  end
+
+  describe '#instance methods' do
+
+    it 'returns all public instance methods' do
+      expect(subject.instance_methods).to eq([:foo, :super])
+    end
+
+  end
+
+  describe '#instance_methods_with_arguments' do
+
+    it 'returns all public instance methods' do
+      expect(subject.instance_methods_with_arguments).to eq([{:foo=>[[:req, :foobar], [:req, :value]]}, {:super=>[]}])
+    end
+
+  end
+
+  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]]}])
+    end
+
+  end
+
+  describe '#relationships_types' do
+
+    it '#belongs_to' do
+
+      expect(subject.relationships_types.belongs_to).to eq([[:company]])
+
+    end
+
+    it '#has_many' do
+
+      expect(subject.relationships_types.has_many).to eq([[:users]])
+
+    end
+
+    it '#has_one' do
+
+      expect(subject.relationships_types.has_one).to eq([[:account]])
+
+    end
+
+    it '#has_and_belongs_to_many' do
+
+      expect(subject.relationships_types.has_and_belongs_to_many).to eq([[:disclosure]])
+
+    end
+
+  end
+
+  describe '#relationships' do
+
+    it 'returns an array of relations' do
+
+      expect(subject.relationships).to eq [:users, :account, :company, :disclosure]
+
+    end
+
+  end
+
+
+  context 'inject string_reader as file_reader' do
+
+    let(:example_model){
+      StringReader.new(
+          <<-eos
+            class Person < ActiveRecord::Base
+
+              belongs_to :zip_code
+
+              def full_name(first_name, last_name)
+
+              end
+
+            end
+          eos
+      )
+    }
+
+    let(:subject){described_class.new({path: File.expand_path('../../', __FILE__), file_reader: example_model})}
+
+    let(:search){subject.parse('Person')}
+
+    it 'let not read a file but return a string instead to be evaluated' do
+      expect(search.relationships_types.belongs_to).to eq  [[:zip_code]]
+      expect(subject.instance_methods).to eq([:full_name])
+      expect(subject.instance_methods_with_arguments).to eq([{:full_name=>[[:req, :first_name], [:req, :last_name]]}])
+    end
+
+  end
+
+end
+

data/spec/lib/active_mocker/schema_reader_spec.rb

@@ -0,0 +1,124 @@
+require 'rspec'
+$:.unshift File.expand_path('../../', __FILE__)
+require 'string_reader'
+require 'file_reader'
+require 'active_mocker/table'
+require 'active_mocker/field'
+require 'active_mocker/active_record/schema'
+require 'active_mocker/schema_reader'
+require 'active_support/all'
+
+describe ActiveMocker::SchemaReader do
+
+  let(:example_schema){
+    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"
+                t.string   "title",             limit: 150
+                t.string   "department",        limit: 150
+                t.string   "person_email",      limit: 150
+                t.string   "work_phone",        limit: 20
+                t.string   "cell_phone",        limit: 20
+                t.string   "home_phone",        limit: 20
+                t.string   "fax",               limit: 20
+
+              end
+
+              create_table "zip_codes", force: true do |t|
+                t.string  "zip_code",       limit: 9
+                t.integer "state_id"
+                t.integer "cola_by_fip_id"
+                t.string  "city_name",      limit: 100
+                t.string  "County_name",    limit: 100
+                t.decimal "City_Latitude",              precision: 8, scale: 4
+                t.decimal "City_Longitude",             precision: 8, scale: 4
+              end
+
+              add_index "zip_codes", ["zip_code"], name: "index_zip_codes_on_zip_code", unique: true, using: :btree
+
+            end
+
+    eos
+    )
+  }
+
+  context 'inject string_reader as file_reader' do
+
+    let(:subject){described_class.new({path: File.expand_path('../../', __FILE__), file_reader: example_schema})}
+
+    let(:search){subject.search('people')}
+
+    it 'let not read a file but return a string instead to be evaluated' do
+      people = subject.search('people')
+      expect(people.name).to eq 'people'
+      expect(people.fields[1].to_h).to eq({:name=>"first_name", :type=>:string, :options=>[{:limit=>128}]})
+      expect(subject.search('zip_codes').name).to eq 'zip_codes'
+    end
+
+  end
+
+  context 'reads from file' do
+
+    let(:subject){described_class.new({path: File.expand_path('../../', __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")
+      end
+
+    end
+
+    let(:people_search){subject.search("people")}
+
+    describe '#column_names' do
+
+      it 'returns an array of columns from the schema.rb' do
+        expect(people_search.name).to eq 'people'
+        expect(people_search.column_names).to eq ["company_id", "first_name", "middle_name", "last_name", "address_1", "address_2", "city", "state_id", "zip_code_id", "title", "department", "person_email", "work_phone", "cell_phone", "home_phone", "fax", "user_id_assistant", "birth_date", "needs_review", "created_at", "updated_at"]
+      end
+
+    end
+
+    describe '#fields' do
+
+      it 'returns all fields from schema' do
+        expect(people_search.fields.first.to_h).to eq({:name=>"company_id", :type=>:integer, :options=>[]})
+      end
+
+    end
+
+    describe '#name' do
+
+      it 'returns the name of the table' do
+        expect(people_search.name).to eq("people")
+      end
+
+
+    end
+
+    it 'returns an exception if table not found in schema.rb' do
+      expect{
+        described_class.new(
+            {path: File.expand_path('../../', __FILE__)}
+        ).search("disclosures")
+      }.to raise_error 'disclosures table not found.'
+    end
+
+
+  end
+
+
+end