maestrano-connector-rails 2.0.2.pre.RC6 → 2.0.2.pre.RC7

data/spec/integration/singleton_spec.rb

@@ -1,297 +0,0 @@
-require 'spec_helper'
-
-describe 'singleton workflow' do
-
-  class Entities::SingletonIntegration < Maestrano::Connector::Rails::Entity
-    def self.external_entity_name
-      'Company'
-    end
-
-    def self.connec_entity_name
-      'Company'
-    end
-
-    def self.mapper_class
-      CompanyMapper
-    end
-
-    def self.object_name_from_connec_entity_hash(entity)
-      entity['name']
-    end
-
-    def self.object_name_from_external_entity_hash(entity)
-      entity['name']
-    end
-
-    def self.id_from_external_entity_hash(entity)
-      entity['id']
-    end
-
-    def self.last_update_date_from_external_entity_hash(entity)
-      entity['updated_at']
-    end
-
-    def self.singleton?
-      true
-    end
-
-    class CompanyMapper
-      extend HashMapper
-      map from('id'), to('id')
-      map from('name'), to('name')
-    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_comp_id) { 'ext comp id' }
-  let(:connec_updated) { 1.hour.ago }
-  let(:ext_updated) { 1.hour.ago }
-  let(:company_base) {
-    {
-      "name" => "My awesome company",
-      "updated_at" => connec_updated.iso8601
-    }
-  }
-
-  let(:ext_company_base) {
-    {
-      'id' => ext_comp_id,
-      'name' => 'My not so awesome store',
-      'updated_at' => ext_updated.iso8601
-    }
-  }
-
-  let(:mapped_connec_entity) {
-    {
-      id: ext_comp_id,
-      name: "My awesome company"
-    }
-  }
-
-  let(:mapped_external_entity) {
-    {
-      id: [
-        {
-          :id=>ext_comp_id,
-          :provider=>provider,
-          :realm=>oauth_uid
-        }
-      ],
-      name: 'My not so awesome store'
-    }
-  }
-
-  let(:synchronized_entity) { "singleton_integration" }
-
-
-  before {
-    allow(connec_client).to receive(:get).and_return(ActionDispatch::Response.new(200, {}, {company: company}.to_json, {}))
-    allow_any_instance_of(Entities::SingletonIntegration).to receive(:get_external_entities).and_return(ext_company)
-    allow_any_instance_of(Entities::SingletonIntegration).to receive(:update_external_entity).and_return(nil)
-    allow(connec_client).to receive(:batch).and_return(ActionDispatch::Response.new(200, {}, {results: [{status: 200, body: {company: {id: [{provider: 'connec', id: 'some connec id'}]}}}]}.to_json, {}))
-    allow(Maestrano::Connector::Rails::External).to receive(:entities_list).and_return([synchronized_entity])
-    organization.reset_synchronized_entities(true)
-  }
-
-  subject { Maestrano::Connector::Rails::SynchronizationJob.new.sync_entity(synchronized_entity, organization, connec_client, external_client, nil, {}) }
-
-
-  describe 'when no idmap' do
-
-    describe 'when received both' do
-      let(:company) { company_base.merge('id' => [{'id' => 'some connec id', 'provider' => 'connec', 'realm' => organization.uid}]) }
-      let(:ext_company) { [ext_company_base] }
-
-      context 'when connec most recent' do
-        let(:connec_updated) { 1.second.ago }
-        let(:batch_params) {
-          {
-            :sequential => true,
-            :ops => [
-              {
-                :method => "put",
-                :url => "/api/v2/#{organization.uid}/company/some connec id",
-                :params => {
-                  :company => {
-                    id: [
-                      {
-                        :id => "ext comp id",
-                        :provider => "provider",
-                        :realm => "oauth uid"
-                      }
-                    ]
-                  }
-                }
-              }
-            ]
-          }
-        }
-
-        it 'handles the get correctly' do
-          expect_any_instance_of(Entities::SingletonIntegration).to receive(:consolidate_and_map_data).with([company], ext_company).and_return({connec_entities: [], external_entities: []})
-          subject
-        end
-
-        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('My awesome company')
-          expect(idmap.connec_entity).to eql('company')
-          expect(idmap.external_entity).to eql('company')
-          expect(idmap.message).to be_nil
-          expect(idmap.external_id).to eql(ext_comp_id)
-          expect(idmap.connec_id).to eql('some connec id')
-        end
-
-        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, 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
-
-      context 'when external most recent' do
-        let(:external_updated) { 1.second.ago }
-
-        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('My not so awesome store')
-          expect(idmap.connec_entity).to eql('company')
-          expect(idmap.external_entity).to eql('company')
-          expect(idmap.message).to be_nil
-          expect(idmap.external_id).to eql(ext_comp_id)
-        end
-
-        it 'does the mapping correctly' do
-          idmap = Entities::SingletonIntegration.create_idmap(organization_id: organization.id, external_id: ext_comp_id)
-          allow(Entities::SingletonIntegration).to receive(:create_idmap).and_return(idmap)
-          expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_connec).with([{entity: mapped_external_entity, idmap: idmap}])
-          subject
-        end
-      end
-    end
-  end
-
-
-
-  describe 'when idmap exists' do
-    describe 'when received both' do
-      let(:company) { company_base.merge('id' => [{'id' => ext_comp_id, 'provider' => provider, 'realm' => oauth_uid}, {'id' => 'connec-id', 'provider' => 'connec', 'realm' => 'some-realm'}]) }
-      let(:ext_company) { [ext_company_base] }
-      let!(:idmap) { Entities::SingletonIntegration.create_idmap(organization_id: organization.id, external_id: ext_comp_id) }
-
-      context 'when connec most recent' do
-        let(:connec_updated) { 1.second.ago }
-
-        it 'handles the idmap correctly' do
-          expect{
-            subject
-          }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
-          idmap = Maestrano::Connector::Rails::IdMap.last
-          expect(idmap.name).to eql('My awesome company')
-          expect(idmap.connec_entity).to eql('company')
-          expect(idmap.external_entity).to eql('company')
-          expect(idmap.message).to be_nil
-          expect(idmap.external_id).to eql(ext_comp_id)
-        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, id_refs_only_connec_entity: {}}])
-          subject
-        end
-
-        it 'does not map the external one' do
-          expect_any_instance_of(Entities::SingletonIntegration).to_not receive(:map_to_connec)
-          subject
-        end
-      end
-
-      context 'when external most recent' do
-        let(:external_updated) { 1.second.ago }
-
-        it 'handles the idmap correctly' do
-          expect{
-            subject
-          }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
-          idmap = Maestrano::Connector::Rails::IdMap.last
-          expect(idmap.name).to eql('My not so awesome store')
-          expect(idmap.connec_entity).to eql('company')
-          expect(idmap.external_entity).to eql('company')
-          expect(idmap.message).to be_nil
-          expect(idmap.external_id).to eql(ext_comp_id)
-        end
-
-        it 'does the mapping correctly' do
-          expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_connec).with([{entity: mapped_external_entity, idmap: idmap}])
-          subject
-        end
-
-        it 'does not map the external one' do
-          expect_any_instance_of(Entities::SingletonIntegration).to_not receive(:map_to_external)
-          subject
-        end
-      end
-    end
-  end
-
-  describe 'when received only connec one' do
-    let(:company) { company_base.merge('id' => [{'id' => ext_comp_id, 'provider' => provider, 'realm' => oauth_uid}, {'id' => 'connec-id', 'provider' => 'connec', 'realm' => 'some-realm'}]) }
-    let(:ext_company) { [] }
-    let!(:idmap) { Entities::SingletonIntegration.create_idmap(organization_id: organization.id, external_id: ext_comp_id) }
-
-    it 'handles the idmap correctly' do
-      expect{
-        subject
-      }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
-      idmap = Maestrano::Connector::Rails::IdMap.last
-      expect(idmap.name).to eql('My awesome company')
-      expect(idmap.connec_entity).to eql('company')
-      expect(idmap.external_entity).to eql('company')
-      expect(idmap.message).to be_nil
-      expect(idmap.external_id).to eql(ext_comp_id)
-    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, id_refs_only_connec_entity: {}}])
-      subject
-    end
-  end
-
-  describe 'when receive only external one' do
-    let(:company) { [] }
-    let(:ext_company) { [ext_company_base] }
-    let!(:idmap) { Entities::SingletonIntegration.create_idmap(organization_id: organization.id, external_id: ext_comp_id) }
-
-    it 'handles the idmap correctly' do
-      expect{
-        subject
-      }.to_not change{ Maestrano::Connector::Rails::IdMap.count }
-      idmap = Maestrano::Connector::Rails::IdMap.last
-      expect(idmap.name).to eql('My not so awesome store')
-      expect(idmap.connec_entity).to eql('company')
-      expect(idmap.external_entity).to eql('company')
-      expect(idmap.message).to be_nil
-      expect(idmap.external_id).to eql(ext_comp_id)
-    end
-
-    it 'does the mapping correctly' do
-      expect_any_instance_of(Entities::SingletonIntegration).to receive(:push_entities_to_connec).with([{entity: mapped_external_entity, idmap: idmap}])
-      subject
-    end
-  end
-end

data/spec/jobs/all_synchronizations_job_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Maestrano::Connector::Rails::AllSynchronizationsJob do
-  let(:organization_not_linked) { create(:organization, oauth_provider: 'salesforce', oauth_token: nil, sync_enabled: true) }
-  let(:organization_not_active) { create(:organization, oauth_provider: 'salesforce', oauth_token: '123', sync_enabled: 0) }
-  let(:organization_to_process) { create(:organization, oauth_provider: 'salesforce', oauth_token: '123', sync_enabled: true) }
-
-  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.id, anything)
-      expect(Maestrano::Connector::Rails::SynchronizationJob).to_not receive(:perform_later).with(organization_not_active.id, anything)
-      expect(Maestrano::Connector::Rails::SynchronizationJob).to receive(:perform_later).with(organization_to_process.id, anything)
-
-      subject
-    end
-  end
-end

data/spec/jobs/push_to_connec_job_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe Maestrano::Connector::Rails::PushToConnecJob do
-  let(:organization) { create(:organization) }
-  let(:entity_name1) { 'entity1' }
-  let(:entity_name2) { 'entity2' }
-  before {
-    class Entities::Entity1 < Maestrano::Connector::Rails::Entity
-    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')
-    class Entities::Entity2 < Maestrano::Connector::Rails::ComplexEntity
-    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(['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
-    end
-    allow(Maestrano::Connector::Rails::Entity).to receive(:entities_list).and_return([entity_name1, entity_name2])
-    allow(Maestrano::Connector::Rails::Entity).to receive(:id_from_external_entity_hash).and_return('11')
-  }
-  let(:entity11) { {first_name: 'John'} }
-  let(:entity12) { {first_name: 'Jane'} }
-  let(:entity21) { {job: 'Pizza guy'} }
-  let(:hash) { {'ext_entity1' => [entity11, entity12], 'Subs' => [entity21]} }
-  subject { Maestrano::Connector::Rails::PushToConnecJob.perform_now(organization, hash) }
-
-  describe 'with organization sync enabled set to false' do
-    before { organization.update(sync_enabled: false, oauth_uid: 'lala') }
-
-    it 'does nothing' do
-      expect(Maestrano::Connec::Client).to_not receive(:new)
-      subject
-    end
-  end
-
-  describe 'with no oauth uid' do
-    before { organization.update(sync_enabled: true, oauth_uid: nil) }
-
-    it 'does nothing' do
-      expect(Maestrano::Connec::Client).to_not receive(:new)
-      subject
-    end
-  end
-
-  describe 'with sync enabled and an oauth uid' do
-    before { organization.update(sync_enabled: true, oauth_uid: 'lala') }
-
-    describe 'with a non existing entity' do
-      let(:hash) { {'lala' => []} }
-
-      it 'logs a warning' do
-        expect(Rails.logger).to receive(:warn)
-        subject
-      end
-    end
-
-    describe 'with entities in synchronized entities' do
-
-      describe 'complex entity' do
-        let(:hash1) { {can_push_to_connec: false, can_push_to_external: false} }
-        let(:hash2) { {can_push_to_connec: true, can_push_to_external: true} }
-        before { organization.update(synchronized_entities: {:"#{entity_name1}" => hash1, :"#{entity_name2}" => hash2})}
-
-        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({"Connec name" => []}, {"Subs"=>[entity21], "ll"=>[]})
-          expect_any_instance_of(Entities::Entity2).to receive(:push_entities_to_connec)
-          subject
-        end
-
-        it 'does not calls methods on the non complex entity' do
-          expect_any_instance_of(Entities::Entity1).to_not receive(:consolidate_and_map_data)
-          subject
-        end
-
-        it 'calls before and after sync' do
-          expect_any_instance_of(Entities::Entity2).to receive(:before_sync)
-          expect_any_instance_of(Entities::Entity2).to receive(:after_sync)
-          subject
-        end
-      end
-
-      describe 'non complex entity' do
-        let(:hash1) { {can_push_to_connec: true, can_push_to_external: true} }
-        let(:hash2) { {can_push_to_connec: false, can_push_to_external: false} }
-        before { organization.update(synchronized_entities: {:"#{entity_name1}" => hash1, :"#{entity_name2}" => hash2})}
-
-        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]).and_return({})
-          expect_any_instance_of(Entities::Entity1).to receive(:push_entities_to_connec)
-          subject
-        end
-
-        it 'does not calls methods on the complex entity' do
-          allow_any_instance_of(Entities::Entity1).to receive(:consolidate_and_map_data).and_return({})
-          expect_any_instance_of(Entities::Entity2).to_not receive(:consolidate_and_map_data)
-          subject
-        end
-
-        it 'calls before and after sync' do
-          allow_any_instance_of(Entities::Entity1).to receive(:consolidate_and_map_data).and_return({})
-          expect_any_instance_of(Entities::Entity1).to receive(:before_sync)
-          expect_any_instance_of(Entities::Entity1).to receive(:after_sync)
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/jobs/push_to_connec_worker_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require 'sidekiq/testing'
-
-describe Maestrano::Connector::Rails::PushToConnecWorker do
-  describe 'class methods' do
-    let(:organization) { create(:organization) }
-    subject { Maestrano::Connector::Rails::PushToConnecWorker }
-
-    Sidekiq::Testing.fake!
-    it 'perform_async add a new job' do
-      expect_any_instance_of(Maestrano::Connector::Rails::PushToConnecJob).to receive(:perform)
-      expect {
-        subject.perform_async(organization.id, 2, 3)
-      }.to change(subject.jobs, :size).by(1)
-
-      expect {
-        subject.drain
-      }.to change(subject.jobs, :size).by(-1)
-    end
-
-    it 'raise an error if the organization can t be found' do
-      subject.perform_async(-1, 2, 3)
-      expect {
-        subject.drain
-      }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-
-    describe 'unique_args' do
-      it do
-        entities_hash = {entity_2: [{'id': 'id2'}, {'id': 'id1'}], entity_1: [{'id': 'id4'}, {'id': nil}, {'id': 'id3'}, {'id': 'id3'}]}
-        expect(subject.unique_args([organization.id, entities_hash])).to eq([organization.id, [:entity_1, :entity_2]])
-      end
-    end
-  end
-end
-