Extract company register

Closes #1079, #916, #1077

test/integration/api/registrant/registrant_api_contacts_test.rb

@@ -5,33 +5,15 @@ class RegistrantApiContactsTest < ApplicationIntegrationTest
   def setup
     super
 
-    @original_registry_time = Setting.days_to_keep_business_registry_cache
-    Setting.days_to_keep_business_registry_cache = 1
-    travel_to Time.zone.parse('2010-07-05')
-
+    @contact = contacts(:john)
     @user = users(:registrant)
     @auth_headers = { 'HTTP_AUTHORIZATION' => auth_token }
   end
 
-  def teardown
-    super
-
-    Setting.days_to_keep_business_registry_cache = @original_registry_time
-    travel_back
-  end
-
-  def test_root_returns_contact_list
-    get '/api/v1/registrant/contacts', {}, @auth_headers
-    assert_equal(200, response.status)
-
-    json_body = JSON.parse(response.body, symbolize_names: true)
-    assert_equal(4, json_body.count)
-    array_of_contact_codes = json_body.map { |x| x[:code] }
-    assert(array_of_contact_codes.include?('william-001'))
-    assert(array_of_contact_codes.include?('jane-001'))
-  end
-
   def test_root_accepts_limit_and_offset_parameters
+    contacts(:william).update!(ident: '1234', ident_type: 'priv', ident_country_code: 'US')
+    assert_equal 3, @user.contacts.size
+
     get '/api/v1/registrant/contacts', { 'limit' => 1, 'offset' => 0 }, @auth_headers
     response_json = JSON.parse(response.body, symbolize_names: true)
     assert_equal(200, response.status)
@@ -39,26 +21,15 @@ class RegistrantApiContactsTest < ApplicationIntegrationTest
 
     get '/api/v1/registrant/contacts', {}, @auth_headers
     response_json = JSON.parse(response.body, symbolize_names: true)
-    assert_equal(4, response_json.count)
+    assert_equal(3, response_json.count)
   end
 
   def test_get_contact_details_by_uuid
-    get '/api/v1/registrant/contacts/0aa54704-d6f7-4ca9-b8ca-2827d9a4e4eb', {}, @auth_headers
-    assert_equal(200, response.status)
+    get api_v1_registrant_contact_path(@contact.uuid), nil, @auth_headers
 
-    contact = JSON.parse(response.body, symbolize_names: true)
-    assert_equal('william@inbox.test', contact[:email])
-  end
-
-  def test_root_returns_503_when_business_registry_is_not_available
-    raise_not_available = -> (a, b) { raise Soap::Arireg::NotAvailableError.new({}) }
-    BusinessRegistryCache.stub :fetch_by_ident_and_cc, raise_not_available do
-      get '/api/v1/registrant/contacts', {}, @auth_headers
-
-      assert_equal(503, response.status)
-      response_json = JSON.parse(response.body, symbolize_names: true)
-      assert_equal({ errors: [base: ['Business Registry not available']] }, response_json)
-    end
+    assert_response :ok
+    response_json = JSON.parse(response.body, symbolize_names: true)
+    assert_equal 'john@inbox.test', response_json[:email]
   end
 
   def test_get_contact_details_by_uuid_returns_404_for_non_existent_contact

test/integration/api/registrant/registrant_api_domains_test.rb

@@ -5,23 +5,12 @@ class RegistrantApiDomainsTest < ApplicationIntegrationTest
   def setup
     super
 
-    @original_registry_time = Setting.days_to_keep_business_registry_cache
-    Setting.days_to_keep_business_registry_cache = 1
-    travel_to Time.zone.parse('2010-07-05')
-
     @domain = domains(:hospital)
     @registrant = @domain.registrant
     @user = users(:registrant)
     @auth_headers = { 'HTTP_AUTHORIZATION' => auth_token }
   end
 
-  def teardown
-    super
-
-    Setting.days_to_keep_business_registry_cache = @original_registry_time
-    travel_back
-  end
-
   def test_get_domain_details_by_uuid
     get '/api/v1/registrant/domains/5edda1a5-3548-41ee-8b65-6d60daf85a37', {}, @auth_headers
     assert_equal(200, response.status)

test/integration/api/registrant/registrant_api_registry_locks_test.rb

@@ -5,22 +5,11 @@ class RegistrantApiRegistryLocksTest < ApplicationIntegrationTest
   def setup
     super
 
-    @original_registry_time = Setting.days_to_keep_business_registry_cache
-    Setting.days_to_keep_business_registry_cache = 1
-    travel_to Time.zone.parse('2010-07-05')
-
     @user = users(:registrant)
     @domain = domains(:airport)
     @auth_headers = { 'HTTP_AUTHORIZATION' => auth_token }
   end
 
-  def teardown
-    super
-
-    Setting.days_to_keep_business_registry_cache = @original_registry_time
-    travel_back
-  end
-
   def test_can_lock_a_not_locked_domain
     post '/api/v1/registrant/domains/2df2c1a1-8f6a-490a-81be-8bdf29866880/registry_lock',
          {}, @auth_headers
@@ -101,11 +90,19 @@ class RegistrantApiRegistryLocksTest < ApplicationIntegrationTest
   end
 
   def test_technical_contact_cannot_lock_a_domain
-    post '/api/v1/registrant/domains/647bcc48-8d5e-4a04-8ce5-2a3cd17b6eab/registry_lock',
-         {}, @auth_headers
+    domain = domains(:shop)
+    contact = contacts(:john)
+    domain.update!(registrant: contacts(:william).becomes(Registrant))
+    domain.tech_contacts = [contact]
+    domain.admin_contacts.clear
+    assert_equal 'US-1234', @user.registrant_ident
+    assert_equal '1234', contact.ident
+    assert_equal 'US', contact.ident_country_code
 
+    post api_v1_registrant_domain_registry_lock_path(domain.uuid), nil, @auth_headers
+
+    assert_response :unauthorized
     response_json = JSON.parse(response.body, symbolize_names: true)
-    assert_equal(401, response.status)
     assert_equal({ errors: [{ base: ['Only administrative contacts can manage registry locks'] }] },
                  response_json)
   end
@@ -123,6 +120,7 @@ class RegistrantApiRegistryLocksTest < ApplicationIntegrationTest
   end
 
   def test_locking_domains_returns_serialized_domain_object
+    travel_to Time.zone.parse('2010-07-05')
     assert_equal 'Best Names', @domain.registrar.name
     assert_equal 'https://bestnames.test', @domain.registrar.website
 

test/integration/api/v1/registrant/contacts/details_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+require 'auth_token/auth_token_creator'
+
+CompanyRegisterClientStub = Struct.new(:any_method) do
+  def representation_rights(citizen_personal_code:, citizen_country_code:)
+    raise CompanyRegister::NotAvailableError
+  end
+end
+
+class RegistrantApiV1ContactDetailsTest < ActionDispatch::IntegrationTest
+  setup do
+    @contact = contacts(:john)
+    @user = users(:registrant)
+  end
+
+  def test_returns_direct_contact_when_company_register_is_unavailable
+    assert_equal '1234', @contact.ident
+    assert_equal Contact::PRIV, @contact.ident_type
+    assert_equal 'US', @contact.ident_country_code
+    assert_equal 'US-1234', @user.registrant_ident
+
+    CompanyRegister::Client.stub(:new, CompanyRegisterClientStub.new) do
+      get api_v1_registrant_contact_path(@contact.uuid), nil, 'HTTP_AUTHORIZATION' => auth_token,
+          'Content-Type' => Mime::JSON.to_s
+    end
+
+    response_json = JSON.parse(response.body, symbolize_names: true)
+    assert_equal '1234', response_json[:ident]
+  end
+
+  def test_unmanaged_contact_cannot_be_accessed
+    assert_equal 'US-1234', @user.registrant_ident
+    @contact.update!(ident: '12345')
+
+    get api_v1_registrant_contact_path(@contact.uuid), nil, 'HTTP_AUTHORIZATION' => auth_token,
+        'Content-Type' => Mime::JSON.to_s
+
+    assert_response :not_found
+    response_json = JSON.parse(response.body, symbolize_names: true)
+    assert_equal ({ errors: [base: ['Contact not found']] }), response_json
+  end
+
+  private
+
+  def auth_token
+    token_creator = AuthTokenCreator.create_with_defaults(@user)
+    hash = token_creator.token_in_hash
+    "Bearer #{hash[:access_token]}"
+  end
+end

test/integration/api/v1/registrant/contacts/list_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+require 'auth_token/auth_token_creator'
+
+CompanyRegisterClientStub = Struct.new(:any_method) do
+  def representation_rights(citizen_personal_code:, citizen_country_code:)
+    raise CompanyRegister::NotAvailableError
+  end
+end
+
+class RegistrantApiV1ContactListTest < ActionDispatch::IntegrationTest
+  setup do
+    @contact = contacts(:john)
+    @user = users(:registrant)
+  end
+
+  def test_returns_direct_contacts
+    delete_indirect_contact
+    assert_equal '1234', @contact.ident
+    assert_equal Contact::PRIV, @contact.ident_type
+    assert_equal 'US', @contact.ident_country_code
+    assert_equal 'US-1234', @user.registrant_ident
+
+    get api_v1_registrant_contacts_path, nil, 'HTTP_AUTHORIZATION' => auth_token,
+        'Content-Type' => Mime::JSON.to_s
+
+    response_json = JSON.parse(response.body, symbolize_names: true)
+    assert_equal 1, response_json.size
+    assert_equal '1234', response_json.first[:ident][:code]
+  end
+
+  def test_returns_indirect_contacts
+    delete_direct_contact
+    @contact = contacts(:acme_ltd)
+    assert_equal 'acme-ltd-001', @contact.code
+
+    get api_v1_registrant_contacts_path, nil, 'HTTP_AUTHORIZATION' => auth_token,
+        'Content-Type' => Mime::JSON.to_s
+
+    response_json = JSON.parse(response.body, symbolize_names: true)
+    assert_equal 1, response_json.size
+    assert_equal 'acme-ltd-001', response_json.first[:code]
+  end
+
+  def test_returns_direct_contacts_when_company_register_is_unavailable
+    assert_equal '1234', @contact.ident
+    assert_equal Contact::PRIV, @contact.ident_type
+    assert_equal 'US', @contact.ident_country_code
+    assert_equal 'US-1234', @user.registrant_ident
+
+    CompanyRegister::Client.stub(:new, CompanyRegisterClientStub.new) do
+      get api_v1_registrant_contacts_path, nil, 'HTTP_AUTHORIZATION' => auth_token,
+          'Content-Type' => Mime::JSON.to_s
+    end
+
+    response_json = JSON.parse(response.body, symbolize_names: true)
+    assert_equal 1, response_json.size
+    assert_equal '1234', response_json.first[:ident][:code]
+  end
+
+  private
+
+  def delete_direct_contact
+    ActiveRecord::Base.connection.disable_referential_integrity { contacts(:john).delete }
+  end
+
+  def delete_indirect_contact
+    ActiveRecord::Base.connection.disable_referential_integrity { contacts(:acme_ltd).delete }
+  end
+
+  def auth_token
+    token_creator = AuthTokenCreator.create_with_defaults(@user)
+    hash = token_creator.token_in_hash
+    "Bearer #{hash[:access_token]}"
+  end
+end

test/integration/api/v1/registrant/contacts/update_test.rb

@@ -6,18 +6,13 @@ class RegistrantApiV1ContactUpdateTest < ActionDispatch::IntegrationTest
     @contact = contacts(:john)
 
     @original_address_processing_setting = Setting.address_processing
-    @original_business_registry_cache_setting = Setting.days_to_keep_business_registry_cache
     @original_fax_enabled_setting = ENV['fax_enabled']
 
-    @current_user = users(:registrant)
-
-    Setting.days_to_keep_business_registry_cache = 1
-    travel_to Time.zone.parse('2010-07-05')
+    @user = users(:registrant)
   end
 
   teardown do
     Setting.address_processing = @original_address_processing_setting
-    Setting.days_to_keep_business_registry_cache = @original_business_registry_cache_setting
     ENV['fax_enabled'] = @original_fax_enabled_setting
   end
 
@@ -52,8 +47,8 @@ class RegistrantApiV1ContactUpdateTest < ActionDispatch::IntegrationTest
   end
 
   def test_update_fax_when_enabled
+    @contact.update!(fax: '+666.6')
     ENV['fax_enabled'] = 'true'
-    @contact = contacts(:william)
 
     patch api_v1_registrant_contact_path(@contact.uuid), { fax: '+777.7' }.to_json,
           'HTTP_AUTHORIZATION' => auth_token,
@@ -101,7 +96,7 @@ class RegistrantApiV1ContactUpdateTest < ActionDispatch::IntegrationTest
   end
 
   def test_address_is_optional_when_enabled
-    @contact = contacts(:william)
+    @contact.update!(street: 'any', zip: 'any', city: 'any', state: 'any', country_code: 'US')
     Setting.address_processing = true
 
     patch api_v1_registrant_contact_path(@contact.uuid), { name: 'any' }.to_json,
@@ -113,18 +108,18 @@ class RegistrantApiV1ContactUpdateTest < ActionDispatch::IntegrationTest
   end
 
   def test_address_cannot_be_updated_when_disabled
-    @contact = contacts(:william)
-    @original_address = @contact.address
+    @contact.update!(street: 'old street')
     Setting.address_processing = false
 
-    patch api_v1_registrant_contact_path(@contact.uuid), { address: { city: 'new city' } }.to_json,
+    patch api_v1_registrant_contact_path(@contact.uuid), { address: { street: 'new street' } }
+                                                           .to_json,
           'HTTP_AUTHORIZATION' => auth_token,
           'Accept' => Mime::JSON,
           'Content-Type' => Mime::JSON.to_s
-
     @contact.reload
+
     assert_response :bad_request
-    assert_equal @original_address, @contact.address
+    assert_not_equal 'new street', @contact.street
 
     error_msg = 'Address processing is disabled and therefore cannot be updated'
     assert_equal ({ errors: [{ address: [error_msg] }] }), JSON.parse(response.body,
@@ -160,10 +155,15 @@ class RegistrantApiV1ContactUpdateTest < ActionDispatch::IntegrationTest
   end
 
   def test_legal_persons_disclosed_attributes_cannot_be_changed
-    business_registry_caches(:one).update!(associated_businesses: %w[1234])
-    @contact.update!(ident_type: Contact::ORG,
-                     ident: '1234',
-                     disclosed_attributes: %w[])
+    @contact = contacts(:acme_ltd)
+
+    # contacts(:acme_ltd).ident
+    assert_equal '1234567', @contact.ident
+
+    assert_equal Contact::ORG, @contact.ident_type
+    assert_equal 'US', @contact.ident_country_code
+    @contact.update!(disclosed_attributes: %w[])
+    assert_equal 'US-1234', @user.registrant_ident
 
     assert_no_changes -> { @contact.disclosed_attributes } do
       patch api_v1_registrant_contact_path(@contact.uuid), { disclosed_attributes: %w[name] }
@@ -222,7 +222,7 @@ class RegistrantApiV1ContactUpdateTest < ActionDispatch::IntegrationTest
   end
 
   def test_unmanaged_contact_cannot_be_updated
-    @current_user.update!(registrant_ident: 'US-1234')
+    assert_equal 'US-1234', @user.registrant_ident
     @contact.update!(ident: '12345')
 
     patch api_v1_registrant_contact_path(@contact.uuid), { name: 'new name' }.to_json,
@@ -252,7 +252,7 @@ class RegistrantApiV1ContactUpdateTest < ActionDispatch::IntegrationTest
   private
 
   def auth_token
-    token_creator = AuthTokenCreator.create_with_defaults(@current_user)
+    token_creator = AuthTokenCreator.create_with_defaults(@user)
     hash = token_creator.token_in_hash
     "Bearer #{hash[:access_token]}"
   end