RubyGems - active_mocker - Versions diffs - 1.4.2 → 1.5 - Mend

active_mocker 1.4.2 → 1.5

Files changed (213) hide show

data/spec/lib/active_mocker/schema_reader_spec.rb DELETED

@@ -1,109 +0,0 @@
-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(:schema_file){ File.join(File.expand_path('../../', __FILE__), 'schema.rb') }
-  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({schema_file:nil, file_reader: example_schema, clear_cache: true})}
-    let!(:search){subject.search(nil)}
-    it 'let not read a file but return a string instead to be evaluated' do
-      tables = subject.tables
-      expect(tables.first.name).to eq 'people'
-      expect(tables.last.name).to eq 'zip_codes'
-      expect(tables.last.fields.count).to eq 8
-    end
-  end
-  context 'reads from file' do
-    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({schema_file: schema_file}).search(nil)
-      end
-    end
-    let(:tables){subject.search("people")}
-    describe '#column_names' do
-      it 'returns an array of columns from the schema.rb' do
-        tables
-        expect(subject.tables.first.name).to eq 'people'
-        expect(subject.tables.first.column_names).to eq ["id", "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
-        tables
-        expect(subject.tables.first.fields[1].to_h).to eq({:name=>"company_id", :type=>:integer, :options=>{}})
-      end
-    end
-  end
-end

data/spec/lib/model.rb DELETED

@@ -1,43 +0,0 @@
-class Model < ActiveRecord::Base
-  include FooBar
-  extend Baz
-  include ModelCore::PlanService::Dah
-  belongs_to :company, class_name: 'PlanServiceCategory', foreign_key: 'category_id'
-  belongs_to :person, through: 'customer'
-  has_many :users
-  has_one :account
-  has_and_belongs_to_many :disclosures
-  devise :database_authenticatable, :registerable,
-         :recoverable, :rememberable, :trackable, :validatable
-  def self.duper(value, *args)
-  end
-  scope :named, ->(name, value=nil, options={}) { }
-  def foo(foobar, value)
-  end
-  def self.foo
-  end
-  def super
-  end
-  def self.bang!
-  end
-  private
-  def bar
-  end
-end

data/spec/lib/person.rb DELETED

@@ -1,9 +0,0 @@
-class Person < ActiveRecord::Base
-  belongs_to :zip_code
-  def full_name
-    "#{first_name} #{last_name}"
-  end
-end

data/spec/lib/readme_spec.rb DELETED

@@ -1,199 +0,0 @@
-# require 'rspec'
-# $:.unshift File.expand_path('../../../active_mocker', __FILE__)
-# require 'active_mocker'
-# require 'string_reader'
-#
-# describe 'ReadMe', pending:true do
-#
-#   before(:each) do
-#     ActiveMocker.configure do |config|
-#       # Required Options
-#       config.schema_file = ""
-#       config.model_dir   = ""
-#       config.schema_file_reader = schema_file
-#       config.model_file_reader  = model_file
-#       config.mock_dir =
-#       config.logger = Logger.new(STDOUT)
-#     end
-#   end
-#
-#   let(:schema_file){
-#     StringReader.new <<-eos
-#
-#       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
-#
-#     eos
-#   }
-#
-#   let(:model_file){
-#     StringReader.new <<-eos
-#       class Person < ActiveRecord::Base
-#         belongs_to :account
-#
-#         def bar(name, type=nil)
-#           puts name
-#         end
-#
-#         def self.bar
-#         end
-#
-#       end
-#     eos
-#   }
-#
-#   before do
-#     ActiveMocker.mock('Person')
-#   end
-#
-#   let(:person_mock){PersonMock}
-#
-#   describe 'Usage' do
-#
-#     it 'Mock a Person' do
-#       expect(ActiveMocker.mock('Person')).to eq PersonMock
-#     end
-#
-#     it '::column_names' do
-#       expect(PersonMock.column_names).to eq ["id", "account_id", "first_name", "last_name", "address", "city"]
-#     end
-#
-#     it '::new' do
-#       expect(PersonMock.new(first_name: "Dustin", last_name: "Zeisler").inspect).to eq("#<PersonMock id: nil, account_id: nil, first_name: \"Dustin\", last_name: \"Zeisler\", address: nil, city: nil>")
-#     end
-#
-#     it '#first_name' do
-#       person_mock = PersonMock.new(first_name: "Dustin", last_name: "Zeisler")
-#       expect( person_mock.first_name).to eq 'Dustin'
-#     end
-#
-#   end
-#
-#   describe 'When schema.rb changes, the mock fails' do
-#
-#     let(:schema_file){
-#       StringReader.new <<-eos
-#
-#       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
-#
-#       eos
-#     }
-#
-#     it 'fails' do
-#       expect{ActiveMocker.mock('Person').new(first_name: "Dustin", last_name: "Zeisler")}.to raise_error(RuntimeError)
-#     end
-#
-#   end
-#
-#   describe 'Mocking instance and class methods' do
-#
-#     it 'bar is not Implemented' do
-#       expect{person_mock.bar}.to raise_error( RuntimeError, '::bar is not Implemented for Class: PersonMock' )
-#     end
-#
-#     it 'is implemented' do
-#       person_mock.mock_instance_method(:bar) do  |name, type=nil|
-#         "Now implemented with #{name} and #{type}"
-#       end
-#
-#       expect(person_mock.new.bar('foo', 'type')).to eq "Now implemented with foo and type"
-#
-#       person_mock.mock_class_method(:bar) do
-#         "Now implemented"
-#       end
-#
-#       expect(person_mock.bar).to eq "Now implemented"
-#
-#     end
-#
-#     it 'has argument error' do
-#
-#       person_mock.mock_instance_method(:bar) do |name, type=nil|
-#         "Now implemented with #{name} and #{type}"
-#       end
-#
-#       expect{person_mock.new.bar}.to raise_error(ArgumentError, 'wrong number of arguments (0 for 1..2)')
-#
-#     end
-#
-#   end
-#
-#   describe 'When the model changes, the mock fails' do
-#
-#     context 'different arguments' do
-#
-#       let(:model_file){
-#         StringReader.new <<-eos
-#         class Person < ActiveRecord::Base
-#           belongs_to :account
-#
-#           def bar(name)
-#             puts name
-#           end
-#
-#         end
-#       eos
-#       }
-#
-#       it 'has argument error' do
-#
-#         person_mock.mock_instance_method(:bar) do |name, type=nil|
-#           "Now implemented with #{name} and #{type}"
-#         end
-#
-#         expect{person_mock.new.bar('foo', 'type')}.to raise_error(ArgumentError, 'wrong number of arguments (2 for 1)')
-#
-#       end
-#
-#     end
-#
-#     context 'different method name' do
-#
-#       let(:model_file){
-#           StringReader.new <<-eos
-#         class Person < ActiveRecord::Base
-#           belongs_to :account
-#
-#           def foo(name)
-#             puts name
-#           end
-#
-#         end
-#
-#       eos
-#       }
-#
-#       it 'when method name changes' do
-#
-#         person_mock.mock_instance_method(:bar) do  |name, type=nil|
-#           "Now implemented with #{name} and #{type}"
-#         end
-#
-#         expect{person_mock.new.bar}.to raise_error(NoMethodError)
-#
-#       end
-#
-#     end
-#
-#   end
-#
-# end

data/spec/lib/reparameterize_spec.rb DELETED

@@ -1,202 +0,0 @@
-require 'rspec'
-require 'rspec/given'
-$:.unshift File.expand_path('../../../lib', __FILE__)
-require 'active_mocker/reparameterize'
-describe ActiveMocker::Reparameterize do
-  describe '::call' do
-    describe 'create parameter arguments' do
-      context 'keyreq' do
-        Given(:parameters) { [[:keyreq, 'named_param']] }
-        When(:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('named_param:') }
-      end
-      context 'key' do
-        Given(:parameters) { [[:key, 'named_param']] }
-        When (:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('named_param: nil') }
-      end
-      context 'req' do
-        Given(:parameters) { [[:req, 'req_param']] }
-        When (:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('req_param') }
-      end
-      context 'rest' do
-        Given(:parameters) { [[:rest, 'rest_param']] }
-        When (:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('*rest_param') }
-      end
-      context 'opt' do
-        Given(:parameters) { [[:opt, 'opt_param']] }
-        When(:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('opt_param=nil') }
-      end
-      context 'req, rest' do
-        Given(:parameters) { [[:req, 'req_param'], [:rest, 'rest_param']] }
-        When(:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('req_param, *rest_param') }
-      end
-      context 'req, opt' do
-        Given(:parameters) { [[:req, 'req_param'], [:opt, 'opt_param']] }
-        When(:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('req_param, opt_param=nil') }
-      end
-      context 'key, keyreq' do
-        Given(:parameters) { [[:key, 'named_param'], [:keyreq, 'named_param']] }
-        When(:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('named_param: nil, named_param:') }
-      end
-      context 'rep, key' do
-        Given(:parameters) { [[:key, 'key_param'], [:req, 'req_param']] }
-        When (:call) { described_class.call(parameters) }
-        Then { expect(call).to eq('key_param: nil, req_param') }
-      end
-    end
-    context 'create a parameter passable list' do
-      context 'keyreq' do
-        Given(:parameters) { [[:keyreq, 'named_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('named_param: named_param') }
-      end
-      context 'key' do
-        Given(:parameters) { [[:key, 'named_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('named_param: named_param') }
-      end
-      context 'req' do
-        Given(:parameters) { [[:req, 'req_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('req_param') }
-      end
-      context 'rest' do
-        Given(:parameters) { [[:rest, 'rest_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('rest_param') }
-      end
-      context 'opt' do
-        Given(:parameters) { [[:opt, 'opt_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('opt_param') }
-      end
-      context 'req, rest' do
-        Given(:parameters) { [[:req, 'req_param'], [:rest, 'rest_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('req_param, rest_param') }
-      end
-      context 'req, opt' do
-        Given(:parameters) { [[:req, 'req_param'], [:opt, 'opt_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('req_param, opt_param') }
-      end
-      context 'key, keyreq' do
-        Given(:parameters) { [[:key, 'key_param'], [:keyreq, 'keyreq_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('key_param: key_param, keyreq_param: keyreq_param') }
-      end
-      context 'rep, key' do
-        Given(:parameters) { [[:key, 'key_param'], [:req, 'req_param']] }
-        When (:call) { described_class.call(parameters, param_list: true) }
-        Then { expect(call).to eq('key_param: key_param, req_param') }
-      end
-    end
-  end
-end