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

data/spec/models/external_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Maestrano::Connector::Rails::External do
-  subject { Maestrano::Connector::Rails::External }
-
-  before {
-    allow(Maestrano::Connector::Rails::External).to receive(:external_name).and_call_original
-    allow(Maestrano::Connector::Rails::External).to receive(:get_client).and_call_original
-    allow(Maestrano::Connector::Rails::External).to receive(:entities_list).and_call_original
-  }
-
-  describe 'external_name' do
-    it { expect{ subject.external_name }.to raise_error(RuntimeError) }
-  end
-
-  describe 'get_client' do
-    it { expect{ subject.get_client(nil) }.to raise_error(RuntimeError) }
-  end
-
-  describe 'entities_list' do
-    it { expect{ subject.entities_list }.to raise_error(RuntimeError) }
-  end
-
-  describe 'create_account_link' do
-    it { expect{ subject.create_account_link }.to raise_error(RuntimeError) }
-  end
-end

data/spec/models/id_map_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Maestrano::Connector::Rails::IdMap do
-
-  # Indexes
-  it { should have_db_index([:connec_id, :connec_entity, :organization_id]) }
-  it { should have_db_index([:external_id, :external_entity, :organization_id]) }
-  it { should have_db_index([:organization_id]) }
-
-  #Associations
-  it { should belong_to(:organization) }
-end

data/spec/models/organization_spec.rb

@@ -1,243 +0,0 @@
-require 'spec_helper'
-
-describe Maestrano::Connector::Rails::Organization do
-
-  # Attributes
-  it { should validate_presence_of(:name) }
-  it { should validate_presence_of(:tenant) }
-  it { should validate_uniqueness_of(:uid) }
-  it { should serialize(:synchronized_entities) }
-
-  # Indexes
-  it { should have_db_index([:uid, :tenant]) }
-
-  # Associations
-  it { should have_many(:user_organization_rels) }
-  it { should have_many(:users) }
-  it { should have_many(:id_maps).dependent(:destroy) }
-  it { should have_many(:synchronizations).dependent(:destroy) }
-
-  describe 'creation' do
-    subject { Maestrano::Connector::Rails::Organization.new }
-
-    it 'initializes the synchronized entities' do
-      entities_list = Maestrano::Connector::Rails::External.entities_list
-      expect(subject.synchronized_entities).to include(entities_list.first.to_sym)
-      expect(subject.synchronized_entities).to include(entities_list.last.to_sym)
-    end
-
-    it 'does not allow organizations with the same oauth UID' do
-      organization1 = create(:organization, oauth_provider: 'myapp', oauth_uid: 'ABC')
-      organization2 = build(:organization, oauth_provider: 'myapp', oauth_uid: 'ABC')
-      expect(organization2).not_to be_valid
-    end
-
-    it 'allows several organizations without oauth UID' do
-      organization1 = create(:organization, oauth_provider: 'myapp', oauth_uid: nil)
-      organization2 = build(:organization, oauth_provider: 'myapp', oauth_uid: nil)
-      expect(organization2).to be_valid
-    end
-  end
-
-  describe "instance methods" do
-    subject { create(:organization) }
-
-    describe 'add_member' do
-
-      context "when user is not from the same tenant" do
-        let(:user) { create(:user, tenant: 'zzz') }
-
-        it "does nothing" do
-          expect{
-            subject.add_member(user)
-          }.to change{Maestrano::Connector::Rails::UserOrganizationRel.count}.by(0)
-        end
-      end
-
-      context "when user is from the same tenant" do
-        let(:user) { create(:user) }
-
-        context "when user is already in the organization" do
-          before { create(:user_organization_rel, user: user, organization: subject) }
-
-          it "does nothing" do
-          expect{
-            subject.add_member(user)
-          }.to change{Maestrano::Connector::Rails::UserOrganizationRel.count}.by(0)
-          end
-        end
-
-        context "when user is not in the organization yet" do
-          it "does nothing" do
-            expect{
-              subject.add_member(user)
-            }.to change{Maestrano::Connector::Rails::UserOrganizationRel.count}.by(1)
-          end
-        end
-      end
-    end
-
-    describe 'member?' do
-      let(:user) { create(:user) }
-
-      context "when user is a member of the organization" do
-        before { create(:user_organization_rel, user: user, organization: subject) }
-
-        it { expect(subject.member?(user)).to be(true) }
-      end
-
-      context "when user is not a member of the organization" do
-        it { expect(subject.member?(user)).to be(false) }
-      end
-    end
-
-    describe 'remove_member' do
-      let(:user) { create(:user) }
-
-      context "when user is a member of the organization" do
-        before { create(:user_organization_rel, user: user, organization: subject) }
-
-        it "deletes the user_organization_rel" do
-          expect{
-            subject.remove_member(user)
-          }.to change{Maestrano::Connector::Rails::UserOrganizationRel.count}.by(-1)
-        end
-      end
-      context "when user is not a member of the organization" do
-        it "does nothing" do
-          expect{
-            subject.remove_member(user)
-          }.to change{Maestrano::Connector::Rails::UserOrganizationRel.count}.by(0)
-        end
-      end
-    end
-
-    describe 'from_omniauth' do
-      let(:saml_hash) { {provider: :maestrano, uid: 'cld-1234', info: {org_uid: 'org-abcd', name: 'My Company'}} }
-      let(:tenant) { 'mytenant' }
-
-      let(:subject) { Maestrano::Connector::Rails::Organization.find_or_create_for_maestrano(saml_hash, tenant) }
-
-      context 'with a new organization' do
-        it 'creates an organization from SAML parameters' do
-          expect(subject.name).to eql('My Company')
-          expect(subject.org_uid).to eql('org-abcd')
-          expect(subject.tenant).to eql(tenant)
-        end
-      end
-
-      context 'with an existing organization' do
-        let!(:organization) { create(:organization, provider: :maestrano, tenant: tenant, uid: 'cld-1234') }
-
-        it 'find the organization from SAML parameters' do
-          expect(subject).to eql(organization)
-        end
-      end
-    end
-
-    describe 'last_three_synchronizations_failed?' do
-      it 'returns true when last three syncs are failed' do
-        3.times do
-          subject.synchronizations.create(status: 'ERROR')
-        end
-        expect(subject.last_three_synchronizations_failed?).to be true
-      end
-
-      it 'returns false when on of the last three sync is success' do
-        subject.synchronizations.create(status: 'SUCCESS')
-        2.times do
-          subject.synchronizations.create(status: 'ERROR')
-        end
-
-        expect(subject.last_three_synchronizations_failed?).to be false
-      end
-
-      it 'returns false when no sync' do
-        expect(subject.last_three_synchronizations_failed?).to be false
-      end
-
-      it 'returns false when less than three sync' do
-        2.times do
-          subject.synchronizations.create(status: 'ERROR')
-        end
-
-        expect(subject.last_three_synchronizations_failed?).to be false
-      end
-    end
-
-    describe 'last_successful_synchronization' do
-      let!(:running_sync) { create(:synchronization, organization: subject, status: 'RUNNING') }
-      let!(:failed_sync) { create(:synchronization, organization: subject, status: 'ERROR') }
-      let!(:success_sync) { create(:synchronization, organization: subject, status: 'SUCCESS', updated_at: 1.minute.ago) }
-      let!(:success_sync2) { create(:synchronization, organization: subject, status: 'SUCCESS', updated_at: 3.hours.ago) }
-      let!(:partial) { create(:synchronization, organization: subject, status: 'SUCCESS', partial: true) }
-
-      it { expect(subject.last_successful_synchronization).to eql(success_sync) }
-    end
-
-    describe 'last_synchronization_date' do
-      let(:date) { 2.days.ago }
-
-      context 'with date_filtering_limit' do
-        before {
-          subject.date_filtering_limit = date
-        }
-
-        it { expect(subject.last_synchronization_date).to eql(date) }
-      end
-
-      context 'with sync' do
-        let!(:success_sync) { create(:synchronization, organization: subject, status: 'SUCCESS') }
-
-        it { expect(subject.last_synchronization_date.to_date).to eql(success_sync.updated_at.to_date) }
-      end
-
-      context 'with both' do
-        let!(:success_sync) { create(:synchronization, organization: subject, status: 'SUCCESS') }
-        before {
-          subject.date_filtering_limit = date
-        }
-
-        it 'returns the sync date' do
-          expect(subject.last_synchronization_date.to_date).to eql(success_sync.updated_at.to_date)
-        end
-      end
-
-      context 'with none' do
-        it { expect(subject.last_synchronization_date).to eql(nil) }
-      end
-    end
-
-    describe '#reset_synchronized_entities' 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} }
-      let(:organization) { create(:organization, synchronized_entities: {entity1: true, entity2: true, tomatoes: false}) }
-      subject { organization.reset_synchronized_entities }
-
-      it 'keeps only the known entities' do
-        subject
-        expect(organization.synchronized_entities).to eql(entity1: hash1, entity2: hash1)
-      end
-
-      it 'adds missing entities' do
-        organization.update_attributes(synchronized_entities: {entity1: true, tomatoes: false})
-
-        subject
-        expect(organization.synchronized_entities).to eql(entity1: hash1, entity2: hash2)
-      end
-
-      context 'with metadata from mnohub' do
-        before {
-          organization.push_disabled = true
-          organization.pull_disabled = true
-        }
-
-
-        it 'takes into account the metadata' do
-          subject
-          expect(organization.synchronized_entities).to eql(entity1: hash2, entity2: hash2)
-        end
-      end
-    end
-  end
-end

data/spec/models/sub_entity_base_spec.rb

@@ -1,155 +0,0 @@
-require 'spec_helper'
-
-describe Maestrano::Connector::Rails::SubEntityBase do
-  describe 'class methods' do
-    subject { Maestrano::Connector::Rails::SubEntityBase }
-
-    describe 'external?' do
-      it { expect{ subject.external? }.to raise_error('Not implemented') }
-    end
-
-    describe 'entity_name' do
-      it { expect{ subject.entity_name }.to raise_error('Not implemented') }
-    end
-
-    describe 'external_entity_name' do
-      context 'when entity is external' do
-        before(:each) do
-          allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:external?).and_return(true)
-          allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:entity_name).and_return('Name')
-        end
-
-        it 'returns the entity_name' do
-          expect(subject.external_entity_name).to eql('Name')
-        end
-      end
-
-      context 'when entity is not external' do
-        before do
-          allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:external?).and_return(false)
-        end
-        it { expect{ subject.external_entity_name }.to raise_error('Forbidden call: cannot call external_entity_name for a connec entity') }
-      end
-    end
-
-    describe 'connec_entity_name' do
-      context 'when entity is not external' do
-        before(:each) do
-          allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:external?).and_return(false)
-          allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:entity_name).and_return('Name')
-        end
-
-        it 'returns the entity_name' do
-          expect(subject.connec_entity_name).to eql('Name')
-        end
-      end
-
-      context 'when entity is external' do
-        before do
-          allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:external?).and_return(true)
-        end
-        it { expect{ subject.connec_entity_name }.to raise_error('Forbidden call: cannot call connec_entity_name for an external entity') }
-      end
-    end
-
-    describe 'names_hash' do
-      let(:bool) { true }
-      before do
-        allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:external?).and_return(bool)
-        allow(Maestrano::Connector::Rails::SubEntityBase).to receive(:entity_name).and_return('Name')
-      end
-
-      context 'when external' do
-        it { expect(subject.names_hash).to eql({external_entity: 'name'}) }
-      end
-      context 'when not external' do
-        let(:bool) { false }
-        it { expect(subject.names_hash).to eql({connec_entity: 'name'}) }
-      end
-    end
-
-    it { expect(subject.mapper_classes).to eql({}) }
-  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::SubEntityBase.new(organization, connec_client, external_client, opts) }
-
-    describe 'map_to' do
-      before do
-        class AMapper
-          extend HashMapper
-        end
-        allow(subject.class).to receive(:mapper_classes).and_return('Name' => AMapper)
-      end
-
-      describe 'failure' do
-        it { expect{ subject.map_to('Not an entity', {}) }.to raise_error(RuntimeError) }
-      end
-
-      context 'when external' do
-        before do
-          allow(subject.class).to receive(:external?).and_return(true)
-          allow(subject.class).to receive(:id_from_external_entity_hash).and_return('this id')
-        end
-
-        it 'calls the mapper denormalize' do
-          expect(AMapper).to receive(:denormalize).with({}, subject.instance_values).and_return({})
-          subject.map_to('Name', {})
-        end
-
-        it 'calls for reference folding' do
-          refs = %w(organization_id person_id)
-          allow(subject.class).to receive(:references).and_return({'Name' => refs})
-          expect(Maestrano::Connector::Rails::ConnecHelper).to receive(:fold_references).with({id: 'this id'}, refs, organization)
-          subject.map_to('Name', {})
-        end
-
-        it 'calls the creation_mapper_classes that delegates to the mapper_classes denormalize when passed true as a third argument' do
-          expect(subject.class).to receive(:creation_mapper_classes).and_call_original
-          expect(AMapper).to receive(:denormalize).with({}, subject.instance_values).and_return({})
-          subject.map_to('Name', {}, true)
-        end
-
-        context 'when no refs' do
-          it 'calls for reference folding' do
-            allow(subject.class).to receive(:references).and_return({})
-            expect(Maestrano::Connector::Rails::ConnecHelper).to receive(:fold_references).with({id: 'this id'}, [], organization)
-            subject.map_to('Name', {})
-          end
-        end
-
-        context 'when connec_matching_fields' do
-          before do
-            expect(AMapper).to receive(:denormalize).and_return({opts: {a: 2}})
-            allow(subject.class).to receive(:connec_matching_fields).and_return('matching_fields')
-          end
-
-          it 'adds the matching_fields in the entity opts' do
-            expect(subject.map_to('Name', {})).to eql({id: [Maestrano::Connector::Rails::ConnecHelper.id_hash('this id', organization)], opts: {a: 2, matching_fields: 'matching_fields'}}.with_indifferent_access)
-          end
-        end
-      end
-
-      context 'when not external' do
-        before do
-          allow(subject.class).to receive(:external?).and_return(false)
-        end
-
-        it 'calls the mapper normalize' do
-          expect(AMapper).to receive(:normalize).with({}, subject.instance_values).and_return({})
-          subject.map_to('Name', {})
-        end
-
-        it 'calls the creation_mapper_classes that delegates to the mapper_classes normalize when passed true as a third argument' do
-          expect(subject.class).to receive(:creation_mapper_classes).and_call_original
-          expect(AMapper).to receive(:normalize).with({}, subject.instance_values).and_return({})
-          subject.map_to('Name', {}, true)
-        end
-      end
-    end
-  end
-end

data/spec/models/synchronization_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe Maestrano::Connector::Rails::Synchronization do
-
-  # Attributes
-  it { should validate_presence_of(:status) }
-
-  # Indexes
-  it { should have_db_index(:organization_id) }
-
-  #Associations
-  it { should belong_to(:organization) }
-
-  describe 'class methods' do
-    subject { Maestrano::Connector::Rails::Synchronization }
-
-    describe 'create_running' do
-      let(:organization) { create(:organization) }
-
-      it 'creates an organization' do
-        expect{ subject.create_running(organization) }.to change{ Maestrano::Connector::Rails::Synchronization.count }.by(1)
-      end
-
-      it { expect(subject.create_running(organization).status).to eql('RUNNING') }
-    end
-  end
-
-  describe 'instance methods' do
-    describe 'success?' do
-      it { expect(Maestrano::Connector::Rails::Synchronization.new(status: 'SUCCESS').success?).to be(true) }
-      it { expect(Maestrano::Connector::Rails::Synchronization.new(status: 'ERROR').success?).to be(false) }
-    end
-
-    describe 'error?' do
-      it { expect(Maestrano::Connector::Rails::Synchronization.new(status: 'ERROR').error?).to be(true) }
-      it { expect(Maestrano::Connector::Rails::Synchronization.new(status: 'RUNNING').error?).to be(false) }
-    end
-
-    describe 'running?' do
-      it { expect(Maestrano::Connector::Rails::Synchronization.new(status: 'RUNNING').running?).to be(true) }
-      it { expect(Maestrano::Connector::Rails::Synchronization.new(status: 'ERROR').running?).to be(false) }
-    end
-
-    describe 'set_success' do
-      let(:sync) { create(:synchronization, status: 'RUNNING') }
-
-      it 'set the synchronization status to success' do
-        sync.set_success
-        sync.reload
-        expect(sync.status).to eql('SUCCESS')
-      end
-    end
-
-    describe 'set_error' do
-      let(:sync) { create(:synchronization, status: 'RUNNING') }
-
-      it 'set the synchronization status to error with the message' do
-        sync.set_error('msg')
-        sync.reload
-        expect(sync.status).to eql('ERROR')
-        expect(sync.message).to eql('msg')
-      end
-    end
-
-    describe 'set_partial' do
-      let(:sync) { create(:synchronization, partial: false) }
-
-      it 'set the synchronization status to error with the message' do
-        sync.set_partial
-        sync.reload
-        expect(sync.partial).to be(true)
-      end
-    end
-
-    describe 'clean_synchronizations on creation' do
-      let!(:organization) { create(:organization) }
-
-      context 'when less than 100 syncs' do
-        before {
-          2.times do
-            create(:synchronization, organization: organization)
-          end
-        }
-
-        it 'does nothing' do
-          expect{ organization.synchronizations.create(status: 'RUNNING') }.to change{ organization.synchronizations.count }.by(1)
-        end
-      end
-
-      context 'when more than 100 syncs' do
-        before {
-          100.times do
-            create(:synchronization, organization: organization)
-          end
-        }
-
-        it 'destroy the right syncs' do
-          sync = organization.synchronizations.create(status: 'RUNNING')
-          expect(Maestrano::Connector::Rails::Synchronization.count).to eql(100)
-          expect(Maestrano::Connector::Rails::Synchronization.all.map(&:id)).to eql([*2..101])
-        end
-
-      end
-    end
-  end
-end