global-registry-bindings 0.6.2 → 0.6.3

data/spec/workers/delete_gr_entity_worker_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe GlobalRegistry::Bindings::Workers::DeleteEntityWorker do
-  context 'entity 22527d88-3cba-11e7-b876-129bd0521531' 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::DeleteEntityWorker.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::DeleteEntityWorker.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

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe GlobalRegistry::Bindings::Workers::PullMdmIdWorker do
-  context Namespaced::Person do
-    let(:person) { create(:person) }
-
-    context 'with valid id' do
-      it 'should call #pull_mdm_id_from_global_registry' do
-        expect(Namespaced::Person).to receive(:find).with(person.id).and_return(person)
-
-        worker_name =
-          "GlobalRegistry::Bindings::Workers::#{Namespaced::Person.global_registry_entity.mdm_worker_class_name}"
-        worker = worker_name.constantize.new
-        expect(worker).to receive(:pull_mdm_id_from_global_registry)
-        worker.perform('Namespaced::Person', person.id)
-        expect(worker.model).to be person
-      end
-    end
-
-    context ActiveRecord::RecordNotFound do
-      it 'should fail silently' do
-        expect(Namespaced::Person).to receive(:find).with(person.id).and_raise(ActiveRecord::RecordNotFound)
-        expect(GlobalRegistry::Bindings::Workers::PullMdmIdWorker).not_to receive(:pull_mdm_id_from_global_registry)
-
-        worker_name =
-          "GlobalRegistry::Bindings::Workers::#{Namespaced::Person.global_registry_entity.mdm_worker_class_name}"
-        worker = worker_name.constantize.new
-        worker.perform(Namespaced::Person, person.id)
-        expect(worker.model).to be nil
-      end
-    end
-
-    context RestClient::ResourceNotFound do
-      it 'should log a message' do
-        expect(Namespaced::Person).to receive(:find).with(person.id).and_raise(RestClient::ResourceNotFound)
-        expect(GlobalRegistry::Bindings::Workers::PullMdmIdWorker).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_entity.mdm_worker_class_name}"
-        worker = worker_name.constantize.new
-        worker.perform(Namespaced::Person, person.id)
-        expect(worker.model).to be nil
-      end
-    end
-  end
-
-  describe '#pull_mdm_id_from_global_registry' do
-    context Namespaced::Person do
-      let(:worker) { GlobalRegistry::Bindings::Workers::PullNamespacedPersonMdmIdWorker.new }
-      before do
-        worker.model = person
-      end
-
-      context 'model missing global_registry_id' do
-        let(:person) { create(:person) }
-
-        it 'should raise an exception' do
-          expect do
-            worker.pull_mdm_id_from_global_registry
-          end.to raise_error GlobalRegistry::Bindings::RecordMissingGlobalRegistryId,
-                             "Namespaced::Person(#{person.id}) has no global_registry_id; will retry"
-        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
-            worker.pull_mdm_id_from_global_registry
-          end.to raise_error GlobalRegistry::Bindings::EntityMissingMdmId,
-                             "GR entity #{person.global_registry_id} for Namespaced::Person(#{person.id}) has " \
-                             'no mdm id; will retry'
-        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
-            worker.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
-
-  describe '#mdm_worker_class' do
-    before do
-      module MdmTest
-        class Klass
-          def self.global_registry_entity
-            @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_entity).to(
-        receive(:mdm_worker_class_name).and_return('PullMdmTestKlassMdmIdWorker')
-      )
-      expect(MdmTest::Klass.global_registry_entity).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_entity_worker_spec.rb

@@ -1,506 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe GlobalRegistry::Bindings::Workers::PushEntityWorker do
-  around { |example| travel_to Time.utc(2001, 2, 3), &example }
-  describe '#perform(model_class, id)' do
-    context Namespaced::Person do
-      let(:person) { create(:person) }
-      context 'with valid id' do
-        it 'should call #push_entity_to_global_registry' do
-          expect(Namespaced::Person).to receive(:find).with(person.id).and_return(person)
-
-          worker = GlobalRegistry::Bindings::Workers::PushEntityWorker.new
-          expect(worker).to receive(:push_entity_to_global_registry)
-          worker.perform('Namespaced::Person', person.id)
-          expect(worker.model).to be person
-        end
-      end
-
-      context 'with valid id and fingerprint' do
-        it 'should call #push_entity_to_global_registry' do
-          expect(Namespaced::Person).to receive(:find).with(person.id).and_return(person)
-
-          worker = GlobalRegistry::Bindings::Workers::PushEntityWorker.new
-          expect(worker).to receive(:push_entity_to_global_registry)
-          worker.perform('Namespaced::Person', person.id)
-          expect(worker.model).to be person
-        end
-      end
-
-      context 'with invalid id' do
-        it 'should fail silently' do
-          expect(Namespaced::Person).to receive(:find).with(person.id).and_raise(ActiveRecord::RecordNotFound)
-          expect(GlobalRegistry::Bindings::Workers::PushEntityWorker).not_to receive(:push_entity_to_global_registry)
-
-          worker = GlobalRegistry::Bindings::Workers::PushEntityWorker.new
-          worker.perform(Namespaced::Person, person.id)
-          expect(worker.model).to be nil
-        end
-      end
-    end
-  end
-
-  describe '#push_entity_to_global_registry' do
-    describe Organization do
-      let(:worker) { GlobalRegistry::Bindings::Workers::PushEntityWorker.new organization }
-      context 'and unknown \'fancy_org\' entity_type' do
-        let!(:requests) do
-          [stub_request(:get, 'https://backend.global-registry.org/entity_types')
-            .with(query: { 'filters[name]' => 'fancy_org', '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: 'fancy_org', parent_id: nil, field_type: 'entity' } })
-             .to_return(body: file_fixture('post_entity_types_fancy_org.json'), status: 200),
-           stub_request(:post, 'https://backend.global-registry.org/entity_types')
-             .with(body: { entity_type: { name: 'name', parent_id: '025a1128-3f33-11e7-b876-129bd0521531',
-                                          field_type: 'string' } })
-             .to_return(status: 200),
-           stub_request(:post, 'https://backend.global-registry.org/entity_types')
-             .with(body: { entity_type: { name: 'description', parent_id: '025a1128-3f33-11e7-b876-129bd0521531',
-                                          field_type: 'string' } })
-             .to_return(status: 200),
-           stub_request(:post, 'https://backend.global-registry.org/entity_types')
-             .with(body: { entity_type: { name: 'start_date', parent_id: '025a1128-3f33-11e7-b876-129bd0521531',
-                                          field_type: 'date' } })
-             .to_return(status: 200)]
-        end
-
-        context 'with root level organization' do
-          let(:organization) { create(:organization) }
-          let!(:sub_requests) do
-            [stub_request(:post, 'https://backend.global-registry.org/entities')
-              .with(body: { entity: { fancy_org: { name: 'Organization', description: 'Fancy Organization',
-                                                   start_date: '2001-02-03', parent_id: nil,
-                                                   client_integration_id: organization.id,
-                                                   client_updated_at: '2001-02-03 00:00:00' } } })
-              .to_return(body: file_fixture('post_entities_fancy_org.json'), status: 200)]
-          end
-
-          it 'should create \'fancy_org\' entity_type and push entity to Global Registry' do
-            worker.push_entity_to_global_registry
-            (requests + sub_requests).each { |r| expect(r).to have_been_requested.once }
-            expect(organization.gr_id).to eq 'aebb4170-3f34-11e7-bba6-129bd0521531'
-          end
-        end
-
-        context 'with organization with parent missing global_registry_id' do
-          let(:parent) { create(:organization, name: 'Parent', description: 'Parent Fancy Organization') }
-          let(:organization) { create(:organization, parent: parent) }
-
-          it 'should create \'fancy_org\' entity_type raise an exception' do
-            expect do
-              worker.push_entity_to_global_registry
-              requests.each { |r| expect(r).to have_been_requested.once }
-            end.to raise_error GlobalRegistry::Bindings::ParentEntityMissingGlobalRegistryId,
-                               "Organization(#{organization.id}) has parent entity Organization(#{parent.id}) " \
-                               'missing global_registry_id; will retry.'
-          end
-        end
-
-        context 'organization with an existing parent' do
-          let(:parent) do
-            create :organization, name: 'Parent', description: 'Parent Fancy Organization',
-                                  gr_id: 'cd5da38a-c336-46a7-b818-dcdd51c4acde'
-          end
-          let(:organization) { create(:organization, parent: parent) }
-          let!(:sub_requests) do
-            [stub_request(:post, 'https://backend.global-registry.org/entities')
-              .with(body: { entity: { fancy_org: { name: 'Organization', description: 'Fancy Organization',
-                                                   start_date: '2001-02-03',
-                                                   parent_id: 'cd5da38a-c336-46a7-b818-dcdd51c4acde',
-                                                   client_integration_id: organization.id,
-                                                   client_updated_at: '2001-02-03 00:00:00' } } })
-              .to_return(body: file_fixture('post_entities_fancy_org.json'), status: 200)]
-          end
-
-          it 'should create \'fancy_org\' entity_type and push both entities' do
-            worker.push_entity_to_global_registry
-            (requests + sub_requests).each { |r| expect(r).to have_been_requested.once }
-            expect(parent.gr_id).to eq 'cd5da38a-c336-46a7-b818-dcdd51c4acde'
-            expect(organization.gr_id).to eq 'aebb4170-3f34-11e7-bba6-129bd0521531'
-          end
-        end
-      end
-    end
-
-    describe Namespaced::Person do
-      let(:worker) { GlobalRegistry::Bindings::Workers::PushEntityWorker.new person }
-      let(:entity_body) do
-        { 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'
-                              } } } }
-      end
-      context 'as create' do
-        let(:person) { create(:person, global_registry_fingerprint: 'abc123') }
-
-        context '\'person\' entity_type does not exist' do
-          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_body)
-               .to_return(body: file_fixture('post_entities_person.json'), status: 200)]
-          end
-
-          it 'should create \'person\' entity_type and push entity' do
-            worker.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'
-            expect(person.global_registry_fingerprint).to eq '4c671c203b5dd19cdc1920ba5434cf64'
-          end
-        end
-
-        context '\'person\' entity_type exists' do
-          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_body)
-               .to_return(body: file_fixture('post_entities_person.json'), status: 200)]
-          end
-
-          it 'should skip creating entity_type and push the entity' do
-            worker.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'
-            expect(person.global_registry_fingerprint).to eq '4c671c203b5dd19cdc1920ba5434cf64'
-          end
-        end
-
-        context 'partial \'person\' entity_type exists' do
-          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_body)
-               .to_return(body: file_fixture('post_entities_person.json'), status: 200)]
-          end
-
-          it 'should skip creating entity_type and push the entity' do
-            worker.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'
-            expect(person.global_registry_fingerprint).to eq '4c671c203b5dd19cdc1920ba5434cf64'
-          end
-        end
-
-        context '\'person\' entity_type is cached' do
-          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_body)
-                      .to_return(body: file_fixture('post_entities_person.json'), status: 200)
-            worker.push_entity_to_global_registry
-            expect(request).to have_been_requested.once
-            expect(person.global_registry_id).to eq '22527d88-3cba-11e7-b876-129bd0521531'
-            expect(person.global_registry_fingerprint).to eq '4c671c203b5dd19cdc1920ba5434cf64'
-          end
-        end
-      end
-
-      context 'as an update' do
-        let(:person) do
-          create(:person, global_registry_id: 'f8d20318-2ff2-4a98-a5eb-e9d840508bf1',
-                          global_registry_fingerprint: 'abc123')
-        end
-        context '\'person\' entity_type is cached' do
-          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_body)
-                      .to_return(body: file_fixture('post_entities_person.json'), status: 200)
-            worker.push_entity_to_global_registry
-            expect(request).to have_been_requested.once
-          end
-
-          context 'invalid entity id' do
-            let!(:requests) { [update_request, create_request] }
-            let!(:update_request) do
-              stub_request(:put, 'https://backend.global-registry.org/entities/f8d20318-2ff2-4a98-a5eb-e9d840508bf1')
-                .with(body: entity_body)
-                .to_return(status: 404)
-            end
-            let!(:create_request) do
-              stub_request(:post, 'https://backend.global-registry.org/entities')
-                .with(body: entity_body)
-                .to_return(body: file_fixture('post_entities_person.json'), status: 200)
-            end
-
-            it 'should push entity as create' do
-              worker.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'
-              expect(person.global_registry_fingerprint).to eq '4c671c203b5dd19cdc1920ba5434cf64'
-            end
-
-            context 'response is also not found on create' do
-              let!(:create_request) do
-                stub_request(:post, 'https://backend.global-registry.org/entities')
-                  .with(body: entity_body)
-                  .to_return(status: 404)
-              end
-
-              it 'should raise an error' do
-                expect { worker.push_entity_to_global_registry }.to raise_error(RestClient::NotFound)
-              end
-            end
-          end
-
-          context 'fingerprints match' do
-            it 'should do nothing' do
-              request = stub_request(:put,
-                                     'https://backend.global-registry.org/entities/f8d20318-2ff2-4a98-a5eb-e9d840508bf1')
-                        .with(body: entity_body)
-                        .to_return(body: file_fixture('post_entities_person.json'), status: 200)
-              person.global_registry_fingerprint = '4c671c203b5dd19cdc1920ba5434cf64'
-              worker.push_entity_to_global_registry
-              expect(request).not_to have_been_requested
-            end
-          end
-        end
-      end
-    end
-
-    describe Address do
-      let(:worker) { GlobalRegistry::Bindings::Workers::PushEntityWorker.new address }
-      context 'as create' do
-        context '\'address\' record does not belong to a person' do
-          let(:address) { create(:address) }
-
-          it 'should not create \'address\' entity_type and skip push of entity' do
-            worker.push_entity_to_global_registry
-          end
-        end
-
-        context '\'address\' entity_type does not exist' do
-          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(:get, 'https://backend.global-registry.org/entity_types')
-               .with(query: { 'filters[name]' => 'address',
-                              'filters[parent_id]' => 'ee13a693-3ce7-4c19-b59a-30c8f137acd8' })
-               .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: 'address', parent_id: 'ee13a693-3ce7-4c19-b59a-30c8f137acd8',
-                                            field_type: 'entity' } })
-               .to_return(body: file_fixture('post_entity_types_address.json'), status: 200),
-             stub_request(:post, 'https://backend.global-registry.org/entity_types')
-               .with(body: { entity_type: { name: 'zip', parent_id: 'f5331684-3ca8-11e7-b937-129bd0521531',
-                                            field_type: 'string' } })
-               .to_return(status: 200),
-             stub_request(:post, 'https://backend.global-registry.org/entity_types')
-               .with(body: { entity_type: { name: 'line1', parent_id: 'f5331684-3ca8-11e7-b937-129bd0521531',
-                                            field_type: 'string' } })
-               .to_return(status: 200),
-             stub_request(:post, 'https://backend.global-registry.org/entity_types')
-               .with(body: { entity_type: { name: 'line2', parent_id: 'f5331684-3ca8-11e7-b937-129bd0521531',
-                                            field_type: 'string' } })
-               .to_return(status: 200),
-             stub_request(:post, 'https://backend.global-registry.org/entity_types')
-               .with(body: { entity_type: { name: 'primary', parent_id: 'f5331684-3ca8-11e7-b937-129bd0521531',
-                                            field_type: 'boolean' } })
-               .to_return(status: 200),
-             stub_request(:post, 'https://backend.global-registry.org/entity_types')
-               .with(body: { entity_type: { name: 'postal_code', parent_id: 'f5331684-3ca8-11e7-b937-129bd0521531',
-                                            field_type: 'string' } })
-               .to_return(status: 200)]
-          end
-
-          context '\'address\' record belongs to a person without global registry id' do
-            let(:person) { create(:person) }
-            let(:address) { create(:address, person: person) }
-
-            it 'should create \'address\' entity_type and raise an error' do
-              expect do
-                worker.push_entity_to_global_registry
-              end.to raise_error GlobalRegistry::Bindings::ParentEntityMissingGlobalRegistryId,
-                                 "Address(#{address.id}) has parent entity Namespaced::Person(#{person.id}) " \
-                                 'missing global_registry_id; will retry.'
-              requests.each { |r| expect(r).to have_been_requested.once }
-              expect(person.global_registry_id).to be nil
-              expect(address.global_registry_id).to be nil
-            end
-          end
-
-          context '\'address\' record belongs to an existing person entity' do
-            let(:person) { create(:person, global_registry_id: '22527d88-3cba-11e7-b876-129bd0521531') }
-            let(:address) { create(:address, person: person) }
-            let!(:sub_requests) do
-              [stub_request(:put,
-                            'https://backend.global-registry.org/entities/22527d88-3cba-11e7-b876-129bd0521531')
-                .with(body: { entity: { person: { client_integration_id: person.id,
-                                                  address: {
-                                                    zip: '90265', primary: 'true',
-                                                    line1: '10880 Malibu Point', postal_code: '90265',
-                                                    client_integration_id: address.id,
-                                                    client_updated_at: '2001-02-03 00:00:00'
-                                                  } } } })
-                .to_return(body: file_fixture('put_entities_address.json'), status: 200)]
-            end
-
-            it 'should create \'address\' entity_type and push address entity' do
-              worker.push_entity_to_global_registry
-              (requests + sub_requests).each { |r| expect(r).to have_been_requested.once }
-              expect(address.global_registry_id).to eq '0a594356-3f1c-11e7-bba6-129bd0521531'
-            end
-          end
-        end
-
-        context '\'address\' and \'person\' entity_types exist' do
-          let(:person) { create(:person, global_registry_id: '22527d88-3cba-11e7-b876-129bd0521531') }
-          let(:address) { create(:address, person: person) }
-          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(:put,
-                          'https://backend.global-registry.org/entities/22527d88-3cba-11e7-b876-129bd0521531')
-               .with(body: { entity: { person: { client_integration_id: person.id,
-                                                 address: {
-                                                   zip: '90265', primary: 'true',
-                                                   line1: '10880 Malibu Point', postal_code: '90265',
-                                                   client_integration_id: address.id,
-                                                   client_updated_at: '2001-02-03 00:00:00'
-                                                 } } } })
-               .to_return(body: file_fixture('put_entities_address.json'), status: 200)]
-          end
-
-          context '\'address\' entity_type has partial fields' do
-            let!(:sub_requests) do
-              [stub_request(:get, 'https://backend.global-registry.org/entity_types')
-                .with(query: { 'filters[name]' => 'address',
-                               'filters[parent_id]' => 'ee13a693-3ce7-4c19-b59a-30c8f137acd8' })
-                .to_return(body: file_fixture('get_entity_types_address_partial.json'), status: 200),
-               stub_request(:post, 'https://backend.global-registry.org/entity_types')
-                 .with(body: { entity_type: { name: 'line2', parent_id: 'f5331684-3ca8-11e7-b937-129bd0521531',
-                                              field_type: 'string' } })
-                 .to_return(status: 200),
-               stub_request(:post, 'https://backend.global-registry.org/entity_types')
-                 .with(body: { entity_type: { name: 'primary', parent_id: 'f5331684-3ca8-11e7-b937-129bd0521531',
-                                              field_type: 'boolean' } })
-                 .to_return(status: 200)]
-            end
-
-            it 'should add missing fields and push address entity' do
-              worker.push_entity_to_global_registry
-              (requests + sub_requests).each { |r| expect(r).to have_been_requested.once }
-              expect(address.global_registry_id).to eq '0a594356-3f1c-11e7-bba6-129bd0521531'
-            end
-          end
-
-          context '\'address\' entity_type has all fields' do
-            let!(:sub_requests) do
-              [stub_request(:get, 'https://backend.global-registry.org/entity_types')
-                .with(query: { 'filters[name]' => 'address',
-                               'filters[parent_id]' => 'ee13a693-3ce7-4c19-b59a-30c8f137acd8' })
-                .to_return(body: file_fixture('get_entity_types_address.json'), status: 200)]
-            end
-
-            it 'should push address entity' do
-              worker.push_entity_to_global_registry
-              (requests + sub_requests).each { |r| expect(r).to have_been_requested.once }
-              expect(address.global_registry_id).to eq '0a594356-3f1c-11e7-bba6-129bd0521531'
-            end
-          end
-        end
-      end
-
-      context 'as an update' do
-        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)
-          address_entity_types = JSON.parse(file_fixture('get_entity_types_address.json').read)
-          Rails.cache.write('GlobalRegistry::Bindings::EntityType::address',
-                            address_entity_types['entity_types'].first)
-        end
-        let(:person) { create(:person, global_registry_id: '22527d88-3cba-11e7-b876-129bd0521531') }
-        let(:address) do
-          create(:address, person: person, global_registry_id: '0a594356-3f1c-11e7-bba6-129bd0521531')
-        end
-        let!(:request) do
-          stub_request(:put,
-                       'https://backend.global-registry.org/entities/22527d88-3cba-11e7-b876-129bd0521531')
-            .with(body: { entity: { person: { client_integration_id: person.id,
-                                              address: {
-                                                zip: '90265', primary: 'false',
-                                                line1: '100 Sesame Street', postal_code: '90265',
-                                                client_integration_id: address.id,
-                                                client_updated_at: '2001-02-03 00:00:00'
-                                              } } } })
-            .to_return(response)
-        end
-        let!(:response) { { body: file_fixture('put_entities_address.json'), status: 200 } }
-
-        subject do
-          address.address1 = '100 Sesame Street'
-          address.primary = false
-          worker.push_entity_to_global_registry
-        end
-
-        it 'should push address entity' do
-          expect { subject }.to_not(change { address.global_registry_id })
-          expect(request).to have_been_requested.once
-        end
-
-        context 'response not found' do
-          let!(:response) { { status: 404 } }
-
-          it 'should raise an error' do
-            expect { subject }.to raise_error(RestClient::NotFound)
-            expect(request).to have_been_requested.once
-          end
-        end
-      end
-    end
-
-    describe Community do
-      let(:worker) { GlobalRegistry::Bindings::Workers::PushEntityWorker.new community }
-      let(:community) { create(:community, infobase_id: 234) }
-      let!(:request) do
-        stub_request(:post, 'https://backend.global-registry.org/entities')
-          .with(body: { entity: { community: { name: 'Community', client_integration_id: community.id,
-                                               client_updated_at: '2001-02-03 00:00:00' } } })
-          .to_return(body: file_fixture('post_entities_community.json'), status: 200)
-      end
-
-      it 'should push community entity' do
-        worker.push_entity_to_global_registry
-        expect(request).to have_been_requested.once
-        expect(community.global_registry_id).to eq '6133f6fe-c63a-425a-bb46-68917c689723'
-      end
-    end
-  end
-end