maestrano-connector-rails 1.3.5 → 1.4.0

data/release_notes.md

@@ -1,3 +1,12 @@
+## 1.3.5
+
+## Features
+* Improve generated files
+* Adds a built-in way to handle error when updating a deleted record
+
+## Fixes
+* Adds safety against potential infinite loop
+
 ## 1.3.4
 `maestrano.rb` file should be updated with new synchronization paths.
 

data/spec/integration/complex_spec.rb

@@ -71,7 +71,7 @@ describe 'complex entities workflow' do
     def self.references
       {'CompOrganization' => ['ref_id']}
     end
-    def map_to(name, entity)
+    def map_to(name, entity, first_time_mapped = nil)
       super.merge(is_supplier: false)
     end
   end
@@ -94,7 +94,7 @@ describe 'complex entities workflow' do
     def self.references
       {'CompOrganization' => ['ref_id']}
     end
-    def map_to(name, entity)
+    def map_to(name, entity, first_time_mapped = nil)
       super.merge(is_supplier: true)
     end
   end
@@ -213,11 +213,11 @@ describe 'complex entities workflow' do
   }
   let!(:supplier_idmap) { Entities::SubEntities::CompSupplier.create_idmap(organization_id: organization.id, external_id: ext_supplier_id, connec_entity: 'comporganization') }
 
-  before {
+  before do
     allow(connec_client).to receive(:get).and_return(ActionDispatch::Response.new(200, {}, {comporganizations: connec_orgs}.to_json, {}))
     allow_any_instance_of(Entities::SubEntities::CompCustomer).to receive(:get_external_entities).and_return([ext_customer])
     allow_any_instance_of(Entities::SubEntities::CompSupplier).to receive(:get_external_entities).and_return([ext_supplier])
-  }
+  end
 
   subject { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity('customer_and_supplier', organization, connec_client, external_client, nil, {}) }
 
@@ -278,4 +278,298 @@ describe 'complex entities workflow' do
     expect(connec_client).to receive(:batch).exactly(3).times.and_return(ActionDispatch::Response.new(201, {}, {results: []}.to_json, {}), ActionDispatch::Response.new(200, {}, {results: []}.to_json, {}))
     subject
   end
+
+  describe "when using creation_mapper_classes" do
+
+    before do
+      allow(connec_client).to receive(:get).and_return(ActionDispatch::Response.new(200, {}, {comporganizationmissingfields: connec_orgs}.to_json, {}))
+      allow_any_instance_of(Entities::SubEntities::CompCustomerMissingField).to receive(:get_external_entities).and_return([ext_customer])
+      allow_any_instance_of(Entities::SubEntities::CompSupplierMissingField).to receive(:get_external_entities).and_return([ext_supplier])
+    end
+
+    let(:subject_missing_field) { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity('customer_and_supplier_missing_field', organization, connec_client, external_client, nil, {}) }
+
+    class Entities::CustomerAndSupplierMissingField < Maestrano::Connector::Rails::ComplexEntity
+      def self.connec_entities_names
+        %w(CompOrganizationMissingField)
+      end
+      def self.external_entities_names
+        %w(CompCustomerMissingField CompSupplierMissingField)
+      end
+      def connec_model_to_external_model(connec_hash_of_entities)
+        organizations_missing_field = connec_hash_of_entities['CompOrganizationMissingField']
+        modelled_connec_entities = { 'CompOrganizationMissingField' => { 'CompSupplierMissingField' => [], 'CompCustomerMissingField' => [] } }
+
+        organizations_missing_field.each do |organization|
+          if organization['is_supplier']
+            modelled_connec_entities['CompOrganizationMissingField']['CompSupplierMissingField'] << organization
+          else
+            modelled_connec_entities['CompOrganizationMissingField']['CompCustomerMissingField'] << organization
+          end
+        end
+
+        return modelled_connec_entities
+      end
+
+      def external_model_to_connec_model(external_hash_of_entities)
+        return {'CompCustomerMissingField' => {'CompOrganizationMissingField' => external_hash_of_entities['CompCustomerMissingField']}, 'CompSupplierMissingField' => {'CompOrganizationMissingField' => external_hash_of_entities['CompSupplierMissingField']}}
+      end
+    end
+
+    class Entities::SubEntities::CompOrganizationMissingField < Entities::SubEntities::CompOrganization
+
+      def self.entity_name
+        'CompOrganizationMissingField'
+      end
+
+      def self.mapper_classes
+        {
+          'CompCustomerMissingField' => ::CompMapper,
+          'CompSupplierMissingField' => ::CompMapper
+        }
+      end
+
+      def self.creation_mapper_classes
+        {
+          'CompCustomerMissingField' => ::CreationCompMapper,
+          'CompSupplierMissingField' => ::CreationCompMapper
+        }
+      end
+
+      def self.references
+        {'CompCustomerMissingField' => ['ref_id'], 'CompSupplierMissingField' => ['ref_id']}
+      end
+    end
+
+    class Entities::SubEntities::CompCustomerMissingField < Maestrano::Connector::Rails::SubEntityBase
+      def self.external?
+        true
+      end
+
+      def self.entity_name
+        'CompCustomerMissingField'
+      end
+
+      def self.creation_mapper_classes
+        {'CompOrganizationMissingField' => ::CreationCompMapper}
+      end
+
+      def self.id_from_external_entity_hash(entity)
+        entity['id']
+      end
+
+      def self.object_name_from_external_entity_hash(entity)
+        entity['name']
+      end
+
+      def self.references
+        {'CompOrganizationMissingField' => ['ref_id']}
+      end
+
+      def map_to(name, entity, first_time_mapped = nil)
+        super.merge(is_supplier: false)
+      end
+    end
+
+    class Entities::SubEntities::CompSupplierMissingField < Maestrano::Connector::Rails::SubEntityBase
+      def self.external?
+        true
+      end
+
+      def self.entity_name
+        'CompSupplierMissingField'
+      end
+
+      def self.mapper_classes
+        {'CompOrganizationMissingField' => ::CompMapper}
+      end
+
+      def self.id_from_external_entity_hash(entity)
+        entity['id']
+      end
+
+      def self.object_name_from_external_entity_hash(entity)
+        entity['name']
+      end
+
+      def self.references
+        {'CompOrganizationMissingField' => ['ref_id']}
+      end
+
+      def map_to(name, entity, first_time_mapped = nil)
+        super.merge(is_supplier: true)
+      end
+    end
+
+    class CreationCompMapper < CompMapper
+      after_normalize do |input, output|
+        output[:missing_field] = "Default"
+        output
+      end
+
+      after_denormalize do |input, output|
+        output[:missing_field] = "Default"
+        output
+      end
+    end
+
+    let(:mapped_connec_org1) {
+      {
+        ref_id: connec_org1_ext_ref_id,
+        name: connec_org1_name,
+        missing_field: "Default"
+      }
+    }
+
+    let(:mapped_connec_org2) {
+      {
+        ref_id: connec_org2_ext_ref_id,
+        name: connec_org2_name,
+        id: connec_org2_ext_id,
+        missing_field: "Default"
+      }
+    }
+
+    let(:mapped_ext_customer) {
+      {
+        :id => [
+          {
+            :id => ext_customer_id,
+            :provider => provider,
+            :realm => oauth_uid
+          }
+        ],
+        :ref_id => [
+          {
+            :id => ext_ref_id,
+            :provider => provider,
+            :realm => oauth_uid
+          }
+        ],
+        :name => ext_customer_name,
+        :is_supplier => false,
+        :missing_field => "Default"
+      }
+    }
+
+    let(:mapped_ext_supplier) {
+      {
+        :id => [
+          {
+            :id => ext_supplier_id,
+            :provider => provider,
+            :realm => oauth_uid
+          }
+        ],
+        :ref_id => [
+          {
+            :id => ext_ref_id,
+            :provider => provider,
+            :realm => oauth_uid
+          }
+        ],
+        :name => ext_supplier_name,
+        :is_supplier => true
+      }
+    }
+
+    let!(:supplier_missing_field_idmap) { Entities::SubEntities::CompSupplierMissingField.create_idmap(organization_id: organization.id, external_id: ext_supplier_id, connec_entity: 'comporganizationmissingfield') }
+
+    it 'handles the mapping correctly' do
+      cust_idmap = Entities::SubEntities::CompCustomerMissingField.create_idmap(organization_id: organization.id, external_id: ext_customer_id, connec_entity: 'comporganizationmissingfield')
+      org1_idmap = Entities::SubEntities::CompOrganizationMissingField.create_idmap(organization_id: organization.id, external_id: connec_org1_ext_id, external_entity: 'compsuppliermissingfield')
+      org2_idmap = Entities::SubEntities::CompOrganizationMissingField.create_idmap(organization_id: organization.id, external_id: connec_org2_ext_id, external_entity: 'compcustomermissingfield')
+      allow(Maestrano::Connector::Rails::IdMap).to receive(:create).and_return(org1_idmap, org2_idmap, cust_idmap)
+      expect_any_instance_of(Entities::CustomerAndSupplierMissingField).to receive(:push_entities_to_external).with({'CompOrganizationMissingField' => {'CompSupplierMissingField' => [{entity: mapped_connec_org1.with_indifferent_access, idmap: org1_idmap, id_refs_only_connec_entity: {}}], 'CompCustomerMissingField' => [{entity: mapped_connec_org2.with_indifferent_access, idmap: org2_idmap, id_refs_only_connec_entity: {}}]}})
+      expect_any_instance_of(Entities::CustomerAndSupplierMissingField).to receive(:push_entities_to_connec).with({'CompCustomerMissingField' => {'CompOrganizationMissingField' => [{entity: mapped_ext_customer.with_indifferent_access, idmap: cust_idmap}]}, 'CompSupplierMissingField' => {'CompOrganizationMissingField' => [{entity: mapped_ext_supplier.with_indifferent_access, idmap: supplier_missing_field_idmap}]}})
+      subject_missing_field
+    end
+
+    context "with idmap and last_push_to_external field present it does not overwrite the missing field" do
+
+      let(:subject_already_pushed_entities) { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity('customer_and_supplier_missing_field', organization, connec_client, external_client, nil, {}) }
+
+      before do
+        allow(connec_client).to receive(:get).and_return(ActionDispatch::Response.new(200, {}, {comporganizationmissingfields: connec_orgs_already_pushed}.to_json, {}))
+        allow_any_instance_of(Entities::SubEntities::CompCustomerMissingField).to receive(:get_external_entities).and_return([ext_customer])
+        allow_any_instance_of(Entities::SubEntities::CompSupplierMissingField).to receive(:get_external_entities).and_return([ext_supplier])
+      end
+
+      let(:connec_org1_already_pushed) { connec_org1.merge!(updated_at: "2015-08-10T14:42:38Z", 'id' => connec_org1['id'].push({'provider' => provider, 'id' => connec_org1_ext_id, 'realm' => oauth_uid})) }
+      let(:connec_org2_already_pushed) { connec_org2.merge!(updated_at: "2015-08-10T14:42:38Z", 'id' => connec_org2['id'].push({'provider' => provider, 'id' => connec_org2_ext_id, 'realm' => oauth_uid})) }
+
+      let(:connec_orgs_already_pushed) { [connec_org1_already_pushed, connec_org2_already_pushed] }
+
+      let(:mapped_connec_org1) {
+        {
+          id: connec_org1_ext_id,
+          ref_id: connec_org1_ext_ref_id,
+          name: connec_org1_name
+        }
+      }
+
+      let(:mapped_connec_org2) {
+        {
+          id: connec_org2_ext_id,
+          ref_id: connec_org2_ext_ref_id,
+          name: connec_org2_name
+
+        }
+      }
+
+      let(:mapped_ext_customer) {
+        {
+          :id => [
+            {
+              :id => ext_customer_id,
+              :provider => provider,
+              :realm => oauth_uid
+            }
+          ],
+          :ref_id => [
+            {
+              :id => ext_ref_id,
+              :provider => provider,
+              :realm => oauth_uid
+            }
+          ],
+          :name => ext_customer_name,
+          :is_supplier => false,
+          :missing_field => "Default"
+        }
+      }
+
+      let(:mapped_ext_supplier) {
+        {
+          :id => [
+            {
+              :id => ext_supplier_id,
+              :provider => provider,
+              :realm => oauth_uid
+            }
+          ],
+          :ref_id => [
+            {
+              :id => ext_ref_id,
+              :provider => provider,
+              :realm => oauth_uid
+            }
+          ],
+          :name => ext_supplier_name,
+          :is_supplier => true
+        }
+      }
+
+      let!(:supplier_missing_field_idmap) { Entities::SubEntities::CompSupplierMissingField.create_idmap(organization_id: organization.id, external_id: ext_supplier_id, connec_entity: 'comporganizationmissingfield', last_push_to_external: "2014-08-10T14:42:38Z") }
+      let!(:customer_missing_field_idmap)  { Entities::SubEntities::CompCustomerMissingField.create_idmap(organization_id: organization.id, external_id: ext_customer_id, connec_entity: 'comporganizationmissingfield', last_push_to_external: "2014-08-10T14:42:38Z") }
+      let!(:org1_missing_field_idmap)     { Entities::SubEntities::CompOrganizationMissingField.create_idmap(organization_id: organization.id, external_id: connec_org1_ext_id, external_entity: 'compsuppliermissingfield', connec_id: connec_org1_id, name: connec_org1_name, last_push_to_external: "2014-08-10T14:42:38Z") }
+      let!(:org2_missing_field_idmap)     { Entities::SubEntities::CompOrganizationMissingField.create_idmap(organization_id: organization.id, external_id: connec_org2_ext_id, external_entity: 'compcustomermissingfield', connec_id: connec_org2_id, name: connec_org2_name, last_push_to_external: "2014-08-10T14:42:38Z") }
+      #update idmap with last_push_to_external and check that the :missing_field is not updated
+      it 'does not overwrite the default field in the subsequent mapping' do
+        expect_any_instance_of(Entities::CustomerAndSupplierMissingField).to receive(:push_entities_to_external).with({'CompOrganizationMissingField' => {'CompSupplierMissingField' => [{entity: mapped_connec_org1.with_indifferent_access, idmap: org1_missing_field_idmap, id_refs_only_connec_entity: {}}], 'CompCustomerMissingField' => [{entity: mapped_connec_org2.with_indifferent_access, idmap: org2_missing_field_idmap, id_refs_only_connec_entity: {}}]}})
+        expect_any_instance_of(Entities::CustomerAndSupplierMissingField).to receive(:push_entities_to_connec).with({'CompCustomerMissingField' => {'CompOrganizationMissingField' => [{entity: mapped_ext_customer.with_indifferent_access, idmap: customer_missing_field_idmap}]}, 'CompSupplierMissingField' => {'CompOrganizationMissingField' => [{entity: mapped_ext_supplier.with_indifferent_access, idmap: supplier_missing_field_idmap}]}})
+        subject_already_pushed_entities
+      end
+    end
+  end
 end

data/spec/integration/connec_to_external_spec.rb

@@ -27,8 +27,18 @@ describe 'connec to the external application' do
       entity['ID']
     end
 
+    def before_sync(last_synchronization_date)
+      @elephant_count = 8
+    end
+
     class PersonMapper
       extend HashMapper
+
+      after_normalize do |input, output, opts|
+        output[:Count] = opts[:elephant_count]
+        output
+      end
+
       map from('organization_id'), to('AccountId')
       map from('first_name'), to('FirstName')
     end
@@ -41,13 +51,17 @@ describe 'connec to the external application' do
   let(:external_client) { Object.new }
   let(:ext_org_id) { 'ext org id' }
   let(:ext_contact_id) { 'ext contact id' }
+  let(:ext_contact_id2) { 'ext contact id 2' }
+  let(:connec_id1) { "23daf041-e18e-0133-7b6a-15461b913fab"}
+  let(:connec_id2) { "11daf041-e18e-0133-7b6a-15461b913yyy"}
+
   let(:person1) {
     {
       "id" => [
         {
           "realm" => "org-fg4a",
           "provider" => "connec",
-          "id" => "23daf041-e18e-0133-7b6a-15461b913fab"
+          "id" => connec_id1
         }
       ],
       "code" => "PE3",
@@ -75,13 +89,12 @@ describe 'connec to the external application' do
   }
   let(:person) { person1 }
 
-
-  before {
+  before do
     allow(connec_client).to receive(:get).and_return(ActionDispatch::Response.new(200, {}, {people: [person]}.to_json, {}))
     allow(connec_client).to receive(:batch).and_return(ActionDispatch::Response.new(200, {}, {results: [{status: 200, body: {people: {}}}]}.to_json, {}))
 
     allow_any_instance_of(Entities::ConnecToExternal).to receive(:get_external_entities).and_return([])
-  }
+  end
 
   subject { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity('connec_to_external', organization, connec_client, external_client, organization.last_synchronization_date, {}) }
 
@@ -93,7 +106,8 @@ describe 'connec to the external application' do
     let(:mapped_entity) {
       {
         AccountId: ext_org_id,
-        FirstName: 'John'
+        FirstName: 'John',
+        Count: 8
       }
     }
 
@@ -102,8 +116,8 @@ describe 'connec to the external application' do
         :sequential=>true,
         :ops=> [
           {
-            :method=>"put", 
-            :url=>"/api/v2/#{organization.uid}/people/23daf041-e18e-0133-7b6a-15461b913fab", 
+            :method=>"put",
+            :url=>"/api/v2/#{organization.uid}/people/23daf041-e18e-0133-7b6a-15461b913fab",
             :params=>
             {
               :people=>{
@@ -157,7 +171,8 @@ describe 'connec to the external application' do
     let(:mapped_entity) {
       {
         AccountId: ext_org_id,
-        FirstName: 'Jane'
+        FirstName: 'Jane',
+        Count: 8
       }
     }
 
@@ -177,12 +192,11 @@ describe 'connec to the external application' do
       expect(connec_client).to_not receive(:batch)
       subject
     end
-
   end
 
   describe 'a creation from connec with references missing' do
     let(:person) { person1.merge("organization_id" => [{"realm"=>"org-fg4a", "provider"=>"connec", "id"=>"2305c5e0-e18e-0133-890f-07d4de9f9781"}]) }
-    
+
     it 'pushes nothing and creates no idmap' do
       expect_any_instance_of(Entities::ConnecToExternal).to_not receive(:create_external_entity)
       expect_any_instance_of(Entities::ConnecToExternal).to_not receive(:update_external_entity)
@@ -211,4 +225,97 @@ describe 'connec to the external application' do
       }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
     end
   end
+
+  describe 'a creation from connec where the creation_only_mapper has to be used' do
+    #idmap.last_push_to_external is nil
+    before do
+      allow_any_instance_of(Entities::ConnecToExternalMissingField).to receive(:get_external_entities).and_return([])
+    end
+
+    subject { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity('connec_to_external_missing_field', organization, connec_client, external_client, organization.last_synchronization_date, {}) }
+
+    class Entities::ConnecToExternalMissingField < Entities::ConnecToExternal
+
+      def self.creation_mapper_class
+        CreationPersonMapper
+      end
+
+      class CreationPersonMapper < PersonMapper
+        after_normalize do |input, output|
+          output[:missing_connec_field] = "Default"
+          output
+        end
+      end
+    end
+
+    describe 'a new record created in connec with all references known' do
+      before {
+        allow(connec_client).to receive(:get).and_return(ActionDispatch::Response.new(200, {}, {people: [person2]}.to_json, {}))
+        allow(connec_client).to receive(:batch).and_return(ActionDispatch::Response.new(200, {}, {results: [{status: 200, body: {people: {}}}]}.to_json, {}))
+
+        allow_any_instance_of(Entities::ConnecToExternalMissingField).to receive(:create_external_entity).and_return({'ID' => ext_contact_id2})
+      }
+
+      let(:person2) { person1.merge('first_name' => 'Jack', 'id' => [{"realm" => "org-fg4a", "provider" => "connec", "id" => connec_id2 }]) }
+
+      let(:mapped_entity_missing_field) {
+        {
+          AccountId: ext_org_id,
+          FirstName: 'Jack',
+          missing_connec_field: "Default",
+          Count: 8
+        }
+      }
+
+      let(:batch_params) {
+        {
+          :sequential=>true,
+          :ops=> [
+            {
+              :method=>"put",
+              :url=>"/api/v2/#{organization.uid}/people/11daf041-e18e-0133-7b6a-15461b913yyy",
+              :params=>
+              {
+                :people=>{
+                  id: [
+                    {
+                      :id=>"ext contact id 2",
+                      :provider=>"provider",
+                      :realm=>"oauth uid"
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      }
+
+      it 'handles the idmap correctly' do
+        expect{
+          subject
+        }.to change{ Maestrano::Connector::Rails::IdMap.count }.by(1)
+        idmap = Maestrano::Connector::Rails::IdMap.last
+        expect(idmap.name).to eql('Jack')
+        expect(idmap.connec_entity).to eql('person')
+        expect(idmap.external_entity).to eql('contact')
+        expect(idmap.message).to be_nil
+        expect(idmap.external_id).to eql(ext_contact_id2)
+        expect(idmap.connec_id).to eql("11daf041-e18e-0133-7b6a-15461b913yyy")
+      end
+
+      it 'does the mapping correctly' do
+        idmap = Entities::ConnecToExternalMissingField.create_idmap(organization_id: organization.id, external_id: ext_contact_id, connec_id: "23daf041-e18e-0133-7b6a-15461b913yyy")
+        allow(Entities::ConnecToExternalMissingField).to receive(:find_or_create_idmap).and_return(idmap)
+        expect_any_instance_of(Entities::ConnecToExternalMissingField).to receive(:push_entities_to_external).with([{entity: mapped_entity_missing_field.with_indifferent_access, idmap: idmap, id_refs_only_connec_entity: {}}])
+        subject
+      end
+
+      it 'send the external id to connec' do
+        expect(connec_client).to receive(:batch).with(batch_params)
+        subject
+      end
+    end
+
+  end
 end