active_mocker 1.3.2 → 1.4.1

data/spec/lib/active_mocker/db_to_ruby_type_spec.rb

@@ -0,0 +1,124 @@
+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/loaded_mocks_spec.rb

@@ -0,0 +1,167 @@
+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

data/spec/lib/active_mocker/logger_spec.rb

@@ -0,0 +1,32 @@
+require 'rspec'
+$:.unshift File.expand_path('../../', __FILE__)
+require 'active_mocker/logger'
+
+describe ActiveMocker::Logger do
+
+  describe '::set' do
+
+    let(:logger){double()}
+
+    around do
+      described_class.class_variable_set(:@@logger, nil)
+    end
+
+    it 'set the logger to be used by the mock class' do
+      described_class.set(logger)
+      expect(described_class.class_variable_get(:@@logger)).to eq(logger)
+    end
+
+    it 'will pass any methods to the set logger' do
+      described_class.set(logger)
+      expect(logger).to receive(:info)
+      described_class.info
+    end
+
+    it 'will return nil if no logger is set' do
+      expect(described_class.any_method).to eq nil
+    end
+
+  end
+
+end

data/spec/lib/active_mocker/model_reader_spec.rb

@@ -1,5 +1,6 @@
 require 'rspec'
 $:.unshift File.expand_path('../../', __FILE__)
+require 'active_support/core_ext/hash/indifferent_access'
 require 'singleton'
 require 'logger'
 require 'active_mocker/logger'
@@ -17,7 +18,9 @@ describe ActiveMocker::ModelReader do
     ActiveMocker::Logger.set(UnitLogger)
   end
 
-  let(:subject){ described_class.new({model_dir: File.expand_path('../../', __FILE__)}).parse('model') }
+  let(:model_reader){ described_class.new({model_dir: File.expand_path('../../', __FILE__)}).parse('model') }
+
+  let(:subject){ model_reader}
 
   describe '#parse' do
 
@@ -61,64 +64,112 @@ describe ActiveMocker::ModelReader do
 
   end
 
-  describe '#relationships_types' do
-
-    it '#belongs_to' do
+  describe '#belongs_to' do
 
-      expect(subject.relationships_types.belongs_to).to eq([[:company]])
+    let(:subject){model_reader.belongs_to}
 
+    it 'name of association' do
+      expect(subject.first.name).to eq(:company)
     end
 
-    it '#has_many' do
-
-      expect(subject.relationships_types.has_many).to eq([[:users]])
-
+    it 'class_name override' do
+      expect(subject.first.class_name).to eq('PlanServiceCategory')
     end
 
-    it '#has_one' do
-
-      expect(subject.relationships_types.has_one).to eq([[:account]])
-
+    it 'infer class_name' do
+      expect(subject.last.class_name).to eq('Person')
     end
 
-    it '#has_and_belongs_to_many' do
+    it 'infer foreign key' do
+      expect(subject.last.foreign_key).to eq('person_id')
+    end
 
-      expect(subject.relationships_types.has_and_belongs_to_many).to eq([[:disclosures]])
+    it 'foreign key override' do
+      expect(subject.first.foreign_key).to eq('category_id')
+    end
 
+    it 'through' do
+      expect(subject.last.through).to eq('customer')
     end
 
   end
 
-  describe '#relationships' do
-
-    it 'returns an array of relations' do
+  describe '#has_one' do
 
-      expect(subject.relationships).to eq [:users, :account, :company, :disclosures]
+    let(:subject) { model_reader.has_one }
 
+    it 'name of association' do
+      expect(subject.first.name).to eq(:account)
     end
 
   end
 
-  describe '#collections' do
-
-    it 'returns an array of relations' do
+  describe '#has_many' do
 
-      expect(subject.collections).to eq [:disclosures, :users]
+    let(:subject) { model_reader.has_many }
 
+    it 'name of association' do
+      expect(subject.first.name).to eq(:users)
     end
 
   end
 
-  describe '#single_relationships' do
+  describe '#has_and_belongs_to_many' do
 
-    it 'returns an array of relations' do
-
-      expect(subject.single_relationships).to eq [:company, :account]
+    let(:subject) { model_reader.has_and_belongs_to_many }
 
+    it 'name of association' do
+      expect(subject.first.name).to eq(:disclosures)
     end
 
   end
 
+# TODO JoinTable
+#     class Assembly < ActiveRecord::Base
+#       has_and_belongs_to_many :parts
+#     end
+#
+#     class Part < ActiveRecord::Base
+#       has_and_belongs_to_many :assemblies
+#     end
+#     These need to be backed up by a migration to create the assemblies_parts table.This table should be created without a primary key:
+
+#     class CreateAssembliesPartsJoinTable < ActiveRecord::Migration
+#       def change
+#         create_table :assemblies_parts, id: false do |t|
+#           t.integer :assembly_id
+#           t.integer :part_id
+#         end
+#       end
+#     end
+
+#   TODO Polymorphic Associations
+#   A slightly more advanced twist on associations is the polymorphic association.With polymorphic associations, a model can belong to more than one other model, on a single association.For example, you might have a picture model that belongs to either an employee model or a product model.Here 's how this could be declared:
+#
+#     class Picture < ActiveRecord::Base
+#       belongs_to :imageable, polymorphic: true
+#     end
+#
+#     class Employee < ActiveRecord::Base
+#       has_many :pictures, as: :imageable
+#     end
+#
+#     class Product < ActiveRecord::Base
+#       has_many :pictures, as: :imageable
+#     end
+
+#     class CreatePictures < ActiveRecord::Migration
+#       def change
+#         create_table :pictures do |t|
+#           t.string :name
+#           t.integer :imageable_id
+#           t.string :imageable_type
+#           t.timestamps
+#         end
+#       end
+#     end
+
+
 
   context 'inject string_reader as file_reader' do
 
@@ -143,7 +194,7 @@ describe ActiveMocker::ModelReader do
     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(search.relationships_types.belongs_to.first.name).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