maestrano-connector-rails 1.2.3 → 1.3.0

data/spec/integration/singleton_spec.rb

@@ -148,7 +148,7 @@ describe 'singleton workflow' do
         it 'does the mapping correctly' do
           idmap = Entities::SingletonIntegration.create_idmap(organization_id: organization.id, external_id: ext_comp_id, connec_id: 'some connec id')
           allow(Entities::SingletonIntegration).to receive(:create_idmap).and_return(idmap)
-          expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_external).with([{entity: {name: 'My awesome company'}, idmap: idmap}])
+          expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_external).with([{entity: {name: 'My awesome company'}, idmap: idmap, id_refs_only_connec_entity: {}}])
           subject
         end
 
@@ -207,7 +207,7 @@ describe 'singleton workflow' do
         end
 
         it 'does the mapping correctly' do
-          expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_external).with([{entity: mapped_connec_entity, idmap: idmap}])
+          expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_external).with([{entity: mapped_connec_entity, idmap: idmap, id_refs_only_connec_entity: {}}])
           subject
         end
 
@@ -263,7 +263,7 @@ describe 'singleton workflow' do
     end
 
     it 'does the mapping correctly' do
-      expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_external).with([{entity: mapped_connec_entity, idmap: idmap}])
+      expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_external).with([{entity: mapped_connec_entity, idmap: idmap, id_refs_only_connec_entity: {}}])
       subject
     end
   end

data/spec/models/complex_entity_spec.rb

@@ -81,8 +81,8 @@ describe Maestrano::Connector::Rails::ComplexEntity do
         }
 
         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)
+          expect_any_instance_of(Entities::SubEntities::ScE1).to receive(:get_external_entities_wrapper).with(nil, 'sc_e1')
+          expect_any_instance_of(Entities::SubEntities::ScE2).to receive(:get_external_entities_wrapper).with(nil, 'ScE2')
           subject.get_external_entities_wrapper(nil)
         end
 
@@ -129,8 +129,10 @@ describe Maestrano::Connector::Rails::ComplexEntity do
           let(:id) { 'id' }
           let(:external_name) { 'sc_e1' }
           let(:connec_name) { 'connec1' }
-          let(:modeled_external_entities) { {external_name => {connec_name => [entity]}} }
+          let(:modelled_external_entities) { {external_name => {connec_name => [entity]}} }
           before {
+            allow(subject.class).to receive(:connec_entities_names).and_return(['connec1'])
+            allow(subject.class).to receive(:external_entities_names).and_return(['sc_e1'])
             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)
@@ -144,19 +146,19 @@ describe Maestrano::Connector::Rails::ComplexEntity do
 
             it 'does not create one' do
               expect{
-                subject.consolidate_and_map_external_entities(modeled_external_entities)
+                subject.consolidate_and_map_external_entities(modelled_external_entities)
               }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
             end
 
             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}]}})
+              expect(subject.consolidate_and_map_external_entities(modelled_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 => []}})
+                expect(subject.consolidate_and_map_external_entities(modelled_external_entities)).to eql({external_name => {connec_name => []}})
               end
             end
 
@@ -166,11 +168,11 @@ describe Maestrano::Connector::Rails::ComplexEntity do
               }
 
               it 'discards the entity' do
-                expect(subject.consolidate_and_map_external_entities(modeled_external_entities)).to eql({external_name => {connec_name => []}})
+                expect(subject.consolidate_and_map_external_entities(modelled_external_entities)).to eql({external_name => {connec_name => []}})
               end
 
               it 'updates the idmaps' do
-                subject.consolidate_and_map_external_entities(modeled_external_entities)
+                subject.consolidate_and_map_external_entities(modelled_external_entities)
                 expect(idmap.reload.external_inactive).to be true
               end
             end
@@ -179,7 +181,7 @@ describe Maestrano::Connector::Rails::ComplexEntity do
               before { idmap.update(last_push_to_connec: 2.second.ago) }
 
               it 'discards the entity' do
-                expect(subject.consolidate_and_map_external_entities(modeled_external_entities)).to eql({external_name => {connec_name => []}})
+                expect(subject.consolidate_and_map_external_entities(modelled_external_entities)).to eql({external_name => {connec_name => []}})
               end
             end
 
@@ -190,22 +192,25 @@ describe Maestrano::Connector::Rails::ComplexEntity 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(:modelled_connec_entities) { {connec_name => {external_name => [entity]}} }
+          let(:modelled_external_entities) { {} }
           let(:connec_name) { 'sc_e1' }
           let(:external_name) { 'ext1' }
+          let(:id_refs_only_connec_entity) { {a: 1} }
           before{
+            allow(subject.class).to receive(:connec_entities_names).and_return(['sc_e1'])
+            allow(subject.class).to receive(:external_entities_names).and_return(['ext1'])
             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))
+            allow(Maestrano::Connector::Rails::ConnecHelper).to receive(:unfold_references).and_return({entity: entity, connec_id: connec_id, id_refs_only_connec_entity: id_refs_only_connec_entity})
           }
 
           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}]}})
+                expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, {})).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: Maestrano::Connector::Rails::IdMap.first, id_refs_only_connec_entity: id_refs_only_connec_entity}]}})
               }.to change{ Maestrano::Connector::Rails::IdMap.count }.by(1)
               expect(Maestrano::Connector::Rails::IdMap.last.name).to eql(human_name)
             end
@@ -216,38 +221,38 @@ describe Maestrano::Connector::Rails::ComplexEntity do
 
             it 'does not create an idmap' do
               expect{
-                subject.consolidate_and_map_connec_entities(modeled_connec_entities, {})
+                subject.consolidate_and_map_connec_entities(modelled_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}]}})
+              expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, {})).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: idmap1, id_refs_only_connec_entity: id_refs_only_connec_entity}]}})
             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 => []}})
+                expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, {})).to eql({connec_name => {external_name => []}})
               end
             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 => []}})
+                expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, {})).to eql({connec_name => {external_name => []}})
               end
             end
 
             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 => []}})
+                expect(subject.consolidate_and_map_connec_entities(modelled_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]}} }
+              let(:modelled_external_entities) { {external_name => {connec_name => [external_entity_1]}} }
               before {
                 allow(Entities::SubEntities::ScE1).to receive(:id_from_external_entity_hash).and_return(id)
               }
@@ -256,16 +261,16 @@ describe Maestrano::Connector::Rails::ComplexEntity 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
+                    expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, modelled_external_entities)).to eql({connec_name => {external_name => []}})
+                    expect(modelled_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
+                    expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, modelled_external_entities)).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: Maestrano::Connector::Rails::IdMap.first, id_refs_only_connec_entity: id_refs_only_connec_entity}]}})
+                    expect(modelled_external_entities[external_name][connec_name]).to be_empty
                   end
                 end
               end
@@ -280,8 +285,8 @@ describe Maestrano::Connector::Rails::ComplexEntity do
                   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
+                    expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, modelled_external_entities)).to eql({connec_name => {external_name => [{entity: {mapped: 'entity'}, idmap: Maestrano::Connector::Rails::IdMap.first, id_refs_only_connec_entity: id_refs_only_connec_entity}]}})
+                    expect(modelled_external_entities[external_name][connec_name]).to be_empty
                   end
                 end
 
@@ -290,8 +295,8 @@ describe Maestrano::Connector::Rails::ComplexEntity do
                   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
+                    expect(subject.consolidate_and_map_connec_entities(modelled_connec_entities, modelled_external_entities)).to eql({connec_name => {external_name => []}})
+                    expect(modelled_external_entities[external_name][connec_name]).to_not be_empty
                   end
                 end
               end
@@ -311,6 +316,11 @@ describe Maestrano::Connector::Rails::ComplexEntity do
           }
         }
 
+        before {
+          allow(subject.class).to receive(:external_entities_names).and_return(['sc_e1', 'ScE2'])
+          allow(subject.class).to receive(:connec_entities_names).and_return(['Connec1', 'connec2'])
+        }
+
         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
@@ -343,6 +353,11 @@ describe Maestrano::Connector::Rails::ComplexEntity do
           }
         }
 
+        before {
+          allow(subject.class).to receive(:external_entities_names).and_return(['ext1', 'ext2'])
+          allow(subject.class).to receive(:connec_entities_names).and_return(['sc_e1', 'ScE2'])
+        }
+
         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

data/spec/models/connec_helper_spec.rb

@@ -54,68 +54,71 @@ describe Maestrano::Connector::Rails::ConnecHelper do
 
     let(:output_hash) {
       {
-        __connec_id: 'abcd',
-        id: id_id,
-        organization_id: org_id_id,
-        lines: [
-          {
-            linked_transaction: {
-              id: lt1_id_id
+        connec_id: connec_id,
+        entity: {
+          id: id_id,
+          organization_id: org_id_id,
+          lines: [
+            {
+              linked_transaction: {
+                id: lt1_id_id
+              }
+            },
+            {
+              linked_transaction: {
+                id: lt2_id_id
+              }
             }
-          },
-          {
-            linked_transaction: {
-              id: lt2_id_id
-            }
-          }
-        ]
+          ]
+        }.with_indifferent_access,
+        id_refs_only_connec_entity: {}
       }
     }
     let(:lt1_id_id) { 'lt1_id' }
     let(:lt2_id_id) { 'lt2_id' }
     let(:lt1_id) { [subject.id_hash(lt1_id_id, organization)] }
     let(:lt2_id) { [subject.id_hash(lt2_id_id, organization)] }
+    let(:connec_id) { 'cid1' }
+    let(:connec_org_id) { 'cid2' }
+    let(:org_id_id) { 'org_id' }
 
     context 'when all ids are here' do
       let(:id_id) { 'id' }
-      let(:org_id_id) { 'org_id' }
-      let(:id) { [subject.id_hash(id_id, organization), {'provider' => 'connec', 'id' => 'abcd'}] }
-      let(:org_id) { [subject.id_hash(org_id_id, organization), {'provider' => 'connec', 'id' => 'abcd'}] }
+      let(:id) { [subject.id_hash(id_id, organization), {'provider' => 'connec', 'id' => connec_id}] }
+      let(:org_id) { [subject.id_hash(org_id_id, organization), {'provider' => 'connec', 'id' => connec_org_id}] }
 
       it 'unfolds everything' do
-        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to eql(output_hash.with_indifferent_access)
+        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to eql(output_hash)
       end
     end
 
     context 'when only id is missing' do
       let(:id_id) { nil }
-      let(:org_id_id) { 'org_id' }
-      let(:id) { [{'provider' => 'connec', 'realm' => 'some realm', 'id' => 'id'}] }
+      let(:id) { [{'provider' => 'connec', 'realm' => 'some realm', 'id' => connec_id}] }
       let(:org_id) { [subject.id_hash(org_id_id, organization)] }
 
       it 'unfolds the other refs and keep the connec_id' do
-        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to eql(output_hash.merge(__connec_id: 'id').with_indifferent_access)
+        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to eql(output_hash.merge(connec_id: connec_id))
       end
     end
 
     context 'when at least one ref is missing and there is a connec id' do
       let(:id_id) { nil }
-      let(:org_id_id) { 'org_id' }
-      let(:id) { [{'provider' => 'connec', 'realm' => 'some realm', 'id' => 'id'}] }
-      let(:org_id) { [{'provider' => 'connec', 'realm' => 'some realm', 'id' => org_id_id}] }
+      let(:id) { [{'provider' => 'connec', 'realm' => 'some realm', 'id' => connec_id}] }
+      let(:org_id) { [{'provider' => 'connec', 'realm' => 'some realm', 'id' => connec_org_id}] }
 
       it 'returns nil' do
-        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to be_nil
+        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to eql(output_hash.merge(entity: nil))
       end
     end
     context 'when at least one ref is missing but there is no connec id' do
       let(:id_id) { 'id' }
-      let(:id) { [subject.id_hash(id_id, organization), {'provider' => 'connec', 'id' => 'abcd'}] }
+      let(:id) { [subject.id_hash(id_id, organization), {'provider' => 'connec', 'id' => connec_id}] }
       let(:org_id_id) { nil }
       let(:org_id) { nil }
 
       it 'unfold the others refs' do
-        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to eql(output_hash.merge(organization_id: nil).with_indifferent_access)
+        expect(subject.unfold_references(connec_hash, ['organization_id', 'lines/linked_transaction/id'], organization)).to eql(output_hash)
       end
     end
 
@@ -129,13 +132,16 @@ describe Maestrano::Connector::Rails::ConnecHelper do
 
       let(:output_hash) {
         {
-          __connec_id: 'abcd',
-          id: '123'
+          connec_id: 'abcd',
+          entity: {
+            id: '123'
+          }.with_indifferent_access,
+          id_refs_only_connec_entity: {}
         }
       }
 
-      it 'let the string as it is' do
-        expect(subject.unfold_references(connec_hash, ['organization_id'], organization)).to eql(output_hash.with_indifferent_access)
+      it 'ignores the string' do
+        expect(subject.unfold_references(connec_hash, ['organization_id'], organization)).to eql(output_hash)
       end
     end
   end
@@ -188,6 +194,10 @@ describe Maestrano::Connector::Rails::ConnecHelper do
       expect(subject.fold_references(mapped_hash, ['organization_id', 'contact/id', 'lines/id', 'not_here_ref'], organization)).to eql(output_hash.with_indifferent_access)
     end
 
+    it 'folds the existing refs (both id and record refs)' do
+      expect(subject.fold_references(mapped_hash, {record_references: %w(organization_id contact/id), id_references: %w(lines/id not_here_ref)}, organization)).to eql(output_hash.with_indifferent_access)
+    end
+
     context 'when id is an integer' do
       let(:id) { 1234 }
 
@@ -196,4 +206,362 @@ describe Maestrano::Connector::Rails::ConnecHelper do
       end
     end
   end
+
+  describe 'build_id_references_tree' do
+    let(:id_references) { %w(lines/id lines/linked/id lines/linked/id2 linked/id) }
+    let(:tree) {
+      {
+        "lines"=>{
+          "id"=>{},
+          "linked"=>{
+            "id"=>{},
+            "id2"=>{}
+          }
+        },
+        "linked"=>{
+          "id"=>{}
+        }
+      }
+    }
+
+    it 'returns the tree' do
+      expect(subject.build_id_references_tree(id_references)).to eql(tree)
+    end
+  end
+
+  describe 'format_references' do
+    context 'when array' do
+      it 'transforms it to an hash' do
+        expect(subject.format_references([1])).to eql({record_references: [1], id_references: []})
+      end
+    end
+
+    context 'when hash with both keys' do
+      let(:hash) { {id_references: [1], record_references: [2]} }
+      it 'returns it' do
+        expect(subject.format_references(hash)).to eql(hash)
+      end
+    end
+
+    context 'when hash with only one key' do
+      context 'when missing id_references' do
+        it 'returns the completed hash' do
+          expect(subject.format_references(record_references: [1])).to eql({record_references: [1], id_references: []})
+        end
+      end
+
+      context 'when missing record_references' do
+        it 'returns the completed hash' do
+          expect(subject.format_references(id_references: [1])).to eql({id_references: [1], record_references: []})
+        end
+      end
+    end
+  end
+
+  describe 'filter_connec_entity_for_id_refs' do
+    let(:connec_entity) {
+      {
+        id: [{"id"=>"001", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+        name: "Brewer Supplies Ltd",
+        description: "We supply all things brewed\n",
+        lines: [
+          {
+            id: [{"id"=>"002", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+            amount: 12,
+            linked: {
+              linked_transactions: [
+                {
+                  class: 'Invoice',
+                  id: [{"id"=>"003", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                  id2: [{"id"=>"013", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                },
+                {
+                  class: 'Sales order',
+                  id: [{"id"=>"004", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                  id2: [{"id"=>"014", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                }
+              ]
+            }
+          }
+        ],
+        linked_transactions: [
+          {
+            class: 'Test',
+            id: [{"id"=>"005", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+          }
+        ]
+      }
+    }
+
+    context 'with id_references' do
+      let(:id_references) { %w(lines/id lines/linked/linked_transactions/id lines/linked/linked_transactions/id2 linked_transactions/id) }
+      let(:filtered_connec_entity) {
+        {
+          lines: [
+            {
+              id: [{"id"=>"002", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+              linked: {
+                linked_transactions: [
+                  {
+                    id: [{"id"=>"003", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                    id2: [{"id"=>"013", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                  },
+                  {
+                    id: [{"id"=>"004", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                    id2: [{"id"=>"014", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+                  }
+                ]
+              }
+            }
+          ],
+          linked_transactions: [
+            {
+              id: [{"id"=>"005", "provider"=>"this_app", "realm"=>"sfuiy765"}],
+            }
+          ]
+        }.with_indifferent_access
+      }
+
+      it 'returns the connec_entity with only the relevant keys' do
+        expect(subject.filter_connec_entity_for_id_refs(connec_entity, id_references)).to eql(filtered_connec_entity)
+      end
+    end
+
+    context 'without id_references' do
+      it 'returns an empty hash' do
+        expect(subject.filter_connec_entity_for_id_refs(connec_entity, [])).to eql({})
+      end
+    end
+  end
+
+  describe 'value from hash' do
+    let(:hash) {
+      {
+        lines: [
+          {
+            linked: [
+              {
+                a: {
+                  b: [1]
+                }
+              }
+            ]
+          },
+          {
+            linked: [
+              {
+                a: {
+                  b: [2]
+                }
+              },
+              {
+                a: {
+                  b: [3]
+                }
+              }
+            ]
+          },
+        ]
+      }
+    }
+
+    let(:path) { [:lines, 1,:linked, 0, :a, :b] }
+
+    it 'returns the value from the path' do
+      expect(subject.value_from_hash(hash, path)).to eql([2])
+    end
+
+    context 'when the path leads to nowhere' do
+      context 'with a wrong array' do
+        let(:hash) {
+          {
+            lines: [
+              {
+                linked: [
+                  {
+                    a: {
+                      b: [1]
+                    }
+                  }
+                ]
+              },
+            ]
+          }
+        }
+
+        it 'returns nil' do
+          expect(subject.value_from_hash(hash, path)).to eql(nil)
+        end
+      end
+
+      context 'with a wrong hash' do
+        let(:hash) {
+          {
+            lines: [
+              {
+              },
+              {
+                linked: [
+                  {
+                  },
+                  {
+                  }
+                ]
+              },
+            ]
+          }
+        }
+
+        it 'returns nil' do
+          expect(subject.value_from_hash(hash, path)).to eql(nil)
+        end
+      end
+    end
+  end
+
+  describe 'merge_id_hashes' do
+    let(:dist) {
+      {
+        lines: [
+          {
+            id: [{"id"=>"002", "provider"=>"connec", "realm"=>"org-123"}],
+            linked: {
+              linked_transactions: [
+                {
+                  id: [{"id"=>"003", "provider"=>"connec", "realm"=>"org-123"}],
+                  id2: [{"id"=>"013", "provider"=>"connec", "realm"=>"org-123"}],
+                },
+                {
+                  id: [{"id"=>"004", "provider"=>"connec", "realm"=>"org-123"}],
+                  id2: [{"id"=>"014", "provider"=>"connec", "realm"=>"org-123"}],
+                }
+              ]
+            }
+          }
+        ],
+        linked_transactions: [
+          {
+            id: [{"id"=>"005", "provider"=>"connec", "realm"=>"org-123"}],
+          }
+        ]
+      }
+    }
+
+    let(:src) {
+      {
+        title: 'Title',
+        lines: [
+          {
+            amount: 123,
+            id: [{"id"=>"002", "provider"=>"this-app", "realm"=>"6543"}],
+            linked: {
+              linked_transactions: [
+                {
+                  class: 'Invoice',
+                  id: [{"id"=>"003", "provider"=>"this-app", "realm"=>"6543"}],
+                  id2: [{"id"=>"013", "provider"=>"this-app", "realm"=>"6543"}],
+                },
+                {
+                  class: 'Sales Order',
+                  id: [{"id"=>"004", "provider"=>"this-app", "realm"=>"6543"}],
+                  id2: [{"id"=>"014", "provider"=>"this-app", "realm"=>"6543"}],
+                }
+              ]
+            }
+          }
+        ],
+        linked_transactions: [
+          {
+            class: 'Payment',
+            id: [{"id"=>"005", "provider"=>"this-app", "realm"=>"6543"}],
+          }
+        ]
+      }
+    }
+
+    let(:id_references) {
+      %w(lines/id lines/linked/linked_transactions/id lines/linked/linked_transactions/id2 linked_transactions/id)
+    }
+
+    let(:output_hash) {
+      {
+        lines: [
+          {
+            id: [{"id"=>"002", "provider"=>"connec", "realm"=>"org-123"}, {"id"=>"002", "provider"=>"this-app", "realm"=>"6543"}],
+            linked: {
+              linked_transactions: [
+                {
+                  id: [{"id"=>"003", "provider"=>"connec", "realm"=>"org-123"}, {"id"=>"003", "provider"=>"this-app", "realm"=>"6543"}],
+                  id2: [{"id"=>"013", "provider"=>"connec", "realm"=>"org-123"}, {"id"=>"013", "provider"=>"this-app", "realm"=>"6543"}],
+                },
+                {
+                  id: [{"id"=>"004", "provider"=>"connec", "realm"=>"org-123"}, {"id"=>"004", "provider"=>"this-app", "realm"=>"6543"}],
+                  id2: [{"id"=>"014", "provider"=>"connec", "realm"=>"org-123"}, {"id"=>"014", "provider"=>"this-app", "realm"=>"6543"}],
+                }
+              ]
+            }
+          }
+        ],
+        linked_transactions: [
+          {
+            id: [{"id"=>"005", "provider"=>"connec", "realm"=>"org-123"}, {"id"=>"005", "provider"=>"this-app", "realm"=>"6543"}],
+          }
+        ]
+      }.with_indifferent_access
+    }
+
+    it 'merge the id from the src to the dist' do
+      expect(subject.merge_id_hashes(dist, src, id_references)).to eql(output_hash)
+    end
+
+    describe 'edge cases' do
+      context 'uncomplete src' do
+        describe 'when an id is missing in an array' do
+          before {
+            src[:linked_transactions] = []
+            output_hash[:linked_transactions].first.delete(:id)
+          }
+
+          it 'does not merge this id' do
+            expect(subject.merge_id_hashes(dist, src, id_references)).to eql(output_hash)
+          end
+        end
+
+        describe 'when an id is missing in a hash' do
+          before {
+            src[:lines].first.delete(:id)
+            output_hash[:lines].first.delete(:id)
+          }
+
+          it 'does not merge this id' do
+            expect(subject.merge_id_hashes(dist, src, id_references)).to eql(output_hash)
+          end
+        end
+      end
+
+      context 'uncomplete dist' do
+        describe 'when an id is missing in an array' do
+          before {
+            dist[:linked_transactions] = []
+            output_hash[:linked_transactions] = []
+          }
+
+          it 'does not merge this id' do
+            expect(subject.merge_id_hashes(dist, src, id_references)).to eql(output_hash)
+          end
+        end
+
+        describe 'when an id is missing in a hash' do
+          before {
+            dist[:lines].first.delete(:id)
+            output_hash[:lines].first.delete(:id)
+          }
+
+          it 'does not merge this id' do
+            expect(subject.merge_id_hashes(dist, src, id_references)).to eql(output_hash)
+          end
+        end
+      end
+    end
+  end
 end