maestrano-connector-rails 0.4.4 → 1.0.0

data/spec/jobs/all_synchronizations_job_spec.rb

@@ -7,6 +7,11 @@ describe Maestrano::Connector::Rails::AllSynchronizationsJob do
 
   subject { Maestrano::Connector::Rails::AllSynchronizationsJob.perform_now() }
 
+  # before{
+  #   organization_not_active.update(encrypted_oauth_token: Maestrano::Connector::Rails::Organization.encrypt_oauth_token('123', key: 'This is a key that is 256 bits!!', iv: 'This iv is 12 bytes or longer'))
+  #   organization_to_process.update(encrypted_oauth_token: Maestrano::Connector::Rails::Organization.encrypt_oauth_token('123', key: 'This is a key that is 256 bits!!', iv: 'This iv is 12 bytes or longer'))
+  # }
+
   describe 'perform' do
     it 'does not calls sync entity' do
       expect(Maestrano::Connector::Rails::SynchronizationJob).to_not receive(:perform_later).with(organization_not_linked, anything)

data/spec/jobs/push_to_connec_job_spec.rb

@@ -6,9 +6,6 @@ describe Maestrano::Connector::Rails::PushToConnecJob do
   let(:entity_name2) { 'entity2' }
   before {
     class Entities::Entity1 < Maestrano::Connector::Rails::Entity
-      def map_to_connec(entity, organization)
-        entity
-      end
     end
     allow_any_instance_of(Entities::Entity1).to receive(:push_entities_to_connec)
     allow(Entities::Entity1).to receive(:external_entity_name).and_return('ext_entity1')
@@ -16,7 +13,7 @@ describe Maestrano::Connector::Rails::PushToConnecJob do
     end
     allow_any_instance_of(Entities::Entity2).to receive(:consolidate_and_map_data).and_return({})
     allow_any_instance_of(Entities::Entity2).to receive(:push_entities_to_connec)
-    allow(Entities::Entity2).to receive(:connec_entities_names).and_return(%w())
+    allow(Entities::Entity2).to receive(:connec_entities_names).and_return(['Connec name'])
     allow(Entities::Entity2).to receive(:external_entities_names).and_return(%w(Subs ll))
     module Entities::SubEntities end;
     class Entities::SubEntities::Sub < Maestrano::Connector::Rails::SubEntityBase
@@ -66,7 +63,7 @@ describe Maestrano::Connector::Rails::PushToConnecJob do
         before { organization.update(synchronized_entities: {:"#{entity_name1}" => false, :"#{entity_name2}" => true})}
 
         it 'calls consolidate and map data on the complex entity with the right arguments' do
-          expect_any_instance_of(Entities::Entity2).to receive(:consolidate_and_map_data).with({}, {"Subs"=>[entity21], "ll"=>[]}, organization, {})
+          expect_any_instance_of(Entities::Entity2).to receive(:consolidate_and_map_data).with({"Connec name" => []}, {"Subs"=>[entity21], "ll"=>[]})
           expect_any_instance_of(Entities::Entity2).to receive(:push_entities_to_connec)
           subject
         end
@@ -87,7 +84,7 @@ describe Maestrano::Connector::Rails::PushToConnecJob do
         before { organization.update(synchronized_entities: {:"#{entity_name1}" => true, :"#{entity_name2}" => false})}
 
         it 'calls consolidate_and_map_data on the non complex entity with the right arguments' do
-          expect_any_instance_of(Entities::Entity1).to receive(:consolidate_and_map_data).with([], [entity11, entity12], organization, {}).and_return({})
+          expect_any_instance_of(Entities::Entity1).to receive(:consolidate_and_map_data).with([], [entity11, entity12]).and_return({})
           expect_any_instance_of(Entities::Entity1).to receive(:push_entities_to_connec)
           subject
         end

data/spec/jobs/synchronization_job_spec.rb

@@ -69,29 +69,41 @@ describe Maestrano::Connector::Rails::SynchronizationJob do
 
       it { performes }
 
-      it 'calls sync entity on all the organization synchronized entities set to true' do
-        organization.synchronized_entities[organization.synchronized_entities.keys.first] = false
-        expect_any_instance_of(Maestrano::Connector::Rails::SynchronizationJob).to receive(:sync_entity).exactly(organization.synchronized_entities.count - 1).times
-
-        subject
+      context 'first sync' do
+        it 'does two half syncs' do
+          expect_any_instance_of(Maestrano::Connector::Rails::SynchronizationJob).to receive(:sync_entity).exactly(2 * organization.synchronized_entities.count).times
+          subject
+        end
       end
 
-      context 'with options' do
-        context 'with only_entities' do
-          let(:opts) { {only_entities: %w(people price)} }
+      context 'subsequent sync' do
+        let!(:old_sync) { create(:synchronization, partial: false, status: 'SUCCESS', organization: organization) }
 
-          it 'calls sync entity on the specified entities' do
-            expect_any_instance_of(Maestrano::Connector::Rails::SynchronizationJob).to receive(:sync_entity).twice
+        it 'calls sync entity on all the organization synchronized entities set to true' do
+          organization.synchronized_entities[organization.synchronized_entities.keys.first] = false
+          expect_any_instance_of(Maestrano::Connector::Rails::SynchronizationJob).to receive(:sync_entity).exactly(organization.synchronized_entities.count - 1).times
 
-            subject
-          end
+          subject
+        end
+
+        context 'with options' do
+          context 'with only_entities' do
+            let(:opts) { {only_entities: %w(people price)} }
 
-          it 'set the current syncrhonization as partial' do
-            subject
-            expect(Maestrano::Connector::Rails::Synchronization.last.partial).to be(true)
+            it 'calls sync entity on the specified entities' do
+              expect_any_instance_of(Maestrano::Connector::Rails::SynchronizationJob).to receive(:sync_entity).twice
+
+              subject
+            end
+
+            it 'set the current syncrhonization as partial' do
+              subject
+              expect(Maestrano::Connector::Rails::Synchronization.last.partial).to be(true)
+            end
           end
         end
       end
+
     end
   end
 
@@ -107,7 +119,7 @@ describe Maestrano::Connector::Rails::SynchronizationJob do
       it 'calls the seven methods' do
         expect_any_instance_of(Entities::Person).to receive(:before_sync)
         expect_any_instance_of(Entities::Person).to receive(:get_connec_entities)
-        expect_any_instance_of(Entities::Person).to receive(:get_external_entities)
+        expect_any_instance_of(Entities::Person).to receive(:get_external_entities_wrapper)
         expect_any_instance_of(Entities::Person).to receive(:consolidate_and_map_data).and_return({})
         expect_any_instance_of(Entities::Person).to receive(:push_entities_to_external)
         expect_any_instance_of(Entities::Person).to receive(:push_entities_to_connec)
@@ -125,7 +137,7 @@ describe Maestrano::Connector::Rails::SynchronizationJob do
       it 'calls the seven methods' do
         expect_any_instance_of(Entities::SomeStuff).to receive(:before_sync)
         expect_any_instance_of(Entities::SomeStuff).to receive(:get_connec_entities)
-        expect_any_instance_of(Entities::SomeStuff).to receive(:get_external_entities)
+        expect_any_instance_of(Entities::SomeStuff).to receive(:get_external_entities_wrapper)
         expect_any_instance_of(Entities::SomeStuff).to receive(:consolidate_and_map_data).and_return({})
         expect_any_instance_of(Entities::SomeStuff).to receive(:push_entities_to_external)
         expect_any_instance_of(Entities::SomeStuff).to receive(:push_entities_to_connec)

data/spec/models/complex_entity_spec.rb

@@ -2,496 +2,341 @@ require 'spec_helper'
 
 describe Maestrano::Connector::Rails::ComplexEntity do
 
-  subject { Maestrano::Connector::Rails::ComplexEntity.new }
-
-  #Complex specific methods
-  describe 'complex specific methods' do
-    describe 'connec_entities_names' do
-      it { expect{ subject.class.connec_entities_names }.to raise_error('Not implemented') }
-    end
-    describe 'external_entities_names' do
-      it { expect{ subject.class.external_entities_names }.to raise_error('Not implemented') }
-    end
-    describe 'connec_model_to_external_model' do
-      it { expect{ subject.connec_model_to_external_model({}, nil) }.to raise_error('Not implemented') }
-    end
-    describe 'external_model_to_connec_model' do
-      it { expect{ subject.external_model_to_connec_model({}, nil) }.to raise_error('Not implemented') }
-    end
-  end
-
-  describe 'general methods' do
-    let(:organization) { create(:organization) }
-
-    describe 'map_to_external_with_idmap' do
-      let(:id) { '322j-bbfg4' }
-      let(:entity) { {'id' => id, 'name' => 'John', 'updated_at' => 2.day.ago} }
-      let(:mapped_entity) { {'first_name' => 'John'} }
-      let(:connec_name) { 'Connec_name' }
-      let(:external_name) { 'External_name' }
-      let(:sub_instance) { Maestrano::Connector::Rails::SubEntityBase.new }
-      let(:human_name) { 'ET' }
-      before {
-        allow(sub_instance.class).to receive(:external?).and_return(false)
-        allow(sub_instance.class).to receive(:entity_name).and_return(connec_name)
-        allow(sub_instance).to receive(:map_to).and_return(mapped_entity)
-        allow(sub_instance.class).to receive(:object_name_from_connec_entity_hash).and_return(human_name)
-      }
-
-      context 'when entity has no idmap' do
-        it 'creates one' do
-          expect {
-            subject.map_to_external_with_idmap(entity, organization, external_name, sub_instance)
-          }.to change{ Maestrano::Connector::Rails::IdMap.count }.by(1)
-        end
+  describe 'class methods' do
+    subject { Maestrano::Connector::Rails::ComplexEntity }
+    
+      describe 'connec_entities_names' do
+        it { expect{ subject.connec_entities_names }.to raise_error('Not implemented') }
       end
-      it 'returns the mapped entity with its idmap' do
-        expect(subject.map_to_external_with_idmap(entity, organization, external_name, sub_instance)).to eql({entity: mapped_entity, idmap: Maestrano::Connector::Rails::IdMap.last})
+      describe 'external_entities_names' do
+        it { expect{ subject.external_entities_names }.to raise_error('Not implemented') }
       end
+  end
 
-      context 'when entity has an idmap without last_push_to_external' do
-        let!(:idmap) { create(:idmap, organization: organization, connec_id: id, connec_entity: connec_name.downcase, last_push_to_external: nil, external_entity: external_name.downcase) }
-
-        it 'returns the mapped entity with its idmap' do
-          expect(subject.map_to_external_with_idmap(entity, organization, external_name, sub_instance)).to eql({entity: mapped_entity, idmap: idmap})
-        end
-      end
-
-      context 'when entity has an idmap with an older last_push_to_external' do
-        let!(:idmap) { create(:idmap, organization: organization, connec_id: id, connec_entity: connec_name.downcase, last_push_to_external: 1.year.ago, external_entity: external_name.downcase) }
-
-        it 'returns the mapped entity with its idmap' do
-          expect(subject.map_to_external_with_idmap(entity, organization, external_name, sub_instance)).to eql({entity: mapped_entity, idmap: idmap})
-        end
-      end
-
-      context 'when entity has an idmap with a more recent last_push_to_external' do
-        let!(:idmap) { create(:idmap, organization: organization, connec_id: id, connec_entity: connec_name.downcase, last_push_to_external: 1.second.ago, external_entity: external_name.downcase) }
-
-        it 'discards the entity' do
-          expect(subject.map_to_external_with_idmap(entity, organization, external_name, sub_instance)).to be_nil
-        end
+  describe 'instance methods' do
+    let!(:organization) { create(:organization, uid: 'cld-123') }
+    let!(:connec_client) { Maestrano::Connec::Client[organization.tenant].new(organization.uid) }
+    let!(:external_client) { Object.new }
+    let(:opts) { {} }
+    subject { Maestrano::Connector::Rails::ComplexEntity.new(organization, connec_client, external_client, opts) }
+
+    #Complex specific methods
+    describe 'complex specific methods' do
+      describe 'connec_model_to_external_model' do
+        it { expect{ subject.connec_model_to_external_model({}) }.to raise_error('Not implemented') }
       end
-
-      context 'when entity has an idmap with to_external set to false' do
-        let!(:idmap) { create(:idmap, organization: organization, connec_id: id, connec_entity: connec_name.downcase, to_external: false, external_entity: external_name.downcase) }
-
-        it 'discards the entity' do
-          expect(subject.map_to_external_with_idmap(entity, organization, external_name, sub_instance)).to be_nil
-        end
-      end
-
-      context 'when entity has an idmap with external_inactive set to true' do
-        let!(:idmap) { create(:idmap, organization: organization, connec_id: id, connec_entity: connec_name.downcase, external_inactive: true, external_entity: external_name.downcase) }
-
-        it 'discards the entity' do
-          expect(subject.map_to_external_with_idmap(entity, organization, external_name, sub_instance)).to be_nil
-        end
+      describe 'external_model_to_connec_model' do
+        it { expect{ subject.external_model_to_connec_model({}) }.to raise_error('Not implemented') }
       end
     end
 
     describe 'filter_connec_entities' do
-      it { expect(subject.filter_connec_entities({'lead' => [{a: 2}]}, organization)).to eql({'lead' => [{a: 2}]}) }
-    end
-  end
-
-  describe 'methods with sub complex entities' do
-    before {
-      module Entities::SubEntities
-      end
-      class Entities::SubEntities::ScE1 < Maestrano::Connector::Rails::SubEntityBase
-      end
-      class Entities::SubEntities::ScE2 < Maestrano::Connector::Rails::SubEntityBase
-      end
-    }
-
-    describe 'get_connec_entities' do
-      before {
-        allow(subject.class).to receive(:connec_entities_names).and_return(%w(sc_e1 ScE2))
-      }
-
-      it 'calls get_connec_entities on each connec sub complex entities' do
-        expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_connec_entities).with(nil, nil, nil, {opts: true})
-        expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_connec_entities).with(nil, nil, nil, {opts: true})
-        subject.get_connec_entities(nil, nil, nil, {opts: true})
-      end
-
-      let(:arr1) { [{'name' => 'Water'}, {'name' => 'Sugar'}] }
-      let(:arr2) { [{'price' => 92}, {'price' => 300}] }
-      it 'returns an hash of the connec_entities keyed by connec_entity_name' do
-        allow_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_connec_entities).and_return(arr1)
-        allow_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_connec_entities).and_return(arr2)
-        expect(subject.get_connec_entities(nil, nil, nil, {opts: true})).to eql({'sc_e1' => arr1, 'ScE2' => arr2})
-      end
+      it { expect(subject.filter_connec_entities({'lead' => [{a: 2}]})).to eql({'lead' => [{a: 2}]}) }
     end
 
-    describe 'get_external_entities' do
+    describe 'methods with sub complex entities' do
       before {
-        allow(subject.class).to receive(:external_entities_names).and_return(%w(sc_e1 ScE2))
+        module Entities::SubEntities
+        end
+        class Entities::SubEntities::ScE1 < Maestrano::Connector::Rails::SubEntityBase
+        end
+        class Entities::SubEntities::ScE2 < Maestrano::Connector::Rails::SubEntityBase
+        end
       }
 
-      it 'calls get_external_entities on each connec sub complex entities' do
-        expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_external_entities).with(nil, nil, nil, {opts: true})
-        expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_external_entities).with(nil, nil, nil, {opts: true})
-        subject.get_external_entities(nil, nil, nil, {opts: true})
-      end
-
-      let(:arr1) { [{'name' => 'Water'}, {'name' => 'Sugar'}] }
-      let(:arr2) { [{'price' => 92}, {'price' => 300}] }
-      it 'returns an hash of the external_entities keyed by external_entity_name' do
-        allow_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_external_entities).and_return(arr1)
-        allow_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_external_entities).and_return(arr2)
-        expect(subject.get_external_entities(nil, nil, nil, {opts: true})).to eql({'sc_e1' => arr1, 'ScE2' => arr2})
-      end
-    end
-
-
-    describe 'consolidate_and_map_data' do
-      let(:opt) { {opt: true} }
-      let(:organization) { create(:organization) }
+      describe 'get_connec_entities' do
+        before {
+          allow(subject.class).to receive(:connec_entities_names).and_return(%w(sc_e1 ScE2))
+        }
 
-      it 'calls external_model_to_connec_model' do
-        allow(subject).to receive(:connec_model_to_external_model).and_return({})
-        expect(subject).to receive(:external_model_to_connec_model).with({a: {}}, organization).and_return({})
-        subject.consolidate_and_map_data({}, {a: {}}, organization, opt)
-      end
+        it 'calls get_connec_entities on each connec sub complex entities' do
+          expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_connec_entities).with(nil)
+          expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_connec_entities).with(nil)
+          subject.get_connec_entities(nil)
+        end
 
-      it 'calls connec_model_to_external_model' do
-        allow(subject).to receive(:external_model_to_connec_model).and_return({})
-        expect(subject).to receive(:connec_model_to_external_model).with({a: {}}, organization).and_return({})
-        subject.consolidate_and_map_data({a: {}}, {}, organization, opt)
+        let(:arr1) { [{'name' => 'Water'}, {'name' => 'Sugar'}] }
+        let(:arr2) { [{'price' => 92}, {'price' => 300}] }
+        it 'returns an hash of the connec_entities keyed by connec_entity_name' do
+          allow_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_connec_entities).and_return(arr1)
+          allow_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_connec_entities).and_return(arr2)
+          expect(subject.get_connec_entities(nil)).to eql({'sc_e1' => arr1, 'ScE2' => arr2})
+        end
       end
 
-      describe 'connec_entities treatment' do
-        #hash as it should be after connec_model_to_external_model
-        let(:connec_hash) {
-          {
-            'sc_e1' => {'ext1' => [{'name' => 'John'}, {'name' => 'Jane'}]},
-            'ScE2' => {'ext1' => [{'name' => 'Robert'}], 'ext2' => [{'price' => 45}]}
-          }
-        }
-        before{
-          allow(subject).to receive(:external_model_to_connec_model).and_return({})
-          allow(subject).to receive(:connec_model_to_external_model).and_return(connec_hash)
+      describe 'get_external_entities' do
+        before {
+          allow(subject.class).to receive(:external_entities_names).and_return(%w(sc_e1 ScE2))
         }
 
-        it 'calls map_to_external_with_idmap on each entity' do
-          expect(subject).to receive(:map_to_external_with_idmap).exactly(4).times
-          subject.consolidate_and_map_data({}, {}, organization, opt)
+        it 'calls get_external_entities on each connec sub complex entities' do
+          expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_external_entities_wrapper).with(nil)
+          expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_external_entities_wrapper).with(nil)
+          subject.get_external_entities_wrapper(nil)
         end
-      end
 
-      describe 'external_entities treatment' do
-        #hash as it should be after external_model_to_connec_model
-        let(:id1) { '5678ttd3' }
-        let(:id2) { '5678taa3' }
-        let(:entity1) { {'id' => id1, 'name' => 'Robert'} }
-        let(:entity2) { {'id' => id2, 'price' => 45} }
-        let(:mapped_entity1) { {'first_name' => 'Robert'} }
-        let(:mapped_entity2) { {'net_price' => 45} }
-        let(:external_hash) {
-          {
-            'sc_e1' => {'Connec1' => [entity1]},
-            'ScE2' => {'Connec1' => [entity1], 'connec2' => [entity2]}
-          }
-        }
-        let(:connec_hash) { {} }
-        let(:human_name) { 'Jabba' }
-        before{
-          allow(subject).to receive(:external_model_to_connec_model).and_return(external_hash)
-          allow(subject).to receive(:connec_model_to_external_model).and_return(connec_hash)
-          allow(Entities::SubEntities::ScE1).to receive(:external?).and_return(true)
-          allow(Entities::SubEntities::ScE1).to receive(:entity_name).and_return('sc_e1')
-          allow(Entities::SubEntities::ScE1).to receive(:id_from_external_entity_hash).with(entity1).and_return(id1)
-          allow(Entities::SubEntities::ScE1).to receive(:last_update_date_from_external_entity_hash).and_return(1.minute.ago)
-          allow_any_instance_of(Entities::SubEntities::ScE1).to receive(:map_to).with('Connec1', entity1, organization).and_return(mapped_entity1)
-          allow(Entities::SubEntities::ScE2).to receive(:external?).and_return(true)
-          allow(Entities::SubEntities::ScE2).to receive(:entity_name).and_return('Sce2')
-          allow(Entities::SubEntities::ScE2).to receive(:id_from_external_entity_hash).with(entity1).and_return(id1)
-          allow(Entities::SubEntities::ScE2).to receive(:id_from_external_entity_hash).with(entity2).and_return(id2)
-          allow(Entities::SubEntities::ScE2).to receive(:last_update_date_from_external_entity_hash).and_return(1.minute.ago)
-          allow_any_instance_of(Entities::SubEntities::ScE2).to receive(:map_to).with('Connec1', entity1, organization).and_return(mapped_entity1)
-          allow_any_instance_of(Entities::SubEntities::ScE2).to receive(:map_to).with('connec2', entity2, organization).and_return(mapped_entity2)
-          allow(Entities::SubEntities::ScE1).to receive(:object_name_from_external_entity_hash).and_return(human_name)
-          allow(Entities::SubEntities::ScE2).to receive(:object_name_from_external_entity_hash).and_return(human_name)
-        }
+        let(:arr1) { [{'name' => 'Water'}, {'name' => 'Sugar'}] }
+        let(:arr2) { [{'price' => 92}, {'price' => 300}] }
+        it 'returns an hash of the external_entities keyed by external_entity_name' do
+          allow_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_external_entities_wrapper).and_return(arr1)
+          allow_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_external_entities_wrapper).and_return(arr2)
+          expect(subject.get_external_entities_wrapper(nil)).to eql({'sc_e1' => arr1, 'ScE2' => arr2})
+        end
+      end
 
-        context 'when entities have no idmaps' do
 
-          it 'creates an idmap for each entity' do
-            expect{
-              subject.consolidate_and_map_data({}, {}, organization, opt)
-            }.to change{ Maestrano::Connector::Rails::IdMap.count }.by(3)
+      describe 'consolidate and map methods' do
+        let(:human_name) { 'Jabba' }
+        let(:mapped_entity) { {mapped: 'entity'} }
+        let(:date) { 2.hour.ago }
+
+        describe 'consolidate_and_map_data' do
+            before{
+              allow(subject).to receive(:external_model_to_connec_model).and_return({})
+              allow(subject).to receive(:connec_model_to_external_model).and_return({})
+            }
+
+          it 'calls external_model_to_connec_model' do
+            expect(subject).to receive(:external_model_to_connec_model).with({a: {}}).and_return({})
+            subject.consolidate_and_map_data({}, {a: {}})
           end
 
-          it 'returns the entity with their new idmaps' do
-            mapped_entities = subject.consolidate_and_map_data({}, external_hash, organization, opt)
-            expect(mapped_entities).to eql(external_entities: {
-              'sc_e1' => {'Connec1' => [{entity: mapped_entity1, idmap: Maestrano::Connector::Rails::IdMap.first}]},
-              'ScE2' => {
-                'Connec1' => [{entity: mapped_entity1, idmap: Maestrano::Connector::Rails::IdMap.second}],
-                'connec2' => [{entity: mapped_entity2, idmap: Maestrano::Connector::Rails::IdMap.last}],
-              }
-            },
-            connec_entities: {})
+          it 'calls connec_model_to_external_model' do
+            expect(subject).to receive(:connec_model_to_external_model).with({a: {}}).and_return({})
+            subject.consolidate_and_map_data({a: {}}, {})
           end
-        end
 
-        context 'when entities have idmaps with to_connec set to false' do
-          let!(:idmap1) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sc_e1', connec_entity: 'connec1', to_connec: false) }
-          let!(:idmap21) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sce2', connec_entity: 'connec1', to_connec: false) }
-          let!(:idmap22) { create(:idmap, organization: organization, external_id: id2, external_entity: 'sce2', connec_entity: 'connec2', to_connec: false) }
-
-          it 'discards the entities' do
-            mapped_entities = subject.consolidate_and_map_data({}, external_hash, organization, opt)
-            expect(mapped_entities).to eql(external_entities: {
-              'sc_e1' => {'Connec1' => []},
-              'ScE2' => {
-                'Connec1' => [],
-                'connec2' => [],
-              }
-            },
-            connec_entities: {})
+          it 'calls the consolidation on both connec and external and returns an hash with the results' do
+            expect(subject).to receive(:consolidate_and_map_connec_entities).with({}, {}).and_return({connec_result: 1})
+            expect(subject).to receive(:consolidate_and_map_external_entities).with({}).and_return({ext_result: 1})
+            expect(subject.consolidate_and_map_data({}, {})).to eql({connec_entities: {connec_result: 1}, external_entities: {ext_result: 1}})
           end
         end
 
-        describe 'external_inactive flagging' do
+        describe 'consolidate_and_map_external_entities' do
+          let(:entity) { {'id' => id, 'name' => 'Jane'} }
+          let(:id) { 'id' }
+          let(:external_name) { 'sc_e1' }
+          let(:connec_name) { 'connec1' }
+          let(:modeled_external_entities) { {external_name => {connec_name => [entity]}} }
+          before {
+            allow(Entities::SubEntities::ScE1).to receive(:external?).and_return(true)
+            allow(Entities::SubEntities::ScE1).to receive(:entity_name).and_return(external_name)
+            allow(Entities::SubEntities::ScE1).to receive(:id_from_external_entity_hash).and_return(id)
+            allow(Entities::SubEntities::ScE1).to receive(:object_name_from_external_entity_hash).and_return(human_name)
+            allow(Entities::SubEntities::ScE1).to receive(:last_update_date_from_external_entity_hash).and_return(date)
+            allow_any_instance_of(Entities::SubEntities::ScE1).to receive(:map_to).and_return(mapped_entity)
+          }
 
-          context 'idmaps external_inactive set to true' do
-            let!(:idmap1) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sc_e1', connec_entity: 'connec1', external_inactive: true) }
-            let!(:idmap21) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sce2', connec_entity: 'connec1', external_inactive: true) }
-            let!(:idmap22) { create(:idmap, organization: organization, external_id: id2, external_entity: 'sce2', connec_entity: 'connec2', external_inactive: true) }
+          context 'when idmap exists' do
+            let!(:idmap) { create(:idmap, organization: organization, connec_entity: connec_name.downcase, external_entity: external_name.downcase, external_id: id) }
 
-            context 'entities inactive' do
-              before {
-                allow(Entities::SubEntities::ScE2).to receive(:inactive_from_external_entity_hash?).and_return(true)
-                allow(Entities::SubEntities::ScE1).to receive(:inactive_from_external_entity_hash?).and_return(true)
-              }
+            it 'does not create one' do
+              expect{
+                subject.consolidate_and_map_external_entities(modeled_external_entities)
+              }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
+            end
 
-              it 'discards the entities' do
-                expect(subject.consolidate_and_map_data({}, external_hash, organization, opt)).to eql(external_entities: {
-                  'sc_e1' => {'Connec1' => []},
-                  'ScE2' => {
-                    'Connec1' => [],
-                    'connec2' => [],
-                  }
-                },
-                connec_entities: {})
+            it 'returns the mapped entity with the idmap' do
+              expect(subject.consolidate_and_map_external_entities(modeled_external_entities)).to eql({external_name => {connec_name => [{entity: mapped_entity, idmap: idmap}]}})
+            end
+
+            context 'when to_connec is false' do
+              before { idmap.update(to_connec: false) }
+
+              it 'discards the entity' do
+                expect(subject.consolidate_and_map_external_entities(modeled_external_entities)).to eql({external_name => {connec_name => []}})
               end
             end
 
-            context 'entities active' do
+            context 'when entity is inactive' do
               before {
-                allow(Entities::SubEntities::ScE2).to receive(:inactive_from_external_entity_hash?).and_return(false)
-                allow(Entities::SubEntities::ScE1).to receive(:inactive_from_external_entity_hash?).and_return(false)
-                [idmap1, idmap21, idmap22].each{|i| i.update(last_push_to_connec: 1.second.ago)} #Used only to simplify specing
+                allow(Entities::SubEntities::ScE1).to receive(:inactive_from_external_entity_hash?).and_return(true)
               }
 
+              it 'discards the entity' do
+                expect(subject.consolidate_and_map_external_entities(modeled_external_entities)).to eql({external_name => {connec_name => []}})
+              end
+
               it 'updates the idmaps' do
-                subject.consolidate_and_map_data({}, external_hash, organization, opt)
-                expect(idmap1.reload.external_inactive).to be false
-                expect(idmap21.reload.external_inactive).to be false
-                expect(idmap22.reload.external_inactive).to be false
-              end 
+                subject.consolidate_and_map_external_entities(modeled_external_entities)
+                expect(idmap.reload.external_inactive).to be true
+              end
             end
-          end
 
-          context 'idmaps external_inactive set to false' do
-            let!(:idmap1) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sc_e1', connec_entity: 'connec1', external_inactive: false) }
-            let!(:idmap21) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sce2', connec_entity: 'connec1', external_inactive: false) }
-            let!(:idmap22) { create(:idmap, organization: organization, external_id: id2, external_entity: 'sce2', connec_entity: 'connec2', external_inactive: false) }
+            context 'when last_push_to_connec is recent' do
+              before { idmap.update(last_push_to_connec: 2.second.ago) }
 
-            context 'entities inactive' do
-              before {
-                allow(Entities::SubEntities::ScE2).to receive(:inactive_from_external_entity_hash?).and_return(true)
-                allow(Entities::SubEntities::ScE1).to receive(:inactive_from_external_entity_hash?).and_return(true)
-              }
-
-              it 'discards the entities and updates the idmaps' do
-                expect(subject.consolidate_and_map_data({}, external_hash, organization, opt)).to eql(external_entities: {
-                  'sc_e1' => {'Connec1' => []},
-                  'ScE2' => {
-                    'Connec1' => [],
-                    'connec2' => [],
-                  }
-                },
-                connec_entities: {})
-                expect(idmap1.reload.external_inactive).to be true
-                expect(idmap21.reload.external_inactive).to be true
-                expect(idmap22.reload.external_inactive).to be true
+              it 'discards the entity' do
+                expect(subject.consolidate_and_map_external_entities(modeled_external_entities)).to eql({external_name => {connec_name => []}})
               end
             end
-          end
-        end
 
-        context 'when entities have idmaps with more recent last_push_to_connec' do
-          let!(:idmap1) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sc_e1', connec_entity: 'connec1', last_push_to_connec: 1.second.ago) }
-          let!(:idmap21) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sce2', connec_entity: 'connec1', last_push_to_connec: 1.second.ago) }
-          let!(:idmap22) { create(:idmap, organization: organization, external_id: id2, external_entity: 'sce2', connec_entity: 'connec2', last_push_to_connec: 1.second.ago) }
-
-          it 'discards the entities' do
-            mapped_entities = subject.consolidate_and_map_data({}, external_hash, organization, opt)
-            expect(mapped_entities).to eql(external_entities: {
-              'sc_e1' => {'Connec1' => []},
-              'ScE2' => {
-                'Connec1' => [],
-                'connec2' => [],
-              }
-            },
-            connec_entities: {})
           end
         end
 
-        context 'when entities have idmaps with older last_push_to_connec' do
+        describe 'consolidate_and_map_connec_entities' do
+          let(:id) { 'external-unfolded-id' }
+          let(:connec_id) { 'connec-id' }
+          let(:entity) { {'id' => id, 'name' => 'John', 'updated_at' => date} }
+          let(:modeled_connec_entities) { {connec_name => {external_name => [entity]}} }
+          let(:modeled_external_entities) { {} }
+          let(:connec_name) { 'sc_e1' }
+          let(:external_name) { 'ext1' }
           before{
-            class Entities::SubEntities::Connec1 < Maestrano::Connector::Rails::SubEntityBase
-            end
-            class Entities::SubEntities::Connec2 < Maestrano::Connector::Rails::SubEntityBase
-            end
-            allow_any_instance_of(Entities::SubEntities::Connec1).to receive(:map_to).and_return({'name' => 'Jacob'})
-            allow(Entities::SubEntities::Connec1).to receive(:external?).and_return(false)
-            allow(Entities::SubEntities::Connec1).to receive(:entity_name).and_return('Connec1')
-            allow(Entities::SubEntities::Connec1).to receive(:object_name_from_connec_entity_hash).and_return('human name')
+            allow(Entities::SubEntities::ScE1).to receive(:external?).and_return(false)
+            allow(Entities::SubEntities::ScE1).to receive(:entity_name).and_return(connec_name)
+            allow_any_instance_of(Entities::SubEntities::ScE1).to receive(:map_to).with(external_name, entity).and_return(mapped_entity)
+            allow(Entities::SubEntities::ScE1).to receive(:object_name_from_connec_entity_hash).and_return(human_name)
+            allow(Maestrano::Connector::Rails::ConnecHelper).to receive(:unfold_references).and_return(entity.merge(__connec_id: connec_id))
           }
-          let(:connec_id1) { '67ttf-5rr4d' }
-          let!(:idmap1) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sc_e1', connec_entity: 'connec1', last_push_to_connec: 1.year.ago, connec_id: connec_id1) }
-          let!(:idmap21) { create(:idmap, organization: organization, external_id: id1, external_entity: 'sce2', connec_entity: 'connec1', last_push_to_connec: 1.year.ago) }
-          let!(:idmap22) { create(:idmap, organization: organization, external_id: id2, external_entity: 'sce2', connec_entity: 'connec2', last_push_to_connec: 1.year.ago) }
-          let(:connec_hash) { {'Connec1' => {'sc_e1' => [{'id' => connec_id1, 'first_name' => 'Jacob', 'updated_at' => 1.hour.ago}]}, 'connec2' => {'sc_e1' => [], 'ScE2' => []}} }
-
-          context 'without conflict' do
-            it 'returns the entity with their idmaps' do
-              subject.consolidate_and_map_data({'Connec1' => []}, {'sc_e1' => []}, organization, opt)
-              expect(external_hash).to eql({
-                'sc_e1' => {'Connec1' => [{entity: mapped_entity1, idmap: idmap1}]},
-                'ScE2' => {
-                  'Connec1' => [{entity: mapped_entity1, idmap: idmap21}],
-                  'connec2' => [{entity: mapped_entity2, idmap: idmap22}],
-                }
-              })
+
+          context 'when idmaps do not exist' do
+            it 'creates the idmaps with a name and returns the mapped entities with their idmaps' do
+              expect{
+                expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, {})).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: Maestrano::Connector::Rails::IdMap.first}]}})
+              }.to change{ Maestrano::Connector::Rails::IdMap.count }.by(1)
+              expect(Maestrano::Connector::Rails::IdMap.last.name).to eql(human_name)
             end
           end
 
-          context 'with conflict' do
-            context 'with option connec_preemption' do
-              context 'set to true' do
-                let(:opt) { {connec_preemption: true} }
-
-                it 'keeps the connec entities' do
-                  mapped_entities = subject.consolidate_and_map_data({'Connec1' => []}, {'sc_e1' => []}, organization, opt)
-                  expect(mapped_entities[:connec_entities]).to eq({'Connec1' => {'sc_e1' => [{entity: {'name' => 'Jacob'}, idmap: idmap1}]}, 'connec2' => {'sc_e1' => [], 'ScE2' => []}})
-                  expect(mapped_entities[:external_entities]).to eql({
-                    'sc_e1' => {'Connec1' => []},
-                    'ScE2' => {
-                      'Connec1' => [{entity: mapped_entity1, idmap: idmap21}],
-                      'connec2' => [{entity: mapped_entity2, idmap: idmap22}],
-                    }
-                  })
-                end
+          context 'when idmap exists' do
+            let!(:idmap1) { create(:idmap, organization: organization, connec_entity: connec_name.downcase, external_entity: external_name.downcase, external_id: id, connec_id: connec_id) }
+
+            it 'does not create an idmap' do
+              expect{
+                subject.consolidate_and_map_connec_entities(modeled_connec_entities, {})
+              }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
+            end
+
+            it 'returns the entity with its idmap' do
+              expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, {})).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: idmap1}]}})
+            end
+
+            context 'when external inactive' do
+              before { idmap1.update(external_inactive: true) }
+              it 'discards the entity' do
+                expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, {})).to eql({connec_name => {external_name => []}})
               end
+            end
 
-              context 'set to false' do
-                let(:opt) { {connec_preemption: false} }
-
-                it 'keeps the external entities' do
-                  mapped_entities = subject.consolidate_and_map_data({'Connec1' => []}, {'sc_e1' => []}, organization, opt)
-                  expect(mapped_entities[:connec_entities]).to eq({'Connec1' => {'sc_e1' => []}, 'connec2' => {'sc_e1' => [], 'ScE2' => []}})
-                  expect(mapped_entities[:external_entities]).to eql({
-                    'sc_e1' => {'Connec1' => [{entity: mapped_entity1, idmap: idmap1}]},
-                    'ScE2' => {
-                      'Connec1' => [{entity: mapped_entity1, idmap: idmap21}],
-                      'connec2' => [{entity: mapped_entity2, idmap: idmap22}],
-                    }
-                  })
-                end
+            context 'when to external flag is false' do
+              before { idmap1.update(to_external: false) }
+              it 'discards the entity' do
+                expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, {})).to eql({connec_name => {external_name => []}})
               end
             end
 
-            context 'without option' do
-              context 'with a more recently updated external entity' do
-                it 'keeps the external entity' do
-                  mapped_entities = subject.consolidate_and_map_data({'Connec1' => []}, {'sc_e1' => []}, organization, opt)
-                  expect(mapped_entities[:connec_entities]).to eq({'Connec1' => {'sc_e1' => []}, 'connec2' => {'sc_e1' => [], 'ScE2' => []}})
-                  expect(mapped_entities[:external_entities]).to eql({
-                    'sc_e1' => {'Connec1' => [{entity: mapped_entity1, idmap: idmap1}]},
-                    'ScE2' => {
-                      'Connec1' => [{entity: mapped_entity1, idmap: idmap21}],
-                      'connec2' => [{entity: mapped_entity2, idmap: idmap22}],
-                    }
-                  })
+            context 'when last_push_to_external is recent' do
+              before { idmap1.update(last_push_to_external: 2.second.ago) }
+              it 'discards the entity' do
+                expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, {})).to eql({connec_name => {external_name => []}})
+              end
+            end
+
+            context 'when conflict' do
+              let(:external_entity_1) { {'id' => id} }
+              let(:modeled_external_entities) { {external_name => {connec_name => [external_entity_1]}} }
+              before {
+                allow(Entities::SubEntities::ScE1).to receive(:id_from_external_entity_hash).and_return(id)
+              }
+
+              context 'with opts' do
+                context 'with connec preemption false' do
+                  it 'discards the entity and keep the external one' do
+                    subject.instance_variable_set(:@opts, {connec_preemption: false})
+                    expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, modeled_external_entities)).to eql({connec_name => {external_name => []}})
+                    expect(modeled_external_entities[external_name][connec_name]).to_not be_empty
+                  end
+                end
+
+                context 'with connec preemption true' do
+                  it 'keeps the entity and discards the external one' do
+                    subject.instance_variable_set(:@opts, {connec_preemption: true})
+                    expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, modeled_external_entities)).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: Maestrano::Connector::Rails::IdMap.first}]}})
+                    expect(modeled_external_entities[external_name][connec_name]).to be_empty
+                  end
                 end
               end
 
-              context 'with a more recently updated connec entity' do
-                let(:connec_hash) { {'Connec1' => {'sc_e1' => [{'id' => connec_id1, 'first_name' => 'Jacob', 'updated_at' => 1.second.ago}]}, 'connec2' => {'sc_e1' => [], 'ScE2' => []}} }
-
-                it 'keeps the connec entities' do
-                  mapped_entities = subject.consolidate_and_map_data({'Connec1' => []}, {'sc_e1' => []}, organization, opt)
-                  expect(mapped_entities[:connec_entities]).to eq({'Connec1' => {'sc_e1' => [{entity: {'name' => 'Jacob'}, idmap: idmap1}]}, 'connec2' => {'sc_e1' => [], 'ScE2' => []}})
-                  expect(mapped_entities[:external_entities]).to eql({
-                    'sc_e1' => {'Connec1' => []},
-                    'ScE2' => {
-                      'Connec1' => [{entity: mapped_entity1, idmap: idmap21}],
-                      'connec2' => [{entity: mapped_entity2, idmap: idmap22}],
-                    }
-                  })
+              context 'without opts' do
+                before {
+                  allow(Entities::SubEntities::ScE1).to receive(:last_update_date_from_external_entity_hash).and_return(external_date)
+                }
+
+                context 'with connec one more recent' do
+                  let(:external_date) { 1.year.ago } 
+                  let(:date) { 1.day.ago } 
+
+                  it 'keeps the entity and discards the external one' do
+                    expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, modeled_external_entities)).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: Maestrano::Connector::Rails::IdMap.first}]}})
+                    expect(modeled_external_entities[external_name][connec_name]).to be_empty
+                  end
+                end
+
+                context 'with external one more recent' do
+                  let(:external_date) { 1.month.ago } 
+                  let(:date) { 1.year.ago } 
+
+                  it 'discards the entity and keep the external one' do
+                    expect(subject.consolidate_and_map_connec_entities(modeled_connec_entities, modeled_external_entities)).to eql({connec_name => {external_name => []}})
+                    expect(modeled_external_entities[external_name][connec_name]).to_not be_empty
+                  end
                 end
               end
             end
           end
         end
       end
-    end
 
-    describe 'push_entities_to_connec' do
-      let(:idmap) { nil }
-      let(:mapped_entity_with_idmap) { {entity: {}, idmap: idmap} }
-      let(:external_hash) {
-        {
-          'sc_e1' => {'Connec1' => [mapped_entity_with_idmap]},
-          'ScE2' => {'Connec1' => [mapped_entity_with_idmap, mapped_entity_with_idmap], 'connec2' => [mapped_entity_with_idmap]}
+
+      describe 'push_entities_to_connec' do
+        let(:idmap) { nil }
+        let(:mapped_entity_with_idmap) { {entity: {}, idmap: idmap} }
+        let(:external_hash) {
+          {
+            'sc_e1' => {'Connec1' => [mapped_entity_with_idmap]},
+            'ScE2' => {'Connec1' => [mapped_entity_with_idmap, mapped_entity_with_idmap], 'connec2' => [mapped_entity_with_idmap]}
+          }
         }
-      }
 
-      it 'calls push_entities_to_connec on each sub complex entity' do
-        expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:push_entities_to_connec_to).once.with(nil, [mapped_entity_with_idmap], 'Connec1', nil)
-        expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:push_entities_to_connec_to).twice
-        subject.push_entities_to_connec(nil, external_hash, nil)
-      end
+        it 'calls push_entities_to_connec on each sub complex entity' do
+          expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:push_entities_to_connec_to).once.with([mapped_entity_with_idmap], 'Connec1')
+          expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:push_entities_to_connec_to).twice
+          subject.push_entities_to_connec(external_hash)
+        end
 
-      describe 'full call' do
-        let(:organization) { create(:organization) }
-        let!(:client) { Maestrano::Connec::Client.new(organization.uid) }
-        let(:idmap) { create(:idmap, organization: organization) }
-        before {
-          [Entities::SubEntities::ScE1, Entities::SubEntities::ScE2].each do |klass|
-            allow(klass).to receive(:external?).and_return(true)
-            allow(klass).to receive(:entity_name).and_return('n')
+        describe 'full call' do
+          let(:idmap) { create(:idmap, organization: organization) }
+          before {
+            [Entities::SubEntities::ScE1, Entities::SubEntities::ScE2].each do |klass|
+              allow(klass).to receive(:external?).and_return(true)
+              allow(klass).to receive(:entity_name).and_return('n')
+            end
+            allow(connec_client).to receive(:batch).and_return(ActionDispatch::Response.new(200, {}, {results: [{status: 200, body: {connec1s: {id: [{provider: 'connec', id: 'connec-id'}]}}}]}.to_json, {}), ActionDispatch::Response.new(200, {}, {results: [{status: 200, body: {connec1s: {id: [{provider: 'connec', id: 'connec-id'}]}}}]}.to_json, {}), ActionDispatch::Response.new(200, {}, {results: [{status: 200, body: {connec2s: {id: [{provider: 'connec', id: 'connec-id'}]}}}]}.to_json, {}))
+          }
+          it 'is successful' do
+            subject.push_entities_to_connec(external_hash)
+            idmap.reload
+            expect(idmap.message).to be nil
           end
-          allow(client).to receive(:batch).and_return(ActionDispatch::Response.new(200, {}, {results: [{status: 200, body: {connec1s: {}}}]}.to_json, {}))
-        }
-        it 'is successful' do
-          subject.push_entities_to_connec(client, external_hash, organization)
-          idmap.reload
-          expect(idmap.message).to be nil
         end
       end
-    end
 
-
-    describe 'push_entities_to_external' do
-      let(:mapped_entity_with_idmap) { {entity: {}, idmap: nil} }
-      let(:connec_hash) {
-        {
-          'sc_e1' => {'ext1' => [mapped_entity_with_idmap]},
-          'ScE2' => {'ext1' => [mapped_entity_with_idmap, mapped_entity_with_idmap], 'ext2' => [mapped_entity_with_idmap]}
+      describe 'push_entities_to_external' do
+        let(:mapped_entity_with_idmap) { {entity: {}, idmap: nil} }
+        let(:connec_hash) {
+          {
+            'sc_e1' => {'ext1' => [mapped_entity_with_idmap]},
+            'ScE2' => {'ext1' => [mapped_entity_with_idmap, mapped_entity_with_idmap], 'ext2' => [mapped_entity_with_idmap]}
+          }
         }
-      }
 
-      it 'calls push_entities_to_connec on each sub complex entity' do
-        expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:push_entities_to_external_to).once.with(nil, [mapped_entity_with_idmap], 'ext1', nil)
-        expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:push_entities_to_external_to).twice
-        subject.push_entities_to_external(nil, connec_hash, nil)
+        it 'calls push_entities_to_connec on each sub complex entity' do
+          expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:push_entities_to_external_to).once.with([mapped_entity_with_idmap], 'ext1')
+          expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:push_entities_to_external_to).twice
+          subject.push_entities_to_external(connec_hash)
+        end
       end
     end
   end