active_mocker 1.4.2 → 1.5

data/spec/lib/acitve_mock/queriable_spec.rb

@@ -1,207 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../', __FILE__)
-require 'active_support/all'
-require 'active_mock/queries'
-require 'active_mock/collection'
-require 'ostruct'
-
-describe ActiveMock::Queries do
-
-  before do
-
-    class Queriable < ActiveMock::Collection
-      include ActiveMock::Queries
-    end
-
-  end
-
-  subject{ Queriable.new }
-
-  describe '#sum' do
-
-    it 'sum values by attribute name' do
-      subject << [OpenStruct.new(value: 1), OpenStruct.new(value: 1)]
-      expect(subject.sum(:value)).to eq 2
-    end
-
-  end
-
-  describe '#limit' do
-
-    let!(:given_collection){ [OpenStruct.new(value: 1),
-                              OpenStruct.new(value: 2),
-                              OpenStruct.new(value: 3)]}
-
-    it 'will return only the n-number of items' do
-      subject << given_collection
-      expect(subject.limit(1).count).to eq 1
-    end
-
-  end
-
-  describe '#<<' do
-
-    it 'will add a single item to the array' do
-
-      subject << "item"
-      expect(subject.count).to eq 1
-      expect(subject.first).to eq 'item'
-
-    end
-
-    it 'will add a many item to the array' do
-
-      subject << ['item1', 'item2', 'item3']
-      expect(subject.count).to eq 3
-      expect(subject).to eq ['item1', 'item2', 'item3']
-
-    end
-
-  end
-
-  describe 'new' do
-
-    it 'take optional item and adds to collection' do
-
-      subject = Queriable.new(1)
-
-      expect(subject.first).to eq 1
-
-    end
-
-    it 'can take an array' do
-
-      subject = Queriable.new([1])
-
-      expect(subject.first).to eq 1
-
-      subject = Queriable.new([1,2])
-
-      expect(subject.last).to eq 2
-
-    end
-
-  end
-
-  describe 'empty?' do
-
-    it 'returns true if collection is empty' do
-      expect(subject.empty?).to eq true
-    end
-
-    it 'returns false if collection is not empty' do
-      subject << 1
-      expect(subject.empty?).to eq false
-    end
-
-  end
-
-  describe 'each' do
-
-    it 'can iterate over array' do
-      sum = 0
-      Queriable.new([1, 2]).each { |a| sum += a }
-      expect(sum).to eq 3
-    end
-
-  end
-
-  describe 'map' do
-
-    it 'return a new array' do
-      expect(Queriable.new([1, 2]).map { |a| a + a }).to eq [2, 4]
-    end
-
-    it 'return an instance of the class' do
-      expect(Queriable.new([1, 2]).map { |a| a + a }).to be_a_kind_of Array
-    end
-
-  end
-
-  describe 'delete_all' do
-
-    let!(:given_collection) { [double(delete: true),
-                               double(delete: true),
-                               double(delete: true)] }
-
-    before do
-      given_collection.each do |item|
-        expect(item).to receive(:delete)
-      end
-      subject << given_collection
-    end
-
-    it 'calls delete on every item in the collection' do
-      subject.delete_all
-    end
-
-    context 'alias destroy_all' do
-
-      it 'calls delete on every item in the collection' do
-        subject.destroy_all
-      end
-
-    end
-
-  end
-
-  describe '#all' do
-    subject{ Queriable.new(given_collection)}
-
-    let(:given_collection) { [1,1,1] }
-
-    it 'return the collection' do
-      expect(subject.all).to eq given_collection
-    end
-
-    it 'returns an instance of the class' do
-      expect(subject.all).to be_a_kind_of Queriable
-    end
-
-  end
-
-  describe 'where' do
-
-    context 'with condition' do
-
-      subject{ Queriable.new(given_collection)}
-
-      let(:given_collection) { [OpenStruct.new(value: 1),
-                                 OpenStruct.new(value: 2),
-                                 OpenStruct.new(value: 3)] }
-
-      it 'returns array of values that meet the condition' do
-        expect(subject.where(value: 1)).to eq [given_collection.first]
-      end
-
-      it 'returns an instance of the class' do
-        expect(subject.where(value: 1)).to be_a_kind_of(Queriable)
-      end
-
-    end
-
-    context 'without condition' do
-
-      subject { Queriable.new(given_collection) }
-
-      it 'return a WhereNotChain' do
-        expect(subject.where).to be_a_kind_of(ActiveMock::Queries::WhereNotChain)
-      end
-
-      let(:given_collection) { [OpenStruct.new(value: 1),
-                                OpenStruct.new(value: 2),
-                                OpenStruct.new(value: 3)] }
-
-      it 'takes .not(condition)' do
-        expect(subject.where.not(value: 1)).to eq [given_collection[1], given_collection[2]]
-      end
-
-      it '.not(condition) return the class' do
-        expect(subject.where.not(value: 1)).to be_a_kind_of(Queriable)
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/active_mocker/db_to_ruby_type_spec.rb

@@ -1,124 +0,0 @@
-require 'rspec'
-require 'rspec/given'
-$:.unshift File.expand_path('../../../lib', __FILE__)
-require 'bigdecimal'
-require 'axiom/types'
-require 'active_mocker/db_to_ruby_type'
-
-describe ActiveMocker::DBToRubyType do
-
-  describe '::call' do
-
-    context 'integer' do
-
-      Given(:db_type) { :integer }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(Fixnum) }
-
-    end
-
-    context 'float' do
-
-      Given(:db_type) { :float }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(Float) }
-
-    end
-
-    context 'decimal' do
-
-      Given(:db_type) { :decimal }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(BigDecimal) }
-
-    end
-
-    context 'timestamp' do
-
-      Given(:db_type) { :timestamp }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(Time) }
-
-    end
-
-    context 'time' do
-
-      Given(:db_type) { :time }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(Time) }
-
-    end
-
-    context 'datetime' do
-
-      Given(:db_type) { :datetime }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(DateTime) }
-
-    end
-
-    context 'date' do
-
-      Given(:db_type) { :date }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(Date) }
-
-    end
-
-    context 'text' do
-
-      Given(:db_type) { :text }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(String) }
-
-    end
-
-    context 'string' do
-
-      Given(:db_type) { :string }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(String) }
-
-    end
-
-    context 'binary' do
-
-      Given(:db_type) { :binary }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(String) }
-
-    end
-
-    context 'boolean' do
-
-      Given(:db_type) { :boolean }
-
-      When (:call) { described_class.call(db_type) }
-
-      Then { expect(call).to eq(Axiom::Types::Boolean) }
-
-    end
-
-  end
-
-end

data/spec/lib/active_mocker/generate_spec.rb

@@ -1,40 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../', __FILE__)
-require 'active_mocker'
-require_relative '../../unit_logger'
-
-describe ActiveMocker::Generate do
-
-  let(:app_root){ File.expand_path('../../../../', __FILE__)}
-  let(:mock_dir){ File.join(app_root, 'sample_app_rails_4/spec/mocks')}
-
-  before(:each) do
-    ActiveMocker.config do |config|
-      config.schema_file = File.join(app_root, 'sample_app_rails_4/db/schema.rb')
-      config.model_dir   = File.join(app_root, 'sample_app_rails_4/app/models')
-      config.mock_dir    = mock_dir
-      config.logger      = UnitLogger
-    end
-
-    FileUtils.rm_rf mock_dir
-
-  end
-
-  subject{described_class.new}
-
-  describe 'new' do
-
-    before(:each) do
-      subject
-    end
-
-    it 'generates all mocks files' do
-      expect(File.exist? File.join(mock_dir, 'user_mock.rb')        ).to eq true
-      expect(File.exist? File.join(mock_dir, 'micropost_mock.rb')   ).to eq true
-      expect(File.exist? File.join(mock_dir, 'relationship_mock.rb')).to eq true
-    end
-
-  end
-
-end
-

data/spec/lib/active_mocker/loaded_mocks_spec.rb

@@ -1,167 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../', __FILE__)
-require 'active_mocker/loaded_mocks'
-
-describe ActiveMocker::LoadedMocks do
-
-  before(:each) do
-
-    class MockClass
-      def self.mocked_class
-        @@clear_called = false
-        @@delete_all_called = false
-        @@reload_all_called = false
-        'Object'
-      end
-
-      def self.clear_mock
-        @@clear_called = true
-      end
-
-      def self.delete_all
-        @@delete_all_called = true
-      end
-
-      def self.reload
-        @@reload_all_called = true
-      end
-    end
-
-    class MockClass2
-      def self.mocked_class
-        @@clear_called = false
-        @@delete_all_called = false
-        @@reload_all_called = false
-        'Object'
-      end
-
-      def self.clear_mock
-        @@clear_called = true
-      end
-
-      def self.delete_all
-        @@delete_all_called = true
-      end
-
-      def self.reload
-        @@reload_all_called = true
-      end
-
-    end
-  end
-
-  after(:each) do
-    described_class.send(:internal_clear)
-  end
-
-  describe '::class_name_to_mock' do
-
-    subject{ described_class.class_name_to_mock }
-
-    it 'returns key of mocked_class and a constant of the mock class' do
-      described_class.add MockClass
-      expect(subject).to eq({'Object' => MockClass})
-    end
-
-  end
-
-  describe '::clear_all' do
-
-    before do
-      ActiveMocker::LoadedMocks.add MockClass
-      ActiveMocker::LoadedMocks.add_subclass MockClass2
-      described_class.clear_all
-    end
-
-    it 'will call clear_mock on each loaded mock' do
-      expect(clear_mock_called?(MockClass)).to eq true
-      expect(clear_mock_called?(MockClass2)).to eq true
-    end
-
-    it 'will empty the sub classes' do
-      expect(ActiveMocker::LoadedMocks.subclasses.empty?).to eq true
-    end
-
-    def clear_mock_called?(mock)
-      return true if mock.class_variable_get(:@@clear_called)
-      return false
-    end
-
-  end
-
-  describe '::delete_all' do
-
-    it 'will call delete_all on each loaded mock' do
-
-      described_class.add MockClass
-      described_class.add_subclass MockClass2
-      described_class.delete_all
-      expect(delete_all_called?(MockClass)).to eq true
-      expect(delete_all_called?(MockClass2)).to eq true
-
-    end
-
-    def delete_all_called?(mock)
-      return true if mock.class_variable_get(:@@delete_all_called)
-      return false
-    end
-
-  end
-
-  describe '::mocks' do
-
-    it 'returns hash the key being a string and the value being the constant' do
-
-      described_class.add MockClass
-      described_class.add MockClass2
-      expect(described_class.mocks).to eq({"MockClass" => MockClass, "MockClass2" => MockClass2})
-
-    end
-
-  end
-
-  describe '::all' do
-
-    it 'returns hash the key being a string and the value being the constant' do
-
-      described_class.add MockClass
-      described_class.add MockClass2
-      expect(described_class.all).to eq({"MockClass" => MockClass, "MockClass2" => MockClass2})
-
-    end
-
-  end
-
-  describe '::undefine_all' do
-
-    # it 'will call delete_all on each loaded mock' do
-    #
-    #   described_class.add MockClass
-    #   described_class.add MockClass2
-    #
-    #   described_class.undefine_all
-    #   expect(Object.const_defined?('MockClass')).to eq false
-    #   expect(Object.const_defined?('MockClass2')).to eq false
-    #
-    # end
-
-  end
-
-  describe '::reload_all' do
-
-    it 'will call reload on each loaded mock' do
-      described_class.add MockClass
-      described_class.add_subclass MockClass2
-      described_class.reload_all
-      expect(reload_all_called?(MockClass)).to eq true
-      expect(reload_all_called?(MockClass2)).to eq true
-    end
-
-    def reload_all_called?(mock)
-      return true if mock.class_variable_get(:@@reload_all_called)
-      return false
-    end
-
-  end
-
-end