maestrano-connector-rails 0.4.4 → 1.0.0

data/spec/controllers/connec_controller_spec.rb

@@ -31,10 +31,19 @@ describe Maestrano::ConnecController, type: :controller do
         expect(response.status).to eq(200)
       end
 
+      context 'with an unexpected error' do
+        let(:notifications) { {'people' => [entity]} }
+        it 'logs a warning' do
+          allow(controller).to receive(:find_entity_class).and_raise('Bruno c\'est peter')
+          expect(Rails.logger).to receive(:warn)
+          subject
+        end
+      end
+
       context "with an unknown entity" do
         let(:notifications) { {'people' => [entity]} }
         before {
-          allow(Maestrano::Connector::Rails::Entity).to receive(:entities_list).and_return(%w())
+          allow(Maestrano::Connector::Rails::External).to receive(:entities_list).and_return(%w())
         }
 
         it 'logs a warning' do
@@ -47,7 +56,7 @@ describe Maestrano::ConnecController, type: :controller do
         let(:notifications) { {'leads' => [entity]} }
 
         before {
-          allow(Maestrano::Connector::Rails::Entity).to receive(:entities_list).and_return(%w(contact_and_lead))
+          allow(Maestrano::Connector::Rails::External).to receive(:entities_list).and_return(%w(contact_and_lead))
           class Entities::ContactAndLead < Maestrano::Connector::Rails::ComplexEntity
             def self.connec_entities_names
               %w(Lead)
@@ -71,11 +80,15 @@ describe Maestrano::ConnecController, type: :controller do
 
           it 'process the data and push them' do
             expect_any_instance_of(Entities::ContactAndLead).to receive(:before_sync)
-            expect_any_instance_of(Entities::ContactAndLead).to receive(:filter_connec_entities).and_return({"Lead"=>[entity]})
-            expect_any_instance_of(Entities::ContactAndLead).to receive(:consolidate_and_map_data).with({"Lead"=>[entity]}, {}, organization, {}).and_return({})
+            expect_any_instance_of(Entities::ContactAndLead).to receive(:filter_connec_entities).with({"Lead"=>[entity]}).and_return({"Lead"=>[entity]})
+            expect_any_instance_of(Entities::ContactAndLead).to receive(:consolidate_and_map_data).with({"Lead"=>[entity]}, {}).and_return({})
             expect_any_instance_of(Entities::ContactAndLead).to receive(:push_entities_to_external)
             expect_any_instance_of(Entities::ContactAndLead).to receive(:after_sync)
+            begin
             subject
+          rescue => e
+            puts e
+          end
           end
         end
       end
@@ -84,7 +97,7 @@ describe Maestrano::ConnecController, type: :controller do
         let(:notifications) { {'people' => [entity]} }
 
         before {
-          allow(Maestrano::Connector::Rails::Entity).to receive(:entities_list).and_return(%w(person))
+          allow(Maestrano::Connector::Rails::External).to receive(:entities_list).and_return(%w(person))
           class Entities::Person < Maestrano::Connector::Rails::Entity
             def self.connec_entity_name
               'People'
@@ -140,7 +153,7 @@ describe Maestrano::ConnecController, type: :controller do
             it 'process the data and push them' do
               expect_any_instance_of(Entities::Person).to receive(:before_sync)
               expect_any_instance_of(Entities::Person).to receive(:filter_connec_entities).and_return([entity])
-              expect_any_instance_of(Entities::Person).to receive(:consolidate_and_map_data).with([entity], [], organization, {}).and_return({})
+              expect_any_instance_of(Entities::Person).to receive(:consolidate_and_map_data).with([entity], []).and_return({})
               expect_any_instance_of(Entities::Person).to receive(:push_entities_to_external)
               expect_any_instance_of(Entities::Person).to receive(:after_sync)
               subject

data/spec/dummy/app/models/maestrano/connector/rails/entity.rb

@@ -1,10 +1,3 @@
 class Maestrano::Connector::Rails::Entity
   include Maestrano::Connector::Rails::Concerns::Entity
-
-  # Return an array of all the entities that the connector can synchronize
-  # If you add new entities, you need to generate
-  # a migration to add them to existing organizations
-  def self.entities_list
-    %w(entity1 entity2)
-  end
 end

data/spec/dummy/app/models/maestrano/connector/rails/external.rb

@@ -8,4 +8,11 @@ class Maestrano::Connector::Rails::External
   def self.get_client(organization)
     nil
   end
+
+  # Return an array of all the entities that the connector can synchronize
+  # If you add new entities, you need to generate
+  # a migration to add them to existing organizations
+  def self.entities_list
+    %w(entity1 entity2)
+  end
 end

data/spec/dummy/app/views/home/index.html.erb

@@ -1,36 +1 @@
-<!-- TODO -->
-<!-- This template is given as an example of the informations that
-can be displayed on the home page -->
-<!-- This view is designed according to the home controller supplied -->
-<div class='home'>
-  <%= link_to 'Admin panel', admin_index_path %>
-  <% unless current_user %>
-    <%= link_to "Link your Maestrano account", maestrano_connector_rails.init_maestrano_auth_saml_index_path(tenant: :default) %>
-    <p>Some generic information about the connector</p>
-
-  <% else %>
-    <% unless @organization.oauth_uid %>
-      Not linked to external app
-      <% if is_admin?(current_user, @organization) %>
-        <%= link_to "Link this company to ...", 'some_path' %>
-      <% end %>
-    <% else %>
-      Linked to external app
-    <% end %>
-
-    <h2>Last synchronization</h2>
-    <% if @synchronizations.first %>
-      <%= "#{@synchronizations.first.updated_at} #{@synchronizations.first.status}" %>
-      <%= @synchronizations.first.message if @synchronizations.first.status == 'ERROR' %>
-    <% end %>
-
-    <h2>Synchronizations history</h2>
-    <% @synchronizations.each do |sync| %>
-      <%= sync.updated_at %>
-      <%= sync.status %>
-      <% if sync.status == 'ERROR' %>
-        <%= sync.message %>
-      <% end %>
-    <% end %>
-  <% end %>
-</div>
+<!-- TODO -->

data/spec/factories.rb

@@ -8,6 +8,9 @@ FactoryGirl.define do
   factory :organization, class: Maestrano::Connector::Rails::Organization do
     name "My company"
     tenant "default"
+    sequence(:uid) { |n| "cld-11#{n}" }
+    oauth_uid 'sfuiy765'
+    oauth_provider 'this_app'
   end
 
   factory :user_organization_rel, class: Maestrano::Connector::Rails::UserOrganizationRel do

data/spec/integration/connec_to_external_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe 'connec to the external application' do
+
+  class Entities::ConnecToExternal < Maestrano::Connector::Rails::Entity
+    def self.external_entity_name
+      'Contact'
+    end
+
+    def self.connec_entity_name
+      'Person'
+    end
+
+    def self.mapper_class
+      PersonMapper
+    end
+
+    def self.references
+      ['organization_id']
+    end
+
+    def self.object_name_from_connec_entity_hash(entity)
+      entity['first_name']
+    end
+
+    class PersonMapper
+      extend HashMapper
+      map from('organization_id'), to('AccountId')
+      map from('first_name'), to('FirstName')
+    end
+  end
+
+  let(:provider) { 'provider' }
+  let(:oauth_uid) { 'oauth uid' }
+  let!(:organization) { create(:organization, oauth_provider: provider, oauth_uid: oauth_uid) }
+  let(:connec_client) { Maestrano::Connec::Client[organization.tenant].new(organization.uid) }
+  let(:external_client) { Object.new }
+  let(:ext_org_id) { 'ext org id' }
+  let(:ext_contact_id) { 'ext contact id' }
+  let(:person1) {
+    {
+      "id" => [
+        {
+          "realm" => "org-fg4a",
+          "provider" => "connec",
+          "id" => "23daf041-e18e-0133-7b6a-15461b913fab"
+        }
+      ],
+      "code" => "PE3",
+      "status" => "ACTIVE",
+      "first_name" => "John",
+      "last_name" => "Doe",
+      "organization_id" => [
+        {
+          "realm" => "org-fg4a",
+          "provider" => "connec",
+          "id" => "2305c5e0-e18e-0133-890f-07d4de9f9781"
+        },
+        {
+          "realm" => oauth_uid,
+          "provider" => provider,
+          "id" => ext_org_id
+        }
+      ],
+      "is_customer" => false,
+      "is_supplier" => true,
+      "is_lead" => false
+    }
+  }
+  let(:person) { person1 }
+
+
+  before {
+    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([])
+  }
+
+  subject { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity('connec_to_external', organization, connec_client, external_client, nil, {}) }
+
+  describe 'a new record created in connec with all references known' do
+    before {
+      allow_any_instance_of(Entities::ConnecToExternal).to receive(:create_external_entity).and_return(ext_contact_id)
+    }
+
+    let(:mapped_entity) {
+      {
+        AccountId: ext_org_id,
+        FirstName: 'John'
+      }
+    }
+
+    let(:batch_params) {
+      {
+        :sequential=>true,
+        :ops=> [
+          {
+            :method=>"put", 
+            :url=>"/api/v2/#{organization.uid}/people/23daf041-e18e-0133-7b6a-15461b913fab", 
+            :params=>
+            {
+              :people=>{
+                id: [
+                  {
+                    :id=>"ext contact id",
+                    :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('John')
+      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_id)
+      expect(idmap.connec_id).to eql("23daf041-e18e-0133-7b6a-15461b913fab")
+    end
+
+    it 'does the mapping correctly' do
+      idmap = Entities::ConnecToExternal.create_idmap(organization_id: organization.id, external_id: ext_contact_id, connec_id: "23daf041-e18e-0133-7b6a-15461b913fab")
+      allow(Entities::ConnecToExternal).to receive(:create_idmap).and_return(idmap)
+      expect_any_instance_of(Entities::ConnecToExternal).to receive(:push_entities_to_external).with([{entity: mapped_entity, idmap: idmap}])
+      subject
+    end
+
+    it 'send the external id to connec' do
+      expect(connec_client).to receive(:batch).with(batch_params)
+      subject
+    end
+  end
+
+  describe 'an update from connec with all references known' do
+    before {
+      allow_any_instance_of(Entities::ConnecToExternal).to receive(:update_external_entity).and_return(nil)
+    }
+    let(:person) { person1.merge('first_name' => 'Jane', 'id' => person1['id'] << {'id' => ext_contact_id, 'provider' => provider, 'realm' => oauth_uid}) }
+    let!(:idmap) { Entities::ConnecToExternal.create_idmap(organization_id: organization.id, external_id: ext_contact_id, connec_id: "23daf041-e18e-0133-7b6a-15461b913fab") }
+
+    let(:mapped_entity) {
+      {
+        AccountId: ext_org_id,
+        FirstName: 'Jane'
+      }
+    }
+
+    it 'update the idmap' do
+      subject
+      expect(idmap.reload.message).to be_nil
+      expect(idmap.reload.name).to eql('Jane')
+      expect(idmap.reload.last_push_to_external > 1.minute.ago).to be true
+    end
+
+    it 'does the mapping correctly' do
+      expect_any_instance_of(Entities::ConnecToExternal).to receive(:push_entities_to_external).with([{entity: mapped_entity, idmap: idmap}])
+      subject
+    end
+
+    it 'does not send the external id to connec' 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)
+      expect{
+        subject
+      }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
+    end
+  end
+end

data/spec/integration/external_to_connec_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe 'external application to connec' do
+
+  class Entities::ExternalToConnec < Maestrano::Connector::Rails::Entity
+    def self.external_entity_name
+      'Contact'
+    end
+
+    def self.connec_entity_name
+      'Person'
+    end
+
+    def self.mapper_class
+      PersonMapper
+    end
+
+    def self.references
+      ['organization_id']
+    end
+
+    def self.object_name_from_external_entity_hash(entity)
+      entity['FirstName']
+    end
+
+    def self.id_from_external_entity_hash(entity)
+      entity['Id']
+    end
+
+    class PersonMapper
+      extend HashMapper
+      map from('organization_id'), to('AccountId')
+      map from('first_name'), to('FirstName')
+    end
+  end
+
+  let(:provider) { 'provider' }
+  let(:oauth_uid) { 'oauth uid' }
+  let!(:organization) { create(:organization, oauth_provider: provider, oauth_uid: oauth_uid) }
+  let(:connec_client) { Maestrano::Connec::Client[organization.tenant].new(organization.uid) }
+  let(:external_client) { Object.new }
+
+  let(:ext_org_id) { 'ext org id' }
+  let(:ext_contact_id) { 'ext contact id' }
+
+  let(:contact1) {
+    {
+      'Id' => ext_contact_id,
+      'FirstName' => 'Jack',
+      'AccountId' => ext_org_id
+    }
+  }
+  let(:contact) { contact1 }
+
+  let(:mapped_entity1) {
+    {
+      id: [
+        {
+          provider: provider,
+          realm: oauth_uid,
+          id: ext_contact_id
+        }
+      ],
+      first_name: 'Jack',
+      organization_id: [
+        {
+          provider: provider,
+          realm: oauth_uid,
+          id: ext_org_id
+        }
+      ]
+    }
+  }
+  let(:mapped_entity) { mapped_entity1 }
+
+  let(:batch_call) {
+    {
+      :sequential => true,
+      :ops => [
+        {
+          :method => "post",
+          :url => "/api/v2/#{organization.uid}/people/",
+          :params => {
+            :people => mapped_entity
+          }
+        }
+      ]
+    }
+  }
+
+  before {
+    allow_any_instance_of(Entities::ExternalToConnec).to receive(:get_connec_entities).and_return([])
+    allow_any_instance_of(Entities::ExternalToConnec).to receive(:get_external_entities).and_return([contact])
+  }
+
+  subject { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity('external_to_connec', organization, connec_client, external_client, nil, {}) }
+
+  describe 'creating an record in connec' do
+    before {
+      allow(connec_client).to receive(:batch).and_return(ActionDispatch::Response.new(201, {}, {results: [{status: 201, body: {people: {id: [{provider: 'connec', id: 'connec-id'}]}}}]}.to_json, {}))
+    }
+
+    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_id)
+    end
+
+    it 'does the mapping correctly' do
+      idmap = Entities::ExternalToConnec.create_idmap(organization_id: organization.id, external_id: ext_contact_id)
+      allow(Entities::ExternalToConnec).to receive(:create_idmap).and_return(idmap)
+      expect_any_instance_of(Entities::ExternalToConnec).to receive(:push_entities_to_connec).with([{entity: mapped_entity, idmap: idmap}])
+      subject
+    end
+
+    it 'does the right call to connec' do
+      expect(connec_client).to receive(:batch).with(batch_call)
+      subject
+      expect(Maestrano::Connector::Rails::IdMap.last.connec_id).to eql('connec-id')
+    end
+  end
+
+  describe 'updating an record in connec' do
+    before {
+      allow(connec_client).to receive(:batch).and_return(ActionDispatch::Response.new(201, {}, {results: [{status: 201, body: {people: {id: [{provider: 'connec', id: 'connec-id'}]}}}]}.to_json, {}))
+    }
+    let(:contact) { contact1.merge('FirstName' => 'Jacky') }
+    let(:mapped_entity) { mapped_entity1.merge(first_name: 'Jacky') }
+    let!(:idmap) { Entities::ExternalToConnec.create_idmap(organization_id: organization.id, external_id: ext_contact_id, connec_id: 'connec-id') }
+
+    it 'handles the idmap correctly' do
+      expect{
+        subject
+      }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
+      expect(idmap.reload.name).to eql('Jacky')
+      expect(idmap.reload.message).to be_nil
+    end
+
+    it 'does the mapping correctly' do
+      expect_any_instance_of(Entities::ExternalToConnec).to receive(:push_entities_to_connec).with([{entity: mapped_entity, idmap: idmap}])
+      subject
+    end
+
+    it 'does the right call to connec' do
+      expect(connec_client).to receive(:batch).with(batch_call)
+      subject
+    end
+  end
+end