global-registry-bindings 0.0.1

data/spec/models/person_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Person' do
+  describe ':push_entity_to_global_registry_async' do
+    it 'should enqueue sidekiq job' do
+      person = build(:person)
+      expect do
+        person.push_entity_to_global_registry_async
+      end.to change(GlobalRegistry::Bindings::Workers::PushGrEntityWorker.jobs, :size).by(1)
+    end
+  end
+
+  describe ':delete_entity_from_global_registry_async' do
+    it 'should enqueue sidekiq job' do
+      person = build(:person, global_registry_id: '22527d88-3cba-11e7-b876-129bd0521531')
+      expect do
+        person.delete_entity_from_global_registry_async
+      end.to change(GlobalRegistry::Bindings::Workers::DeleteGrEntityWorker.jobs, :size).by(1)
+    end
+
+    it 'should not enqueue sidekiq job when missing global_registry_id' do
+      person = build(:person)
+      expect do
+        person.delete_entity_from_global_registry_async
+      end.not_to change(GlobalRegistry::Bindings::Workers::DeleteGrEntityWorker.jobs, :size)
+    end
+  end
+
+  describe ':push_entity_to_global_registry' do
+    context 'create' do
+      let(:person) { create(:person) }
+
+      context '\'person\' entity_type does not exist' do
+        around { |example| travel_to Time.utc(2001, 2, 3), &example }
+        let!(:requests) do
+          [stub_request(:get, 'https://backend.global-registry.org/entity_types')
+            .with(query: { 'filters[name]' => 'person', 'filters[parent_id]' => nil })
+            .to_return(body: file_fixture('get_entity_types.json'), status: 200),
+           stub_request(:post, 'https://backend.global-registry.org/entity_types')
+             .with(body: { entity_type: { name: 'person', parent_id: nil, field_type: 'entity' } })
+             .to_return(body: file_fixture('post_entity_types_person.json'), status: 200),
+           stub_request(:post, 'https://backend.global-registry.org/entity_types')
+             .with(body: { entity_type: { name: 'first_name', parent_id: 'ee13a693-3ce7-4c19-b59a-30c8f137acd8',
+                                          field_type: 'string' } })
+             .to_return(status: 200),
+           stub_request(:post, 'https://backend.global-registry.org/entity_types')
+             .with(body: { entity_type: { name: 'last_name', parent_id: 'ee13a693-3ce7-4c19-b59a-30c8f137acd8',
+                                          field_type: 'string' } })
+             .to_return(status: 200),
+           stub_request(:post, 'https://backend.global-registry.org/entities')
+             .with(body: { entity: { person: { first_name: 'Tony', last_name: 'Stark',
+                                               client_integration_id: person.id,
+                                               client_updated_at: '2001-02-03 00:00:00',
+                                               authentication: {
+                                                 key_guid: '98711710-acb5-4a41-ba51-e0fc56644b53'
+                                               } } } })
+             .to_return(body: file_fixture('post_entities_person.json'), status: 200)]
+        end
+
+        it 'should create \'person\' entity_type and push entity' do
+          person.push_entity_to_global_registry
+          requests.each { |r| expect(r).to have_been_requested.once }
+          expect(person.global_registry_id).to eq '22527d88-3cba-11e7-b876-129bd0521531'
+        end
+      end
+
+      context '\'person\' entity_type exists' do
+        around { |example| travel_to Time.utc(2001, 2, 3), &example }
+        let!(:requests) do
+          [stub_request(:get, 'https://backend.global-registry.org/entity_types')
+            .with(query: { 'filters[name]' => 'person', 'filters[parent_id]' => nil })
+            .to_return(body: file_fixture('get_entity_types_person.json'), status: 200),
+           stub_request(:post, 'https://backend.global-registry.org/entities')
+             .with(body: { entity: { person: { first_name: 'Tony', last_name: 'Stark',
+                                               client_integration_id: person.id,
+                                               client_updated_at: '2001-02-03 00:00:00',
+                                               authentication: {
+                                                 key_guid: '98711710-acb5-4a41-ba51-e0fc56644b53'
+                                               } } } })
+             .to_return(body: file_fixture('post_entities_person.json'), status: 200)]
+        end
+
+        it 'should skip creating entity_type and push the entity' do
+          person.push_entity_to_global_registry
+          requests.each { |r| expect(r).to have_been_requested.once }
+          expect(person.global_registry_id).to eq '22527d88-3cba-11e7-b876-129bd0521531'
+        end
+      end
+
+      context 'partial \'person\' entity_type exists' do
+        around { |example| travel_to Time.utc(2001, 2, 3), &example }
+        let!(:requests) do
+          [stub_request(:get, 'https://backend.global-registry.org/entity_types')
+            .with(query: { 'filters[name]' => 'person', 'filters[parent_id]' => nil })
+            .to_return(body: file_fixture('get_entity_types_person_partial.json'), status: 200),
+           stub_request(:post, 'https://backend.global-registry.org/entity_types')
+             .with(body: { entity_type: { name: 'first_name', parent_id: 'ee13a693-3ce7-4c19-b59a-30c8f137acd8',
+                                          field_type: 'string' } })
+             .to_return(status: 200),
+           stub_request(:post, 'https://backend.global-registry.org/entities')
+             .with(body: { entity: { person: { first_name: 'Tony', last_name: 'Stark',
+                                               client_integration_id: person.id,
+                                               client_updated_at: '2001-02-03 00:00:00',
+                                               authentication: {
+                                                 key_guid: '98711710-acb5-4a41-ba51-e0fc56644b53'
+                                               } } } })
+             .to_return(body: file_fixture('post_entities_person.json'), status: 200)]
+        end
+
+        it 'should skip creating entity_type and push the entity' do
+          person.push_entity_to_global_registry
+          requests.each { |r| expect(r).to have_been_requested.once }
+          expect(person.global_registry_id).to eq '22527d88-3cba-11e7-b876-129bd0521531'
+        end
+      end
+
+      context '\'person\' entity_type is cached' do
+        around { |example| travel_to Time.utc(2001, 2, 3), &example }
+        before :each do
+          person_entity_types = JSON.parse(file_fixture('get_entity_types_person.json').read)
+          Rails.cache.write('GlobalRegistry::Bindings::EntityType::person', person_entity_types['entity_types'].first)
+        end
+
+        it 'should skip creating entity_type and push the entity' do
+          request = stub_request(:post, 'https://backend.global-registry.org/entities')
+                    .with(body: { entity: { person: { first_name: 'Tony', last_name: 'Stark',
+                                                      client_integration_id: person.id,
+                                                      client_updated_at: '2001-02-03 00:00:00',
+                                                      authentication: {
+                                                        key_guid: '98711710-acb5-4a41-ba51-e0fc56644b53'
+                                                      } } } })
+                    .to_return(body: file_fixture('post_entities_person.json'), status: 200)
+          person.push_entity_to_global_registry
+          expect(request).to have_been_requested.once
+          expect(person.global_registry_id).to eq '22527d88-3cba-11e7-b876-129bd0521531'
+        end
+      end
+    end
+
+    context 'update' do
+      let(:person) { create(:person, global_registry_id: 'f8d20318-2ff2-4a98-a5eb-e9d840508bf1') }
+      context '\'person\' entity_type is cached' do
+        around { |example| travel_to Time.utc(2001, 2, 3), &example }
+        before :each do
+          person_entity_types = JSON.parse(file_fixture('get_entity_types_person.json').read)
+          Rails.cache.write('GlobalRegistry::Bindings::EntityType::person', person_entity_types['entity_types'].first)
+        end
+
+        it 'should skip creating entity_type and update the entity' do
+          request = stub_request(:put,
+                                 'https://backend.global-registry.org/entities/f8d20318-2ff2-4a98-a5eb-e9d840508bf1')
+                    .with(body: { entity: { person: { first_name: 'Tony', last_name: 'Stark',
+                                                      client_integration_id: person.id,
+                                                      client_updated_at: '2001-02-03 00:00:00',
+                                                      authentication: {
+                                                        key_guid: '98711710-acb5-4a41-ba51-e0fc56644b53'
+                                                      } } } })
+                    .to_return(body: file_fixture('post_entities_person.json'), status: 200)
+          person.push_entity_to_global_registry
+          expect(request).to have_been_requested.once
+        end
+
+        context 'invalid entity id' do
+          let!(:requests) do
+            [stub_request(:put,
+                          'https://backend.global-registry.org/entities/f8d20318-2ff2-4a98-a5eb-e9d840508bf1')
+              .with(body: { entity: { person: { first_name: 'Tony', last_name: 'Stark',
+                                                client_integration_id: person.id,
+                                                client_updated_at: '2001-02-03 00:00:00',
+                                                authentication: {
+                                                  key_guid: '98711710-acb5-4a41-ba51-e0fc56644b53'
+                                                } } } })
+              .to_return(status: 404),
+             stub_request(:post, 'https://backend.global-registry.org/entities')
+               .with(body: { entity: { person: { first_name: 'Tony', last_name: 'Stark',
+                                                 client_integration_id: person.id,
+                                                 client_updated_at: '2001-02-03 00:00:00',
+                                                 authentication: {
+                                                   key_guid: '98711710-acb5-4a41-ba51-e0fc56644b53'
+                                                 } } } })
+               .to_return(body: file_fixture('post_entities_person.json'), status: 200)]
+          end
+
+          it 'should push entity as create' do
+            person.push_entity_to_global_registry
+            requests.each { |r| expect(r).to have_been_requested.once }
+            expect(person.global_registry_id).to eq '22527d88-3cba-11e7-b876-129bd0521531'
+          end
+        end
+      end
+    end
+  end
+
+  describe ':pull_mdm_id_from_global_registry_async' do
+    it 'should enqueue sidekiq job' do
+      person = build(:person)
+      expect do
+        person.pull_mdm_id_from_global_registry_async
+      end.to change(GlobalRegistry::Bindings::Workers::PullNamespacedPersonMdmIdWorker.jobs, :size).by(1)
+    end
+  end
+
+  describe ':pull_mdm_id_from_global_registry' do
+    context 'record missing global_registry_id' do
+      let(:person) { create(:person) }
+
+      it 'should raise an exception' do
+        expect do
+          person.pull_mdm_id_from_global_registry
+        end.to raise_error GlobalRegistry::Bindings::RecordMissingGlobalRegistryId
+      end
+    end
+
+    context 'entity missing mdm id' do
+      let(:person) { create(:person, global_registry_id: '22527d88-3cba-11e7-b876-129bd0521531') }
+      let!(:request) do
+        stub_request(:get, 'https://backend.global-registry.org/entities/22527d88-3cba-11e7-b876-129bd0521531')
+          .with(query: { 'filters[owned_by]' => 'mdm' })
+          .to_return(body: file_fixture('get_entities_person.json'), status: 200)
+      end
+
+      it 'should raise an exception' do
+        expect do
+          person.pull_mdm_id_from_global_registry
+        end.to raise_error GlobalRegistry::Bindings::EntityMissingMdmId
+      end
+    end
+
+    context 'entity missing mdm id' do
+      let(:person) { create(:person, global_registry_id: '22527d88-3cba-11e7-b876-129bd0521531') }
+      let!(:request) do
+        stub_request(:get, 'https://backend.global-registry.org/entities/22527d88-3cba-11e7-b876-129bd0521531')
+          .with(query: { 'filters[owned_by]' => 'mdm' })
+          .to_return(body: file_fixture('get_entities_person_mdm.json'), status: 200)
+      end
+
+      it 'should raise an exception' do
+        expect do
+          person.pull_mdm_id_from_global_registry
+          expect(person.global_registry_mdm_id).to eq 'c81340b2-7e57-4978-b6b9-396f21bb0bb2'
+        end.not_to raise_error
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler/setup'
+require 'pry'
+
+require 'active_record'
+ActiveRecord::Migration.verbose = false
+
+require 'combustion'
+Combustion.initialize! :active_record
+
+require 'rspec/rails'
+require 'webmock/rspec'
+require 'factory_girl'
+require 'simplecov'
+
+require 'global_registry_bindings'
+
+require 'sidekiq/testing'
+require 'sidekiq_unique_jobs/testing'
+Sidekiq::Testing.fake!
+
+require 'mock_redis'
+MOCK_REDIS = MockRedis.new
+
+ActionController::Base.cache_store = :memory_store
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.file_fixture_path = 'spec/fixtures'
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+  config.include ActiveSupport::Testing::TimeHelpers
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:suite) do
+    FactoryGirl.find_definitions
+  end
+
+  config.before(:each) do
+    MOCK_REDIS.keys.each do |key|
+      MOCK_REDIS.del(key)
+    end
+
+    SidekiqUniqueJobs.configure do |c|
+      c.redis_test_mode = :mock
+    end
+    allow(Sidekiq).to receive(:redis).and_yield(MOCK_REDIS)
+
+    Sidekiq::Queues.clear_all
+    Sidekiq::Worker.clear_all
+    Rails.cache.clear
+  end
+end

data/spec/workers/delete_gr_entity_worker_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'GlobalRegistry::Bindings::Workers' do
+  describe 'DeleteGrEntityWorker' do
+    context 'valid global_registry_id' do
+      let!(:request) do
+        stub_request(:delete, 'https://backend.global-registry.org/entities/22527d88-3cba-11e7-b876-129bd0521531')
+          .to_return(status: 200)
+      end
+
+      it 'should delete the entity' do
+        worker = GlobalRegistry::Bindings::Workers::DeleteGrEntityWorker.new
+        worker.perform('22527d88-3cba-11e7-b876-129bd0521531')
+        expect(request).to have_been_requested.once
+      end
+    end
+
+    context 'unknown global_registry_id' do
+      let!(:request) do
+        stub_request(:delete, 'https://backend.global-registry.org/entities/22527d88-3cba-11e7-b876-129bd0521531')
+          .to_return(status: 404)
+      end
+
+      it 'should delete the entity' do
+        worker = GlobalRegistry::Bindings::Workers::DeleteGrEntityWorker.new
+        worker.perform('22527d88-3cba-11e7-b876-129bd0521531')
+        expect(request).to have_been_requested.once
+      end
+    end
+  end
+end

data/spec/workers/pull_mdm_id_worker_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'GlobalRegistry::Bindings::Workers' do
+  describe 'PullMdmIdWorker' do
+    let(:user) { create(:person) }
+
+    it 'sends :pull_mdm_id_from_global_registry to the model instance' do
+      allow(Namespaced::Person).to receive(:pull_mdm_id_from_global_registry)
+      expect(Namespaced::Person).to receive(:find).with(user.id).and_return(user)
+      expect(user).to receive(:pull_mdm_id_from_global_registry)
+
+      worker_name = "GlobalRegistry::Bindings::Workers::#{Namespaced::Person.global_registry.mdm_worker_class_name}"
+      worker = worker_name.constantize.new
+      worker.perform(Namespaced::Person, user.id)
+    end
+
+    it 'fails silently on ActiveRecord::RecordNotFound' do
+      allow(Namespaced::Person).to receive(:pull_mdm_id_from_global_registry)
+      expect(Namespaced::Person).to receive(:find).with(user.id).and_raise(ActiveRecord::RecordNotFound)
+      expect(user).not_to receive(:pull_mdm_id_from_global_registry)
+
+      worker_name = "GlobalRegistry::Bindings::Workers::#{Namespaced::Person.global_registry.mdm_worker_class_name}"
+      worker = worker_name.constantize.new
+      worker.perform(Namespaced::Person, user.id)
+    end
+
+    it 'logs a message on RestClient::ResourceNotFound' do
+      allow(Namespaced::Person).to receive(:pull_mdm_id_from_global_registry)
+      expect(Namespaced::Person).to receive(:find).with(user.id).and_raise(RestClient::ResourceNotFound)
+      expect(user).not_to receive(:pull_mdm_id_from_global_registry)
+      expect(Rails.logger).to receive(:info).with('GR entity for GlobalRegistry::Bindings::Workers::PullNamespaced' \
+                                                  'PersonMdmIdWorker 1 does not exist; will _not_ retry')
+
+      worker_name = "GlobalRegistry::Bindings::Workers::#{Namespaced::Person.global_registry.mdm_worker_class_name}"
+      worker = worker_name.constantize.new
+      worker.perform(Namespaced::Person, user.id)
+    end
+  end
+
+  describe 'mdm_worker_class' do
+    before do
+      module MdmTest
+        class Klass
+          def self.global_registry
+            @gr ||= Object.new
+          end
+        end
+      end
+    end
+    after do
+      MdmTest.send :remove_const, :Klass
+      GlobalRegistry::Bindings::Workers.send :remove_const, :PullMdmTestKlassMdmIdWorker
+    end
+
+    it 'generates worker class with mdm timeout set' do
+      expect(MdmTest::Klass.global_registry).to(
+        receive(:mdm_worker_class_name).and_return('PullMdmTestKlassMdmIdWorker')
+      )
+      expect(MdmTest::Klass.global_registry).to(
+        receive(:mdm_timeout).and_return(33.minutes)
+      )
+
+      GlobalRegistry::Bindings::Workers.mdm_worker_class(MdmTest::Klass)
+      expect(GlobalRegistry::Bindings::Workers.const_defined?(:PullMdmTestKlassMdmIdWorker)).to be true
+      expect(GlobalRegistry::Bindings::Workers::PullMdmTestKlassMdmIdWorker.get_sidekiq_options)
+        .to include('unique' => :until_timeout, 'unique_expiration' => 33.minutes)
+    end
+  end
+end

data/spec/workers/push_gr_entity_worker_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'GlobalRegistry::Bindings::Workers' do
+  describe 'PushGrEntityWorker' do
+    let(:user) { create(:person) }
+
+    it 'sends :push_entity_to_global_registry to the model instance' do
+      allow(Namespaced::Person).to receive(:push_entity_to_global_registry_async)
+      expect(Namespaced::Person).to receive(:find).with(user.id).and_return(user)
+      expect(user).to receive(:push_entity_to_global_registry)
+
+      worker = GlobalRegistry::Bindings::Workers::PushGrEntityWorker.new
+      worker.perform(Namespaced::Person, user.id)
+    end
+
+    it 'fails silently on ActiveRecord::RecordNotFound' do
+      allow(Namespaced::Person).to receive(:push_entity_to_global_registry_async)
+      expect(Namespaced::Person).to receive(:find).with(user.id).and_raise(ActiveRecord::RecordNotFound)
+      expect(user).not_to receive(:push_entity_to_global_registry)
+
+      worker = GlobalRegistry::Bindings::Workers::PushGrEntityWorker.new
+      worker.perform(Namespaced::Person, user.id)
+    end
+  end
+end

data/spec/workers/push_relationship_worker_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'GlobalRegistry::Bindings::Workers' do
+  describe 'PushRelationshipWorker' do
+    let(:user) { create(:person) }
+
+    it 'sends :push_relationship_to_global_registry to the model instance' do
+      allow(Namespaced::Person).to receive(:push_relationship_to_global_registry)
+      expect(Namespaced::Person).to receive(:find).with(user.id).and_return(user)
+      expect(user).to receive(:push_relationship_to_global_registry)
+
+      worker = GlobalRegistry::Bindings::Workers::PushRelationshipWorker.new
+      worker.perform(Namespaced::Person, user.id)
+    end
+
+    it 'fails silently on ActiveRecord::RecordNotFound' do
+      allow(Namespaced::Person).to receive(:push_relationship_to_global_registry)
+      expect(Namespaced::Person).to receive(:find).with(user.id).and_raise(ActiveRecord::RecordNotFound)
+      expect(user).not_to receive(:push_relationship_to_global_registry)
+
+      worker = GlobalRegistry::Bindings::Workers::PushRelationshipWorker.new
+      worker.perform(Namespaced::Person, user.id)
+    end
+  end
+end