Merge pull request #740 from internetee/registry-661

Registry 661

test/fixtures/contacts.yml

@@ -42,6 +42,17 @@ acme_ltd:
   code: acme-ltd-001
   auth_info: 720b3c
 
+jack:
+  name: Jack
+  email: jack@inbox.test
+  phone: '+555.555'
+  ident: 1234
+  ident_type: org
+  registrar: goodnames
+  ident_country_code: US
+  code: jack-001
+  auth_info: e2c440
+
 invalid:
   name: any
   code: any

test/fixtures/domains.yml

@@ -28,6 +28,16 @@ library:
   period: 1
   period_unit: m
 
+metro:
+  name: metro.test
+  name_dirty: metro.test
+  registrar: goodnames
+  registrant: jack
+  transfer_code: 1071ad
+  valid_to: 2010-07-05
+  period: 1
+  period_unit: m
+
 invalid:
   name: invalid.test
   transfer_code: any

test/fixtures/nameservers.yml

@@ -0,0 +1,23 @@
+shop_ns1:
+  hostname: ns1.bestnames.test
+  ipv4:
+    - 192.0.2.1
+  ipv6:
+    - 2001:db8::1
+  domain: shop
+
+shop_ns2:
+  hostname: ns2.bestnames.test
+  ipv4:
+    - 192.0.2.2
+  ipv6:
+    - 2001:db8::2
+  domain: shop
+
+airport_ns1:
+  hostname: ns1.bestnames.test
+  domain: airport
+
+metro_ns1:
+  hostname: ns1.bestnames.test
+  domain: metro

test/integration/api/nameservers/put_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class APINameserversPutTest < ActionDispatch::IntegrationTest
+  def test_replaces_registrar_nameservers
+    old_nameserver_ids = [nameservers(:shop_ns1).id,
+                          nameservers(:airport_ns1).id,
+                          nameservers(:metro_ns1).id]
+    request_params = { format: :json, data: { type: 'nameserver', id: 'ns1.bestnames.test',
+                                              attributes: { hostname: 'ns55.bestnames.test' } } }
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+    assert_empty (old_nameserver_ids & registrars(:bestnames).nameservers(true).ids)
+  end
+
+  def test_saves_all_attributes
+    request_params = { format: :json, data: { type: 'nameserver', id: 'ns1.bestnames.test',
+                                              attributes: { hostname: 'ns55.bestnames.test',
+                                                            ipv4: ['192.0.2.55'],
+                                                            ipv6: ['2001:db8::55'] } } }
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+
+    new_nameserver = domains(:shop).nameservers.find_by(hostname: 'ns55.bestnames.test')
+    assert_equal ['192.0.2.55'], new_nameserver.ipv4
+    assert_equal ['2001:DB8::55'], new_nameserver.ipv6
+  end
+
+  def test_keeps_other_nameserver_intact
+    request_params = { format: :json, data: { type: 'nameserver', id: 'ns1.bestnames.test',
+                                              attributes: { hostname: 'ns55.bestnames.test' } } }
+
+    other_nameserver_hash = nameservers(:shop_ns2).attributes
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+    assert_equal other_nameserver_hash, nameservers(:shop_ns2).reload.attributes
+  end
+
+  def test_keeps_other_registrar_nameservers_intact
+    request_params = { format: :json, data: { type: 'nameserver', id: 'ns1.bestnames.test',
+                                              attributes: { hostname: 'ns55.bestnames.test' } } }
+
+    nameserver_hash = nameservers(:metro_ns1).attributes
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+    assert_equal nameserver_hash, nameservers(:metro_ns1).reload.attributes
+  end
+
+  def test_returns_new_nameserver_record
+    request_params = { format: :json, data: { type: 'nameserver', id: 'ns1.bestnames.test',
+                                              attributes: { hostname: 'ns55.bestnames.test',
+                                                            ipv4: ['192.0.2.55'],
+                                                            ipv6: ['2001:db8::55'] } } }
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+
+    assert_response 200
+    assert_equal ({ data: { type: 'nameserver',
+                            id: 'ns55.bestnames.test',
+                            attributes: { hostname: 'ns55.bestnames.test',
+                                          ipv4: ['192.0.2.55'],
+                                          ipv6: ['2001:db8::55'] } } }),
+                 JSON.parse(response.body, symbolize_names: true)
+  end
+
+  def test_optional_params
+    request_params = { format: :json, data: { type: 'nameserver', id: 'ns1.bestnames.test',
+                                              attributes: { hostname: 'ns55.bestnames.test' } } }
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+    assert_response 200
+  end
+
+  def test_non_existent_nameserver_hostname
+    request_params = { format: :json, data: { type: 'nameserver', id: 'non-existent.test',
+                                              attributes: { hostname: 'any.bestnames.test' } } }
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+
+    assert_response 404
+    assert_equal ({ errors: [{ title: 'Hostname non-existent.test does not exist' }] }),
+                 JSON.parse(response.body, symbolize_names: true)
+  end
+
+  def test_invalid_request_params
+    request_params = { format: :json, data: { type: 'nameserver', id: 'ns1.bestnames.test',
+                                              attributes: { hostname: '' } } }
+    put '/repp/v1/registrar/nameservers', request_params, { 'HTTP_AUTHORIZATION' => http_auth_key }
+
+    assert_response 400
+    assert_equal ({ errors: [{ title: 'Hostname is missing' }] }),
+                 JSON.parse(response.body, symbolize_names: true)
+  end
+
+  def test_unauthenticated
+    put '/repp/v1/registrar/nameservers'
+    assert_response 401
+  end
+
+  private
+
+  def http_auth_key
+    ActionController::HttpAuthentication::Basic.encode_credentials('test_bestnames', 'testtest')
+  end
+end

test/integration/epp/domain/create/nameservers_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class EppDomainCreateNameserversTest < ActionDispatch::IntegrationTest
+  # Glue record requirement
+  def test_nameserver_ip_address_is_required_if_hostname_is_under_the_same_domain
+    request_xml = <<-XML
+      <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+      <epp xmlns="https://epp.tld.ee/schema/epp-ee-1.0.xsd">
+        <command>
+          <create>
+            <domain:create xmlns:domain="https://epp.tld.ee/schema/domain-eis-1.0.xsd">
+              <domain:name>new.test</domain:name>
+              <domain:ns>
+                <domain:hostAttr>
+                  <domain:hostName>ns1.new.test</domain:hostName>
+                </domain:hostAttr>
+              </domain:ns>
+              <domain:registrant>john-001</domain:registrant>
+            </domain:create>
+          </create>
+          <extension>
+            <eis:extdata xmlns:eis="https://epp.tld.ee/schema/eis-1.0.xsd">
+              <eis:legalDocument type="pdf">test</eis:legalDocument>
+            </eis:extdata>
+          </extension>
+        </command>
+      </epp>
+    XML
+
+    assert_no_difference 'Domain.count' do
+      post '/epp/command/create', { frame: request_xml }, { 'HTTP_COOKIE' => 'session=api_bestnames' }
+    end
+    assert_equal '2003', Nokogiri::XML(response.body).at_css('result')[:code]
+  end
+end

test/integration/registrar/nameserver_replacement_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class RegistrarNameserverReplacementTest < ActionDispatch::IntegrationTest
+  def setup
+    WebMock.reset!
+    login_as users(:api_goodnames)
+  end
+
+  def test_replaces_current_registrar_nameservers
+    request_body = { data: { type: 'nameserver',
+                             id: 'ns1.bestnames.test',
+                             attributes: { hostname: 'new-ns.bestnames.test',
+                                           ipv4: %w[192.0.2.55 192.0.2.56],
+                                           ipv6: %w[2001:db8::55 2001:db8::56] } } }
+    request_stub = stub_request(:put, /registrar\/nameservers/).with(body: request_body,
+                                                                     headers: { 'Content-type' => 'application/json' },
+                                                                     basic_auth: ['test_goodnames', 'testtest'])
+                     .to_return(body: { data: [{
+                                                 type: 'nameserver',
+                                                 id: 'new-ns.bestnames.test'
+                                               }] }.to_json, status: 200)
+
+    visit registrar_domains_url
+    click_link 'Replace nameserver'
+
+    fill_in 'Old hostname', with: 'ns1.bestnames.test'
+    fill_in 'New hostname', with: 'new-ns.bestnames.test'
+    fill_in 'ipv4', with: "192.0.2.55\n192.0.2.56"
+    fill_in 'ipv6', with: "2001:db8::55\n2001:db8::56"
+    click_on 'Replace nameserver'
+
+    assert_requested request_stub
+    assert_current_path registrar_domains_path
+    assert_text 'Nameserver have been successfully replaced'
+  end
+
+  def test_fails_gracefully
+    stub_request(:put, /registrar\/nameservers/).to_return(status: 400,
+                                                           body: { errors: [{ title: 'epic fail' }] }.to_json,
+                                                           headers: { 'Content-type' => 'application/json' })
+
+    visit registrar_domains_url
+    click_link 'Replace nameserver'
+
+    fill_in 'Old hostname', with: 'old hostname'
+    fill_in 'New hostname', with: 'new hostname'
+    fill_in 'ipv4', with: 'ipv4'
+    fill_in 'ipv6', with: 'ipv6'
+    click_on 'Replace nameserver'
+
+    assert_text 'epic fail'
+    assert_field 'Old hostname', with: 'old hostname'
+    assert_field 'New hostname', with: 'new hostname'
+    assert_field 'ipv4', with: 'ipv4'
+    assert_field 'ipv6', with: 'ipv6'
+  end
+end

test/models/nameserver/glue_record_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class NameserverGlueRecordTest < ActiveSupport::TestCase
+  def setup
+    @nameserver = nameservers(:shop_ns1)
+  end
+
+  def test_invalid_without_ip_if_glue_record_is_required
+    @nameserver.hostname = 'ns1.shop.test'
+    @nameserver.ipv4 = @nameserver.ipv6 = ''
+    assert @nameserver.invalid?
+    assert_includes @nameserver.errors.full_messages, 'Either IPv4 or IPv6 is required' \
+    ' for glue record generation'
+  end
+
+  def test_valid_with_ip_if_glue_record_is_required
+    @nameserver.hostname = 'ns1.shop.test'
+    @nameserver.ipv4 = ['192.0.2.1']
+    @nameserver.ipv6 = ''
+    assert @nameserver.valid?
+  end
+
+  def test_valid_without_ip_if_glue_record_is_not_required
+    @nameserver.ipv4 = @nameserver.ipv6 = ''
+    assert @nameserver.valid?
+  end
+end

test/models/nameserver_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class NameserverTest < ActiveSupport::TestCase
+  def setup
+    @nameserver = nameservers(:shop_ns1)
+  end
+
+  def test_valid
+    assert @nameserver.valid?
+  end
+
+  def test_invalid_without_domain
+    @nameserver.domain = nil
+    assert @nameserver.invalid?
+  end
+
+  def test_invalid_without_hostname
+    @nameserver.hostname = ''
+    assert @nameserver.invalid?
+  end
+
+  def test_hostname_format_validation
+    @nameserver.hostname = 'foo.bar'
+    assert @nameserver.valid?
+
+    @nameserver.hostname = 'äöüõšž.ÄÖÜÕŠŽ.umlauts'
+    assert @nameserver.valid?
+
+    @nameserver.hostname = 'foo_bar'
+    assert @nameserver.invalid?
+  end
+
+  def test_ipv4_format_validation
+    @nameserver.ipv4 = ['192.0.2.1']
+    assert @nameserver.valid?
+
+    @nameserver.ipv4 = ['0.0.0.256']
+    assert @nameserver.invalid?
+
+    @nameserver.ipv4 = ['192.168.0.0/24']
+    assert @nameserver.invalid?
+  end
+
+  def test_ipv6_format_validation
+    @nameserver.ipv6 = ['2001:db8::1']
+    assert @nameserver.valid?
+
+    @nameserver.ipv6 = ['3ffe:0b00:0000:0001:0000:0000:000a']
+    assert @nameserver.invalid?
+  end
+
+  def test_hostnames
+    assert_equal %w[ns1.bestnames.test
+      ns2.bestnames.test
+      ns1.bestnames.test
+      ns1.bestnames.test], Nameserver.hostnames
+  end
+
+  def test_normalizes_hostname
+    @nameserver.hostname = ' ns1.bestnameS.test.'
+    @nameserver.validate
+    assert_equal 'ns1.bestnames.test', @nameserver.hostname
+  end
+
+  def test_normalizes_ipv4
+    @nameserver.ipv4 = [' 192.0.2.1']
+    @nameserver.validate
+    assert_equal ['192.0.2.1'], @nameserver.ipv4
+  end
+
+  def test_normalizes_ipv6
+    @nameserver.ipv6 = [' 2001:db8::1']
+    @nameserver.validate
+    assert_equal ['2001:DB8::1'], @nameserver.ipv6
+  end
+
+  def test_encodes_hostname_to_punycode
+    @nameserver.hostname = 'ns1.münchen.de'
+    assert_equal 'ns1.xn--mnchen-3ya.de', @nameserver.hostname_puny
+  end
+end